INitial add

28 files changed, 3803 insertions, 0 deletions

diff --git a/apps/JAWS/PROTOTYPE/HTTP_10.cpp b/apps/JAWS/PROTOTYPE/HTTP_10.cpp
new file mode 100644
index 00000000000..e4644c78fdf
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/HTTP_10.cpp
@@ -0,0 +1,21 @@
+// $Id$
+
+#include "JAWS/HTTP_10.h"
+
+JAWS_HTTP_10_Read_Task::JAWS_HTTP_10_Read_Task (void)
+{
+}
+
+JAWS_HTTP_10_Read_Task::~JAWS_HTTP_10_Read_Task (void)
+{
+}
+
+int
+JAWS_HTTP_10_Read_Task::handle_put (JAWS_Data_Block *data, ACE_Time_Value *)
+{
+  JAWS_Dispatch_Policy *policy = data->policy ();
+  JAWS_IO_Handler *handler = data->handler ();
+  JAWS_Pipeline_Handler *task = data->task ();
+
+  JAWS_IO *io = policy->io ();
+}
diff --git a/apps/JAWS/PROTOTYPE/HTTP_10.h b/apps/JAWS/PROTOTYPE/HTTP_10.h
new file mode 100644
index 00000000000..acf174e2aa7
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/HTTP_10.h
@@ -0,0 +1,20 @@
+/* -*- c++ -*- */
+// $Id$
+
+#if !defined (JAWS_HTTP_10_H)
+#define JAWS_HTTP_10_H
+
+#include "JAWS/Data_Block.h"
+
+class JAWS_HTTP_10_Read_Task : public JAWS_Pipeline_Handler
+{
+public:
+  JAWS_HTTP_10_Read_Task (void);
+  virtual ~JAWS_HTTP_10_Read_Task (void);
+
+  virtual int handle_put (JAWS_Data_Block *data, ACE_Time_Value *tv)
+
+private:
+};
+
+#endif /* !defined (JAWS_HTTP_10_H) */
diff --git a/apps/JAWS/PROTOTYPE/HTTP_Policy.cpp b/apps/JAWS/PROTOTYPE/HTTP_Policy.cpp
new file mode 100644
index 00000000000..9b8d3dd36a6
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/HTTP_Policy.cpp
@@ -0,0 +1,15 @@
+// $Id$
+
+#include "HTTP_Policy.h"
+
+HTTP_Policy::HTTP_Policy (JAWS_Concurrency *concurrency)
+  : concurrency_ (concurrency)
+{
+}
+
+JAWS_Concurrency_Base *
+HTTP_Policy update (void *)
+{
+  /* for now, we always return the same concurrency strategy */
+  returh this->concurrency_;
+}
diff --git a/apps/JAWS/PROTOTYPE/HTTP_Policy.h b/apps/JAWS/PROTOTYPE/HTTP_Policy.h
new file mode 100644
index 00000000000..38e4314b272
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/HTTP_Policy.h
@@ -0,0 +1,21 @@
+/* -*- c++ -*- */
+// $Id$
+
+#if !defined (HTTP_POLICY_H)
+#define HTTP_POLICY_H
+
+#include "JAWS/Concurrency.h"
+
+/* create a policy */
+class HTTP_Policy : public JAWS_Dispatch_Policy
+{
+public:
+  HTTP_Policy (JAWS_Concurrency_Base *concurrency);
+  virtual JAWS_Concurrency_Base * update (void *state = 0);
+
+private:
+  JAWS_Concurrency_Base *concurrency_;
+};
+
+
+#endif /* !defined (HTTP_POLICY_H) */
diff --git a/apps/JAWS/PROTOTYPE/JAWS/Concurrency.cpp b/apps/JAWS/PROTOTYPE/JAWS/Concurrency.cpp
new file mode 100644
index 00000000000..107ce4a68dc
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/Concurrency.cpp
@@ -0,0 +1,126 @@
+// $Id$
+
+#include "JAWS/Concurrency.h"
+#include "JAWS/Pipeline.h"
+#include "JAWS/Policy.h"
+#include "JAWS/Data_Block.h"
+
+JAWS_Concurrency_Base::JAWS_Concurrency_Base (void)
+{
+}
+
+int
+JAWS_Concurrency_Base::put (ACE_Message_Block *mb, ACE_Time_Value *tv)
+{
+  return this->putq (mb, tv);
+}
+
+int
+JAWS_Concurrency_Base::svc (void)
+{
+  int result = 0;
+
+  for (;;)
+    {
+      ACE_Message_Block *mb;
+
+      // At this point we could set a timeout value so that the
+      // threading strategy can delete a thread if there is nothing to
+      // do.  Carefully think how to implement it so you don't leave
+      // yourself with 0 threads.
+
+      result = this->getq (mb);
+
+      // Use a NULL message block to indicate that the thread should shut
+      // itself down
+      if (result == -1 || mb == 0)
+        break;
+
+      do
+        {
+          JAWS_Data_Block *db;
+          JAWS_Pipeline_Task *task;
+
+          db = ACE_dynamic_cast (JAWS_Data_Block *, mb->data_block ());
+          task = db->task ();
+
+          // Use a NULL task to make the thread recycle now
+          if (task == 0)
+            break;
+
+          result = task->put (mb);
+          if (result == -1)
+            ACE_ERROR ((LM_ERROR, "%p\n", "JAWS_Concurrency_Base::svc"));
+        }
+      while (result == 0);
+    }
+  return 0;
+}
+
+JAWS_Dispatcher::JAWS_Dispatcher (void)
+  : policy_(0)
+{
+}
+
+int
+JAWS_Dispatcher::dispatch (ACE_Message_Block *mb)
+{
+  return this->policy ()->concurrency ()->put (mb);
+}
+
+JAWS_Dispatch_Policy *
+JAWS_Dispatcher::policy (void)
+{
+  return this->policy_;
+}
+
+JAWS_Dispatch_Policy *
+JAWS_Dispatcher::policy (JAWS_Dispatch_Policy *p)
+{
+  this->policy_ = p;
+  return this->policy_;
+}
+
+int
+JAWS_Thread_Pool_Task::open (long flags, int nthreads, int maxthreads)
+{
+  this->nthreads_ = nthreads;
+  this->maxthreads_ = maxthreads;
+
+  if (this->activate (flags, nthreads) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "JAWS_Thread_Pool_Task::activate"),
+                      -1);
+}
+
+int
+JAWS_Thread_Per_Task::open (long flags, int maxthreads)
+{
+  this->flags_ = flags;
+  this->maxthreads_ = maxthreads;
+  return 0;
+}
+
+int
+JAWS_Thread_Per_Task::put (ACE_Message_Block *mb, ACE_Time_Value *tv)
+{
+  const int force_active = 1;
+  const int nthreads = 1;
+
+  if (this->activate (this->flags_, nthreads, force_active) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "JAWS_Thread_Pool_Task::activate"),
+                      -1);
+
+  this->putq (mb, tv);
+
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
+template class ACE_Singleton<JAWS_Dispatcher, ACE_SYNCH_MUTEX>;
+template class ACE_Singleton<JAWS_Thread_Pool_Task, ACE_SYNCH_MUTEX>;
+template class ACE_Singleton<JAWS_Thread_Per_Task, ACE_SYNCH_MUTEX>;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate  ACE_Singleton<JAWS_Dispatcher, ACE_SYNCH_MUTEX>
+#pragma instantiate  ACE_Singleton<JAWS_Thread_Pool_Task, ACE_SYNCH_MUTEX>
+#pragma instantiate  ACE_Singleton<JAWS_Thread_Per_Task, ACE_SYNCH_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
diff --git a/apps/JAWS/PROTOTYPE/JAWS/Concurrency.h b/apps/JAWS/PROTOTYPE/JAWS/Concurrency.h
new file mode 100644
index 00000000000..50c8e3f8e28
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/Concurrency.h
@@ -0,0 +1,101 @@
+/* -*- c++ -*- */
+// $Id$
+
+#if !defined (JAWS_CONCURRENCY_H)
+#define JAWS_CONCURRENCY_H
+
+#include "ace/Singleton.h"
+#include "ace/Synch.h"
+#include "ace/Task.h"
+
+#include "JAWS/IO.h"
+
+class JAWS_Dispatch_Policy;
+
+class JAWS_Concurrency_Base : public ACE_Task<ACE_MT_SYNCH>
+  // = TITLE
+  //     Base class for different concurrency models
+  //
+  // = DESCRIPTION
+  //     Provides a default implementaion of the virtual put() method
+  //     which calls putq(), but can be overloaded to do something
+  //     synchronously, such as call put_next().
+
+{
+public:
+  JAWS_Concurrency_Base (void);
+
+  virtual int put (ACE_Message_Block *mb, ACE_Time_Value *tv = 0);
+  virtual int svc (void);
+};
+
+class JAWS_Dispatcher
+  // = TITLE
+  //     The class that is responsible to delivering events to the
+  //     appropriate concurrency mechanism.
+  //
+  // = DESCRIPTION
+  //     JAWS_IO_Handler calls into the dispatcher so that the completed
+  //     IO can find a thread to take care of it.
+{
+public:
+  JAWS_Dispatcher (void);
+
+  int dispatch (ACE_Message_Block *mb);
+  JAWS_Dispatch_Policy *policy (void);
+  JAWS_Dispatch_Policy *policy (JAWS_Dispatch_Policy *p);
+
+private:
+  JAWS_Dispatch_Policy *policy_;
+};
+
+class JAWS_Thread_Pool_Task : public JAWS_Concurrency_Base
+  // = TITLE
+  //     Used to implement Thread Pool Concurrency Strategy
+  //
+  // = DESCRIPTION
+  //     This task is created to hold a pool of threads that receive
+  //     requests through the message queue.
+{
+public:
+  virtual int open (long flags = THR_NEW_LWP,
+                    int nthreads = 5, int maxthreads = 20);
+  // Initiate the thread_pool task
+
+private:
+  int nthreads_;
+  int maxthreads_;
+};
+
+class JAWS_Thread_Per_Task : public JAWS_Concurrency_Base
+  // = TITLE
+  //     Used to implement Thread Per Request Concurrency Strategy
+  //
+  // = DESCRIPTION
+  //     As each new message arrives from the queue, a new thread is
+  //     spawned to handle it.  This is done by overloading put to call
+  //     activate.
+{
+public:
+  JAWS_Thread_Per_Task (long flags = THR_NEW_LWP, int maxthreads = 20);
+
+  virtual int open (long flags = THR_NEW_LWP, int maxthreads = 20);
+  // Initiate the thread_per task
+
+  virtual int put (ACE_Message_Block *mb, ACE_Time_Value *tv = 0);
+
+private:
+  long flags_;
+  int maxthreads_;
+};
+
+typedef ACE_Singleton<JAWS_Dispatcher, ACE_SYNCH_MUTEX>
+        JAWS_Dispatcher_Singleton;
+
+typedef ACE_Singleton<JAWS_Thread_Pool_Task, ACE_SYNCH_MUTEX>
+        JAWS_Thread_Pool_Singleton;
+
+typedef ACE_Singleton<JAWS_Thread_Per_Task, ACE_SYNCH_MUTEX>
+        JAWS_Thread_Per_Singleton;
+
+#endif /* !defined (JAWS_CONCURRENCY_H) */
diff --git a/apps/JAWS/PROTOTYPE/JAWS/Data_Block.cpp b/apps/JAWS/PROTOTYPE/JAWS/Data_Block.cpp
new file mode 100644
index 00000000000..4225659b5c0
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/Data_Block.cpp
@@ -0,0 +1,46 @@
+// $Id$
+
+#include "JAWS/Data_Block.h"
+#include "JAWS/Policy.h"
+
+JAWS_Pipeline_Handler *
+JAWS_Data_Block::task (void)
+{
+  return this->task_;
+}
+
+JAWS_IO_Handler *
+JAWS_Data_Block::io_handler (void)
+{
+  return this->io_handler_;
+}
+
+JAWS_Dispatch_Policy *
+JAWS_Data_Block::policy (void)
+{
+  return this->policy_;
+}
+
+void
+JAWS_Data_Block::task (JAWS_Pipeline_Handler *taskp)
+{
+  this->task_ = taskp;
+}
+
+void
+JAWS_Data_Block::io_handler (JAWS_IO_Handler *handlerp)
+{
+  this->io_handler_ = handlerp;
+}
+
+void
+JAWS_Data_Block::policy (JAWS_Dispatch_Policy *policyp)
+{
+  this->policy_ = policyp;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
+template class JAWS_Pipeline_Abstract_Handler<JAWS_Data_Block>;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate JAWS_Pipeline_Abstract_Handler<JAWS_Data_Block>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
diff --git a/apps/JAWS/PROTOTYPE/JAWS/Data_Block.h b/apps/JAWS/PROTOTYPE/JAWS/Data_Block.h
new file mode 100644
index 00000000000..62dcdf0a66b
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/Data_Block.h
@@ -0,0 +1,36 @@
+/* -*- c++ -*- */
+// $Id$
+
+#if !defined (JAWS_DATA_BLOCK_H)
+#define JAWS_DATA_BLOCK_H
+
+#include "ace/Singleton.h"
+#include "JAWS/Pipeline.h"
+
+class JAWS_IO_Handler;
+class JAWS_Dispatch_Policy;
+class JAWS_Data_Block;
+
+typedef JAWS_Pipeline_Abstract_Handler<JAWS_Data_Block>
+        JAWS_Pipeline_Handler;
+
+class JAWS_Data_Block : public ACE_Data_Block
+// = TITLE
+//   Defines the communication unit between pipeline components
+{
+public:
+  JAWS_Pipeline_Handler *task (void);
+  JAWS_IO_Handler *io_handler (void);
+  JAWS_Dispatch_Policy *policy (void);
+
+  void task (JAWS_Pipeline_Handler *taskp);
+  void io_handler (JAWS_IO_Handler * handlerp);
+  void policy (JAWS_Dispatch_Policy * policyp);
+
+private:
+  JAWS_IO_Handler *io_handler_;
+  JAWS_Dispatch_Policy *policy_;
+  JAWS_Pipeline_Handler *task_;
+};
+
+#endif /* !defined (JAWS_DATA_BLOCK_H) */
diff --git a/apps/JAWS/PROTOTYPE/JAWS/IO.cpp b/apps/JAWS/PROTOTYPE/JAWS/IO.cpp
new file mode 100644
index 00000000000..b499e459448
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/IO.cpp
@@ -0,0 +1,450 @@
+// $Id$
+
+#include "JAWS/IO.h"
+#include "JAWS/IO_Handler.h"
+#include "JAWS/IO_Acceptor.h"
+
+// #include "HTTP_Helpers.h"
+
+#include "ace/Message_Block.h"
+#include "ace/SOCK_Stream.h"
+#include "ace/Filecache.h"
+
+JAWS_IO::JAWS_IO (void)
+  : handle_ (ACE_INVALID_HANDLE),
+    handler_ (0),
+    inet_addr_ (0),
+    acceptor_ (0)
+{
+}
+
+JAWS_IO::~JAWS_IO (void)
+{
+}
+
+#if 0
+ACE_HANDLE
+JAWS_IO::handle (void)
+{
+  return this->handle_;
+}
+
+void
+JAWS_IO::handle (ACE_HANDLE handle)
+{
+  this->handle_ = handle;
+}
+
+void
+JAWS_IO::handler (JAWS_IO_Handler *handler)
+{
+  this->handler_ = handler;
+}
+
+void
+JAWS_IO::acceptor (JAWS_IO_Acceptor *acceptor)
+{
+  this->acceptor_ = acceptor;
+}
+#endif /* 0 */
+
+JAWS_Synch_IO::JAWS_Synch_IO (void)
+{
+  this->acceptor_ = JAWS_IO_Synch_Acceptor_Singleton::instance ();
+}
+
+JAWS_Synch_IO::~JAWS_Synch_IO (void)
+{
+  ACE_OS::closesocket (this->handle_);
+}
+
+void
+JAWS_Synch_IO::accept (JAWS_IO_Handler *ioh)
+{
+  ACE_SOCK_Stream new_stream;
+  if (this->acceptor_->accept (new_stream) == -1)
+    ioh->accept_error ();
+  else
+    ioh->accept_complete (new_stream.get_handle ());
+}
+
+void
+JAWS_Synch_IO::read (JAWS_IO_Handler *ioh,
+                     ACE_Message_Block &mb,
+                     int size)
+{
+  ACE_SOCK_Stream stream;
+
+  stream.set_handle (ioh->handle ());
+  int result = stream.recv (mb.wr_ptr (), size);
+
+  if (result <= 0)
+    ioh->read_error ();
+  else
+    {
+      mb.wr_ptr (result);
+      ioh->read_complete (mb);
+    }
+}
+
+void
+JAWS_Synch_IO::receive_file (JAWS_IO_Handler *ioh,
+                             const char *filename,
+                             void *initial_data,
+                             int initial_data_length,
+                             int entire_length)
+{
+  ACE_Filecache_Handle handle (filename, entire_length);
+
+  int result = handle.error ();
+
+  if (result == ACE_Filecache_Handle::SUCCESS)
+    {
+      ACE_SOCK_Stream stream;
+      stream.set_handle (ioh->handle ());
+
+      int bytes_to_memcpy = ACE_MIN (entire_length, initial_data_length);
+      ACE_OS::memcpy (handle.address (), initial_data, bytes_to_memcpy);
+
+      int bytes_to_read = entire_length - bytes_to_memcpy;
+
+      int bytes = stream.recv_n ((char *)
+                                 handle.address () + initial_data_length,
+                                 bytes_to_read);
+      if (bytes == bytes_to_read)
+        ioh->receive_file_complete ();
+      else
+        result = -1;
+    }
+
+  if (result != ACE_Filecache_Handle::SUCCESS)
+    ioh->receive_file_error (result);
+}
+
+void
+JAWS_Synch_IO::transmit_file (JAWS_IO_Handler *ioh,
+                              const char *filename,
+                              const char *header,
+                              int header_size,
+                              const char *trailer,
+                              int trailer_size)
+{
+  ACE_Filecache_Handle handle (filename);
+
+  int result = handle.error ();
+
+  if (result == ACE_Filecache_Handle::SUCCESS)
+    {
+#if defined (ACE_JAWS_BASELINE)
+      ACE_SOCK_Stream stream;
+      stream.set_handle (ioh->handle ());
+
+      if ((stream.send_n (header, header_size) == header_size)
+          && ((u_long) stream.send_n (handle.address (), handle.size ())
+              == handle.size ())
+          && (stream.send_n (trailer, trailer_size) == trailer_size))
+        this->handler_->transmit_file_complete ();
+      else
+        result = -1;
+#else
+      // Attempting to use writev
+      // Is this faster?
+      struct iovec iov[3];
+      int iovcnt = 0;
+      if (header_size > 0)
+        {
+          iov[iovcnt].iov_base = (char *) header;
+          iov[iovcnt].iov_len = header_size;
+          iovcnt++;
+        }
+      if (handle.size () > 0)
+        {
+          iov[iovcnt].iov_base = (char *) handle.address ();
+          iov[iovcnt].iov_len = handle.size ();
+          iovcnt++;
+        }
+      if (trailer_size > 0)
+        {
+          iov[iovcnt].iov_base = (char *) trailer;
+          iov[iovcnt].iov_len = trailer_size;
+          iovcnt++;
+        }
+      if (ACE_OS::writev (ioh->handle (), iov, iovcnt) < 0)
+        result = -1;
+      else
+        ioh->transmit_file_complete ();
+#endif /* ACE_JAWS_BASELINE */
+    }
+
+  if (result != ACE_Filecache_Handle::SUCCESS)
+    ioh->transmit_file_error (result);
+}
+
+void
+JAWS_Synch_IO::send_confirmation_message (JAWS_IO_Handler *ioh,
+                                          const char *buffer,
+                                          int length)
+{
+  this->send_message (ioh, buffer, length);
+  ioh->confirmation_message_complete ();
+}
+
+void
+JAWS_Synch_IO::send_error_message (JAWS_IO_Handler *ioh,
+                                   const char *buffer,
+                                   int length)
+{
+  this->send_message (ioh, buffer, length);
+  ioh->error_message_complete ();
+}
+
+void
+JAWS_Synch_IO::send_message (JAWS_IO_Handler *ioh,
+                             const char *buffer,
+                             int length)
+{
+  ACE_SOCK_Stream stream;
+  stream.set_handle (ioh->handle ());
+  stream.send_n (buffer, length);
+}
+
+// This only works on Win32
+#if defined (ACE_WIN32)
+
+JAWS_Asynch_IO::JAWS_Asynch_IO (void)
+{
+}
+
+JAWS_Asynch_IO::~JAWS_Asynch_IO (void)
+{
+  ACE_OS::closesocket (this->handle_);
+}
+
+void
+JAWS_Asynch_IO::read (ACE_Message_Block& mb,
+                      int size)
+{
+  ACE_Asynch_Read_Stream ar;
+
+  if (ar.open (*this, this->handle_) == -1
+      || ar.read (mb, size) == -1)
+    this->handler_->read_error ();
+}
+
+// This method will be called when an asynchronous read completes on a
+// stream.
+
+void
+JAWS_Asynch_IO::handle_read_stream (const ACE_Asynch_Read_Stream::Result &result)
+{
+  // This callback is for this->receive_file()
+  if (result.act () != 0)
+    {
+      int code = 0;
+      if (result.success () && result.bytes_transferred () != 0)
+        {
+          if (result.message_block ().length () == result.message_block ().size ())
+            code = ACE_Filecache_Handle::SUCCESS;
+          else
+            {
+              ACE_Asynch_Read_Stream ar;
+              if (ar.open (*this, this->handle_) == -1
+                  || ar.read (result.message_block (),
+                              result.message_block ().size () - result.message_block ().length (),
+                              result.act ()) == -1)
+                code = -1;
+              else
+                return;
+            }
+        }
+      else
+        code = -1;
+
+      if (code == ACE_Filecache_Handle::SUCCESS)
+        this->handler_->receive_file_complete ();
+      else
+        this->handler_->receive_file_error (code);
+
+      delete &result.message_block ();
+      delete (ACE_Filecache_Handle *) result.act ();
+    }
+  else
+    {
+      // This callback is for this->read()
+      if (result.success ()
+          && result.bytes_transferred () != 0)
+        this->handler_->read_complete (result.message_block ());
+      else
+        this->handler_->read_error ();
+    }
+}
+
+void
+JAWS_Asynch_IO::receive_file (const char *filename,
+                              void *initial_data,
+                              int initial_data_length,
+                              int entire_length)
+{
+  ACE_Message_Block *mb = 0;
+  ACE_Filecache_Handle *handle;
+
+  ACE_NEW (handle, ACE_Filecache_Handle (filename, entire_length, NOMAP));
+
+  int result = handle->error ();
+
+  if (result == ACE_Filecache_Handle::SUCCESS)
+    {
+      ACE_OS::memcpy (handle->address (),
+                      initial_data,
+                      initial_data_length);
+
+      int bytes_to_read = entire_length - initial_data_length;
+
+      ACE_NEW (mb, ACE_Message_Block ((char *)handle->address ()
+                                      + initial_data_length, bytes_to_read));
+
+      if (mb == 0)
+        {
+          errno = ENOMEM;
+          result = -1;
+        }
+      else
+        {
+          ACE_Asynch_Read_Stream ar;
+
+          if (ar.open (*this, this->handle_) == -1
+              || ar.read (*mb, mb->size () - mb->length (), handle) == -1)
+            result = -1;
+        }
+    }
+
+  if (result != ACE_Filecache_Handle::SUCCESS)
+    {
+      this->handler_->receive_file_error (result);
+      delete mb;
+      delete handle;
+    }
+}
+
+void
+JAWS_Asynch_IO::transmit_file (const char *filename,
+                               const char *header,
+                               int header_size,
+                               const char *trailer,
+                               int trailer_size)
+{
+  ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer = 0;
+  ACE_Filecache_Handle *handle = new ACE_Filecache_Handle (filename, NOMAP);
+
+  int result = handle->error ();
+
+  if (result == ACE_Filecache_Handle::SUCCESS)
+    {
+      ACE_Message_Block header_mb (header, header_size);
+      ACE_Message_Block trailer_mb (trailer, trailer_size);
+
+      header_and_trailer = new ACE_Asynch_Transmit_File::Header_And_Trailer
+        (&header_mb, header_size, &trailer_mb, trailer_size);
+
+      ACE_Asynch_Transmit_File tf;
+
+      if (tf.open (*this, this->handle_) == -1
+          || tf.transmit_file (handle->handle (), // file handle
+                               header_and_trailer, // header and trailer data
+                               0,  // bytes_to_write
+                               0,  // offset
+                               0,  // offset_high
+                               0,  // bytes_per_send
+                               0,  // flags
+                               handle // act
+                               ) == -1)
+        result = -1;
+    }
+
+  if (result != ACE_Filecache_Handle::SUCCESS)
+    {
+      this->handler_->transmit_file_error (result);
+      delete header_and_trailer;
+      delete handle;
+    }
+}
+
+
+// This method will be called when an asynchronous transmit file completes.
+void
+JAWS_Asynch_IO::handle_transmit_file (const ACE_Asynch_Transmit_File::Result &result)
+{
+  if (result.success ())
+    this->handler_->transmit_file_complete ();
+  else
+    this->handler_->transmit_file_error (-1);
+
+  delete result.header_and_trailer ();
+  delete (ACE_Filecache_Handle *) result.act ();
+}
+
+void
+JAWS_Asynch_IO::send_confirmation_message (const char *buffer,
+                                           int length)
+{
+  this->send_message (buffer, length, CONFORMATION);
+}
+
+void
+JAWS_Asynch_IO::send_error_message (const char *buffer,
+                                    int length)
+{
+  this->send_message (buffer, length, ERROR_MESSAGE);
+}
+
+void
+JAWS_Asynch_IO::send_message (const char *buffer,
+                              int length,
+                              int act)
+{
+  ACE_Message_Block *mb;
+  ACE_NEW (mb, ACE_Message_Block (buffer, length));
+
+  if (mb == 0)
+    {
+      this->handler_->error_message_complete ();
+      return;
+    }
+
+  ACE_Asynch_Write_Stream aw;
+  if (aw.open (*this, this->handle_) == -1
+      || aw.write (*mb, length, (void *) act) == -1)
+    {
+      mb->release ();
+
+      if (act == CONFORMATION)
+        this->handler_->confirmation_message_complete ();
+      else
+        this->handler_->error_message_complete ();
+    }
+}
+
+void
+JAWS_Asynch_IO::handle_write_stream (const ACE_Asynch_Write_Stream::Result &result)
+{
+  result.message_block ().release ();
+
+  if (result.act () == (void *) CONFORMATION)
+    this->handler_->confirmation_message_complete ();
+  else
+    this->handler_->error_message_complete ();
+}
+
+#endif /* ACE_WIN32 */
+
+// #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
+// template class ACE_Singleton<JAWS_VFS, ACE_SYNCH_MUTEX>;
+// #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+// #pragma instantiate ACE_Singleton<JAWS_VFS, ACE_SYNCH_MUTEX>
+// #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
+template class ACE_Singleton<JAWS_Synch_IO, ACE_SYNCH_MUTEX>;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate  ACE_Singleton<JAWS_Synch_IO, ACE_SYNCH_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
diff --git a/apps/JAWS/PROTOTYPE/JAWS/IO.h b/apps/JAWS/PROTOTYPE/JAWS/IO.h
new file mode 100644
index 00000000000..e25d29a07ee
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/IO.h
@@ -0,0 +1,198 @@
+/* -*- c++ -*- */
+// Hey, Emacs!  This is a C++ file!
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//   jaws
+//
+// = FILENAME
+//    IO.h
+//
+// = AUTHOR
+//    James Hu
+//
+// ============================================================================
+
+#if !defined (JAWS_IO_H)
+#define JAWS_IO_H
+
+class ACE_Message_Block;
+class JAWS_IO_Handler;
+class JAWS_IO_Acceptor;
+
+#include "ace/ACE.h"
+#include "ace/Asynch_IO.h"
+#include "ace/SOCK_Stream.h"
+#include "ace/Singleton.h"
+
+class JAWS_IO
+  // = TITLE
+  //
+  //     This class defines the abstract interface for an I/O class in
+  //     the context of Web-likes servers
+  //
+  // = DESCRIPTION
+  //
+  //     An I/O class should have the following interface. Derived
+  //     classes will define the exactly how the I/O will take place
+  //     (Asynchronous, Synchronous, Reactive)
+{
+public:
+  JAWS_IO (void);
+  virtual ~JAWS_IO (void);
+
+  //  void acceptor (JAWS_IO_Acceptor *acceptor);
+  //  void handler (JAWS_IO_Handler *handler);
+  //  void handle (ACE_HANDLE h);
+  //  ACE_HANDLE handle (void);
+
+  // James, please add documentation here.
+
+  virtual void accept (JAWS_IO_Handler *ioh) = 0;
+  // accept a passive connection
+
+  virtual void read (JAWS_IO_Handler *ioh,
+                     ACE_Message_Block& mb,
+                     int size) = 0;
+  // read from the handle size bytes into the message block.
+
+  virtual void transmit_file (JAWS_IO_Handler *ioh,
+                              const char *filename,
+                              const char *header,
+                              int header_size,
+                              const char *trailer,
+                              int trailer_size) = 0;
+  // send header, filename, trailer to the handle.
+
+  virtual void receive_file (JAWS_IO_Handler *ioh,
+                             const char *filename,
+                             void *initial_data,
+                             int initial_data_length,
+                             int entire_length) = 0;
+  // read data from the handle and store in filename.
+
+  virtual void send_confirmation_message (JAWS_IO_Handler *ioh,
+                                          const char *buffer,
+                                          int length) = 0;
+  // send a confirmation message to the handle.
+
+  virtual void send_error_message (JAWS_IO_Handler *ioh,
+                                   const char *buffer,
+                                   int length) = 0;
+  // send an error message to the handle.
+
+protected:
+  ACE_HANDLE handle_;
+  JAWS_IO_Handler *handler_;
+  ACE_INET_Addr *inet_addr_;
+  JAWS_IO_Acceptor *acceptor_;
+};
+
+class JAWS_Synch_IO : public JAWS_IO
+  // = TITLE
+  //
+  //     This class defines the interface for a Synchronous I/O class.
+  //
+  // = DESCRIPTION
+{
+public:
+  JAWS_Synch_IO (void);
+
+  ~JAWS_Synch_IO (void);
+
+  virtual void accept (JAWS_IO_Handler *ioh);
+
+  void read (JAWS_IO_Handler *ioh, ACE_Message_Block& mb, int size);
+
+  void transmit_file (JAWS_IO_Handler *ioh,
+                      const char *filename,
+                      const char *header,
+                      int header_size,
+                      const char *trailer,
+                      int trailer_size);
+
+  void receive_file (JAWS_IO_Handler *ioh,
+                     const char *filename,
+                     void *initial_data,
+                     int initial_data_length,
+                     int entire_length);
+
+  void send_confirmation_message (JAWS_IO_Handler *ioh,
+                                  const char *buffer,
+                                  int length);
+
+  void send_error_message (JAWS_IO_Handler *ioh,
+                           const char *buffer,
+                           int length);
+
+protected:
+  virtual void send_message (JAWS_IO_Handler *ioh,
+                             const char *buffer,
+                             int length);
+};
+
+typedef ACE_Singleton<JAWS_Synch_IO, ACE_SYNCH_MUTEX>
+        JAWS_Synch_IO_Singleton;
+
+// This only works on Win32
+#if defined (ACE_WIN32)
+
+class JAWS_Asynch_IO : public JAWS_IO, public ACE_Handler
+  // = TITLE
+  //
+  //     This class defines the interface for a Asynchronous I/O class.
+  //
+  // = DESCRIPTION
+{
+public:
+  JAWS_Asynch_IO (void);
+
+  ~JAWS_Asynch_IO (void);
+
+  void read (ACE_Message_Block& mb, int size);
+
+  void transmit_file (const char *filename,
+                      const char *header,
+                      int header_size,
+                      const char *trailer,
+                      int trailer_size);
+
+  void receive_file (const char *filename,
+                     void *initial_data,
+                     int initial_data_length,
+                     int entire_length);
+
+  void send_confirmation_message (const char *buffer,
+                                  int length);
+
+  void send_error_message (const char *buffer,
+                           int length);
+
+protected:
+  enum Message_Types
+  {
+    CONFORMATION,
+    ERROR_MESSAGE
+  };
+
+  virtual void send_message (const char *buffer,
+                             int length,
+                             int act);
+
+  virtual void handle_read_stream (const ACE_Asynch_Read_Stream::Result &result);
+  // This method will be called when an asynchronous read completes on
+  // a stream.
+
+  virtual void handle_write_stream (const ACE_Asynch_Write_Stream::Result &result);
+  // This method will be called when an asynchronous write completes
+  // on a stream.
+
+  virtual void handle_transmit_file (const ACE_Asynch_Transmit_File::Result &result);
+  // This method will be called when an asynchronous transmit file
+  // completes.
+};
+
+#endif /* ACE_WIN32 */
+#endif /* JAWS_IO_H */
diff --git a/apps/JAWS/PROTOTYPE/JAWS/IO_Acceptor.cpp b/apps/JAWS/PROTOTYPE/JAWS/IO_Acceptor.cpp
new file mode 100644
index 00000000000..9453c16693d
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/IO_Acceptor.cpp
@@ -0,0 +1,67 @@
+// $Id$
+
+#include "JAWS/IO_Acceptor.h"
+
+int
+JAWS_IO_Acceptor::open (const ACE_INET_Addr &)
+{
+  return -1;
+}
+
+int
+JAWS_IO_Acceptor::accept (ACE_SOCK_Stream &, ACE_Addr *, ACE_Time_Value *,
+                          int, int) const
+{
+  return -1;
+}
+
+int
+JAWS_IO_Acceptor::accept (size_t)
+{
+  return -1;
+}
+
+int
+JAWS_IO_Synch_Acceptor::open (const ACE_INET_Addr &local_sap)
+{
+  return this->acceptor_->open (local_sap, 0, PF_INET, 5, 0);
+}
+
+int
+JAWS_IO_Synch_Acceptor::accept (ACE_SOCK_Stream &new_stream,
+                                ACE_Addr *remote_addr,
+                                ACE_Time_Value *timeout,
+                                int restart,
+                                int reset_new_handle) const
+{
+  return this->acceptor_->accept (new_stream, remote_addr, timeout,
+                                  restart, reset_new_handle);
+}
+
+
+#if defined (ACE_WIN32)
+// This only works on Win32 platforms
+
+int
+JAWS_IO_Asynch_Acceptor::open (const ACE_INET_Addr &address);
+{
+  return -1;
+}
+
+int
+JAWS_IO_Asynch_Acceptor::accept (size_t bytes_to_read)
+{
+  return this->acceptor_->accept (bytes_to_read);
+}
+
+
+
+#endif /* defined (ACE_WIN32) */
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
+template class ACE_Singleton<JAWS_IO_Synch_Acceptor, ACE_SYNCH_MUTEX>;
+template class ACE_Singleton<JAWS_IO_Asynch_Acceptor, ACE_SYNCH_MUTEX>;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate  ACE_Singleton<JAWS_IO_Synch_Acceptor, ACE_SYNCH_MUTEX>
+#pragma instantiate  ACE_Singleton<JAWS_IO_Asynch_Acceptor, ACE_SYNCH_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
diff --git a/apps/JAWS/PROTOTYPE/JAWS/IO_Acceptor.h b/apps/JAWS/PROTOTYPE/JAWS/IO_Acceptor.h
new file mode 100644
index 00000000000..36b7b4fabb0
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/IO_Acceptor.h
@@ -0,0 +1,99 @@
+/* -*- c++ -*- */
+// $Id$
+
+#if !defined (JAWS_IO_ACCEPTOR_H)
+#define JAWS_IO_ACCEPTOR_H
+
+// Use the Adapter pattern to encapsulate either a LOCK_SOCK_Acceptor or
+// an ACE_Asynch_Acceptor
+
+#include "ace/Asynch_Acceptor.h"
+#include "ace/LOCK_SOCK_Acceptor.h"
+#include "ace/Singleton.h"
+
+#include "JAWS/IO.h"
+
+// Forward declaration.
+class ACE_Proactor;
+class ACE_Reactor;
+
+#if defined (ACE_HAS_THREAD_SAFE_ACCEPT)
+typedef ACE_LOCK_SOCK_Acceptor<ACE_SYNCH_NULL_MUTEX> JAWS_IO_SOCK_Acceptor;
+#else
+typedef ACE_LOCK_SOCK_Acceptor<ACE_SYNCH_MUTEX> JAWS_IO_SOCK_Acceptor;
+#endif /* ACE_HAS_THREAD_SAFE_ACCEPT */
+
+class JAWS_IO_Acceptor
+{
+public:
+
+  JAWS_IO_Acceptor (void);
+  virtual ~JAWS_IO_Acceptor (void);
+
+  virtual int open (const ACE_INET_Addr &address);
+  // Initiate a passive mode socket.
+
+  virtual int accept (ACE_SOCK_Stream &new_stream,
+                      ACE_Addr *remote_addr = 0,
+                      ACE_Time_Value *timeout = 0,
+                      int restart = 1,
+                      int reset_new_handle = 0) const;
+  // Synchronously accept the connection
+
+  virtual int accept (size_t bytes_to_read = 0);
+  // This initiates a new asynchronous accept through the AcceptEx call.
+
+  enum { ASYNC = 0, SYNCH = 1 };
+  // identify if this is being used for aynchronous or synchronous
+  // accept calls
+
+private:
+
+};
+
+class JAWS_IO_Synch_Acceptor : public JAWS_IO_Acceptor
+{
+public:
+
+  virtual int open (const ACE_INET_Addr &local_sap);
+  // Initiate a passive mode socket.
+
+  virtual int accept (ACE_SOCK_Stream &new_stream,
+                      ACE_Addr *remote_addr = 0,
+                      ACE_Time_Value *timeout = 0,
+                      int restart = 1,
+                      int reset_new_handle = 0) const;
+  // Accept the connection
+
+private:
+  JAWS_IO_SOCK_Acceptor *acceptor_;
+};
+
+
+class JAWS_IO_Asynch_Acceptor : public JAWS_IO_Acceptor
+{
+public:
+
+  virtual int open (const ACE_INET_Addr &address);
+  // Initiate an asynchronous passive connection
+
+  virtual int accept (size_t bytes_to_read = 0);
+  // This initiates a new asynchronous accept through the AcceptEx call.
+
+private:
+
+#if defined (ACE_WIN32)
+// This only works on Win32 platforms
+  ACE_Asynch_Acceptor<JAWS_IO_Handler> *acceptor_;
+#else
+  void *acceptor_;
+#endif /* defined (ACE_WIN32) */
+};
+
+typedef ACE_Singleton<JAWS_IO_Synch_Acceptor, ACE_SYNCH_MUTEX>
+        JAWS_IO_Synch_Acceptor_Singleton;
+
+typedef ACE_Singleton<JAWS_IO_Asynch_Acceptor, ACE_SYNCH_MUTEX>
+        JAWS_IO_Asynch_Acceptor_Singleton;
+
+#endif /* !defined (JAWS_IO_ACCEPTOR_H) */
diff --git a/apps/JAWS/PROTOTYPE/JAWS/IO_Handler.cpp b/apps/JAWS/PROTOTYPE/JAWS/IO_Handler.cpp
new file mode 100644
index 00000000000..8dfca3ca02b
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/IO_Handler.cpp
@@ -0,0 +1,146 @@
+// $Id$
+
+#include "JAWS/IO.h"
+#include "JAWS/IO_Handler.h"
+#include "JAWS/Data_Block.h"
+
+JAWS_IO_Handler_Factory::~JAWS_IO_Handler_Factory (void)
+{
+}
+
+JAWS_Synch_IO_Handler::JAWS_Synch_IO_Handler (JAWS_IO_Handler_Factory *factory)
+  : status_ (0),
+    mb_ (0),
+    handle_ (ACE_INVALID_HANDLE),
+    task_ (0),
+    factory_ (factory)
+{
+  // this->io_->handler (this);
+}
+
+JAWS_Synch_IO_Handler::~JAWS_Synch_IO_Handler (void)
+{
+  if (this->mb_)
+    this->mb_->release ();
+  this->mb_ = 0;
+}
+
+void
+JAWS_Synch_IO_Handler::accept_complete (ACE_HANDLE handle)
+{
+  // callback into pipeline task, notify that the accept has completed
+  this->handle_ = handle;
+}
+
+void
+JAWS_Synch_IO_Handler::accept_error (void)
+{
+  // callback into pipeline task, notify that the accept has failed
+}
+
+void
+JAWS_Synch_IO_Handler::read_complete (ACE_Message_Block &data)
+{
+  ACE_UNUSED_ARG (data);
+  // We can call back into the pipeline task at this point
+  // this->pipeline_->read_complete (data);
+}
+
+void
+JAWS_Synch_IO_Handler::read_error (void)
+{
+  // this->pipeline_->read_error ();
+}
+
+void
+JAWS_Synch_IO_Handler::transmit_file_complete (void)
+{
+  // this->pipeline_->transmit_file_complete ();
+}
+
+void
+JAWS_Synch_IO_Handler::transmit_file_error (int result)
+{
+  ACE_UNUSED_ARG (result);
+  // this->pipeline_->transmit_file_complete (result);
+}
+
+void
+JAWS_Synch_IO_Handler::receive_file_complete (void)
+{
+}
+
+void
+JAWS_Synch_IO_Handler::receive_file_error (int result)
+{
+  ACE_UNUSED_ARG(result);
+}
+
+void
+JAWS_Synch_IO_Handler::write_error (void)
+{
+  ACE_DEBUG ((LM_DEBUG, " (%t) error in writing response\n"));
+
+  this->done ();
+}
+
+void
+JAWS_Synch_IO_Handler::confirmation_message_complete (void)
+{
+}
+
+void
+JAWS_Synch_IO_Handler::error_message_complete (void)
+{
+}
+
+JAWS_IO_Handler_Factory *
+JAWS_Synch_IO_Handler::factory (void)
+{
+  return this->factory_;
+}
+
+ACE_HANDLE
+JAWS_Synch_IO_Handler::handle (void)
+{
+  return this->handle_;
+}
+
+void
+JAWS_Synch_IO_Handler::done (void)
+{
+  this->factory ()->destroy_io_handler (this);
+}
+
+int
+JAWS_Synch_IO_Handler::status (void)
+{
+  return this->status_;
+}
+
+JAWS_IO_Handler *
+JAWS_Synch_IO_Handler_Factory::create_io_handler (void)
+{
+  JAWS_Synch_IO *io;
+  JAWS_Synch_IO_Handler *handler;
+
+  io = new JAWS_Synch_IO;
+  if (io == 0) return 0;
+
+  handler = new JAWS_Synch_IO_Handler (this);
+  if (handler == 0) delete io;
+
+  return handler;
+}
+
+void
+JAWS_Synch_IO_Handler_Factory::destroy_io_handler (JAWS_IO_Handler *handler)
+{
+  delete handler;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
+template class ACE_Singleton<JAWS_Synch_IO_Handler_Factory, ACE_SYNCH_MUTEX>;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate  ACE_Singleton<JAWS_Synch_IO_Handler_Factory, ACE_SYNCH_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
diff --git a/apps/JAWS/PROTOTYPE/JAWS/IO_Handler.h b/apps/JAWS/PROTOTYPE/JAWS/IO_Handler.h
new file mode 100644
index 00000000000..6b22e88609a
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/IO_Handler.h
@@ -0,0 +1,251 @@
+/* -*- c++ -*- */
+// Hey, Emacs!  This is a C++ file!
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//   jaws
+//
+// = FILENAME
+//    IO.h
+//
+// = AUTHOR
+//    James Hu
+//
+// ============================================================================
+
+#if !defined (JAWS_IO_HANDLER_H)
+#define JAWS_IO_HANDLER_H
+
+#include "ace/Asynch_IO.h"
+#include "ace/Singleton.h"
+
+// #include "JAWS/IO.h"
+class JAWS_IO;
+class JAWS_Synch_IO;
+class JAWS_Asynch_IO;
+class JAWS_IO_Handler;
+class JAWS_Synch_IO_Handler;
+class JAWS_Asynch_IO_Handler;
+class JAWS_IO_Handler_Factory;
+class JAWS_Synch_IO_Handler_Factory;
+class JAWS_Asynch_IO_Handler_Factory;
+class JAWS_Data_Block;
+
+template <class TYPE> class JAWS_Pipeline_Abstract_Handler;
+typedef JAWS_Pipeline_Abstract_Handler<JAWS_Data_Block>
+        JAWS_Pipeline_Handler;
+
+class JAWS_IO_Handler
+  // = TITLE
+  //
+  //     This class defines the abstract interface for an I/O handler
+  //     class in the context of Web-likes servers
+  //
+  // = DESCRIPTION
+{
+public:
+  virtual void accept_complete (ACE_HANDLE handle) = 0;
+  // This method is called by the IO class when new passive connection has
+  // been established.
+
+  virtual void accept_error (void) = 0;
+  // This method is called by the IO class when new passive connection has
+  // been established.
+
+#if 0
+  virtual void connect_complete (ACE_Message_Block &) = 0;
+  // This method is called by the IO class when new active connection has
+  // been established.
+
+  virtual void connect_error (ACE_Message_Block &) = 0;
+  // This method is called by the IO class when new active connection has
+  // been established.
+#endif
+
+  virtual void read_complete (ACE_Message_Block &data) = 0;
+  // This method is called by the IO class when new client data shows
+  // up.
+
+  virtual void read_error (void) = 0;
+  // This method is called by the IO class when there was an error in
+  // reading new data from the client.
+
+  virtual void transmit_file_complete (void) = 0;
+  // This method is called by the IO class when the requested file has
+  // been successfully transmitted to the client.
+
+  virtual void transmit_file_error (int result) = 0;
+  // This method is called by the IO class when there was an error in
+  // transmitting the requested file to the client.
+
+  virtual void receive_file_complete (void) = 0;
+  // This method is called by the IO class when the requested file has
+  // been successfully received from the client.
+
+  virtual void receive_file_error (int result) = 0;
+  // This method is called by the IO class when there was an error in
+  // receiving the requested file from the client.
+
+  virtual void write_error (void) = 0;
+  // This method is called by the IO class when there was an error in
+  // writing data to the client.
+
+  virtual void confirmation_message_complete (void) = 0;
+  // This method is called by the IO class when the confirmation
+  // message has been delivered to the client.
+
+  virtual void error_message_complete (void) = 0;
+  // This method is called by the IO class when the error message has
+  // been delivered to the client.
+
+  virtual JAWS_IO_Handler_Factory *factory (void) = 0;
+  // Returns the factory for this IO handler
+
+  virtual ACE_HANDLE handle (void) = 0;
+  // Returns the socket handle for this handler
+
+  virtual int status (void) = 0;
+
+  enum { IDLE = 0,
+         ACCEPT_OK, ACCEPT_ERROR,
+         READ_OK, READ_ERROR,
+         WRITE_OK, WRITE_ERROR,
+         TRANSMIT_OK, TRANSMIT_ERROR,
+         RECEIVE_OK, RECEIVE_ERROR };
+};
+
+class JAWS_IO_Handler_Factory
+#if defined (ACE_WIN32)
+ : public ACE_Service_Handler
+#endif
+{
+public:
+  virtual ~JAWS_IO_Handler_Factory (void);
+  // Destructor
+
+  virtual JAWS_IO_Handler *create_io_handler (void) = 0;
+  // This creates a new HTTP_Handler
+
+  virtual void destroy_io_handler (JAWS_IO_Handler *handler) = 0;
+  // The HTTP handler will call this method from HTTP_Handler::done to
+  // tell the factory to reap up the handler as it is now done with
+  // the protocol
+};
+
+class JAWS_Synch_IO_Handler : protected JAWS_IO_Handler
+{
+friend class JAWS_Synch_IO;
+friend class JAWS_Synch_IO_Handler_Factory;
+
+public:
+  JAWS_Synch_IO_Handler (JAWS_IO_Handler_Factory *factory);
+  virtual ~JAWS_Synch_IO_Handler (void);
+
+protected:
+  // Inherited from JAWS_IO_Handler
+
+  virtual void accept_complete (ACE_HANDLE handle);
+  virtual void accept_error (void);
+  virtual void read_complete (ACE_Message_Block &data);
+  virtual void read_error (void);
+  virtual void transmit_file_complete (void);
+  virtual void transmit_file_error (int result);
+  virtual void receive_file_complete (void);
+  virtual void receive_file_error (int result);
+  virtual void write_error (void);
+  virtual void confirmation_message_complete (void);
+  virtual void error_message_complete (void);
+
+  virtual JAWS_IO_Handler_Factory *factory (void);
+  virtual ACE_HANDLE handle (void);
+
+  virtual void done (void);
+  virtual int status (void);
+
+private:
+  int status_;
+  // The state of the handler.
+
+  ACE_Message_Block *mb_;
+  // This maintains the state of the request.
+
+  ACE_HANDLE handle_;
+  // The socket handle returned from accept.
+
+  JAWS_Pipeline_Handler *task_;
+  // This is a reference to the next stage of the pipeline when the IO
+  // request completes.
+
+  JAWS_IO_Handler_Factory *factory_;
+};
+
+class JAWS_Synch_IO_Handler_Factory : public JAWS_IO_Handler_Factory
+{
+public:
+  JAWS_IO_Handler *create_io_handler (void);
+  // This creates a new HTTP_Handler
+
+  void destroy_io_handler (JAWS_IO_Handler *handler);
+  // The HTTP handler will call this method from HTTP_Handler::done to
+  // tell the factory to reap up the handler as it is now done with
+  // the protocol
+};
+
+typedef ACE_Singleton<JAWS_Synch_IO_Handler_Factory, ACE_SYNCH_MUTEX>
+        JAWS_Synch_IO_Handler_Factory_Singleton;
+
+// This only works on Win32
+#if defined (ACE_WIN32)
+
+class JAWS_Asynch_IO_Handler : protected JAWS_IO_Handler
+{
+public:
+  JAWS_Asynch_IO_Handler (void);
+  virtual ~JAWS_Asynch_IO_Handler (void);
+
+protected:
+  // Inherited from JAWS_IO_Handler
+
+  virtual void accept_complete (void);
+  virtual void accept_error (void);
+  virtual void read_complete (ACE_Message_Block &data);
+  virtual void read_error (void);
+  virtual void transmit_file_complete (void);
+  virtual void transmit_file_error (int result);
+  virtual void receive_file_complete (void);
+  virtual void receive_file_error (int result);
+  virtual void write_error (void);
+  virtual void confirmation_message_complete (void);
+  virtual void error_message_complete (void);
+  virtual JAWS_Handler_Factory *factory (void);
+
+private:
+  ACE_Message_Block *state_;
+  // This maintains the state of the request.
+
+  JAWS_IO *io_;
+  // The reference to our IO interface (synch vs. asynch)
+
+  JAWS_Pipeline *pipeline_;
+  // This is a reference to the next stage of the pipeline when the IO
+  // request completes.
+
+  JAWS_IO_Handler_Factory *factory_;
+};
+
+class JAWS_Asynch_IO_Handler_Factory : public JAWS_IO_Handler_Factory
+{
+public:
+  JAWS_IO_Handler *create_io_handler (void);
+  // This creates a new HTTP_Handler
+
+  void destroy_io_handler (JAWS_IO_Handler *handler);
+  // The HTTP handler will call this method from HTTP_Handler::done to
+  // tell the factory to reap up the handler as it is now done with
+  // the protocol
+};
+
+#endif /* ACE_WIN32 */
+#endif /* JAWS_IO_HANDLER_H */
diff --git a/apps/JAWS/PROTOTYPE/JAWS/IO_State.h b/apps/JAWS/PROTOTYPE/JAWS/IO_State.h
new file mode 100644
index 00000000000..18648f71613
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/IO_State.h
@@ -0,0 +1,225 @@
+/* -*- c++ -*- */
+// Hey, Emacs!  This is a C++ file!
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//   jaws
+//
+// = FILENAME
+//    IO.h
+//
+// = AUTHOR
+//    James Hu
+//
+// ============================================================================
+
+#if !defined (JAWS_IO_STATE_H)
+#define JAWS_IO_STATE_H
+
+#include "ace/Asynch_IO.h"
+
+// #include "JAWS/IO.h"
+class JAWS_IO;
+class JAWS_Synch_IO;
+class JAWS_Asynch_IO;
+class JAWS_IO_Handler;
+class JAWS_Synch_IO_Handler;
+class JAWS_Asynch_IO_Handler;
+class JAWS_IO_Handler_Factory;
+class JAWS_Synch_IO_Handler_Factory;
+class JAWS_Asynch_IO_Handler_Factory;
+class JAWS_Pipeline;
+
+class JAWS_IO_Handler
+  // = TITLE
+  //
+  //     This class defines the abstract interface for an I/O handler
+  //     class in the context of Web-likes servers
+  //
+  // = DESCRIPTION
+{
+public:
+  virtual void accept_complete (void) = 0;
+  // This method is called by the IO class when new passive connection has
+  // been established.
+
+  virtual void accept_error (void) = 0;
+  // This method is called by the IO class when new passive connection has
+  // been established.
+
+#if 0
+  virtual void connect_complete (ACE_Message_Block &) = 0;
+  // This method is called by the IO class when new active connection has
+  // been established.
+
+  virtual void connect_error (ACE_Message_Block &) = 0;
+  // This method is called by the IO class when new active connection has
+  // been established.
+#endif
+
+  virtual void read_complete (ACE_Message_Block &data) = 0;
+  // This method is called by the IO class when new client data shows
+  // up.
+
+  virtual void read_error (void) = 0;
+  // This method is called by the IO class when there was an error in
+  // reading new data from the client.
+
+  virtual void transmit_file_complete (void) = 0;
+  // This method is called by the IO class when the requested file has
+  // been successfully transmitted to the client.
+
+  virtual void transmit_file_error (int result) = 0;
+  // This method is called by the IO class when there was an error in
+  // transmitting the requested file to the client.
+
+  virtual void receive_file_complete (void) = 0;
+  // This method is called by the IO class when the requested file has
+  // been successfully received from the client.
+
+  virtual void receive_file_error (int result) = 0;
+  // This method is called by the IO class when there was an error in
+  // receiving the requested file from the client.
+
+  virtual void write_error (void) = 0;
+  // This method is called by the IO class when there was an error in
+  // writing data to the client.
+
+  virtual void confirmation_message_complete (void) = 0;
+  // This method is called by the IO class when the confirmation
+  // message has been delivered to the client.
+
+  virtual void error_message_complete (void) = 0;
+  // This method is called by the IO class when the error message has
+  // been delivered to the client.
+
+  virtual JAWS_IO_Handler_Factory *factory (void) = 0;
+  // Returns the factory for this IO handler
+};
+
+class JAWS_IO_Handler_Factory
+#if defined (ACE_WIN32)
+ : public ACE_Service_Handler
+#endif
+{
+public:
+  virtual ~JAWS_IO_Handler_Factory (void);
+  // Destructor
+
+  virtual JAWS_IO_Handler *create_io_handler (void) = 0;
+  // This creates a new HTTP_Handler
+
+  virtual void destroy_io_handler (JAWS_IO_Handler *handler, JAWS_IO *io) = 0;
+  // The HTTP handler will call this method from HTTP_Handler::done to
+  // tell the factory to reap up the handler as it is now done with
+  // the protocol
+};
+
+class JAWS_Synch_IO_Handler : protected JAWS_IO_Handler
+{
+friend class JAWS_Synch_IO;
+friend class JAWS_Synch_IO_Handler_Factory;
+
+public:
+  JAWS_Synch_IO_Handler (JAWS_IO *io, JAWS_IO_Handler_Factory *factory);
+  virtual ~JAWS_Synch_IO_Handler (void);
+
+protected:
+  // Inherited from JAWS_IO_Handler
+
+  virtual void accept_complete (void);
+  virtual void accept_error (void);
+  virtual void read_complete (ACE_Message_Block &data);
+  virtual void read_error (void);
+  virtual void transmit_file_complete (void);
+  virtual void transmit_file_error (int result);
+  virtual void receive_file_complete (void);
+  virtual void receive_file_error (int result);
+  virtual void write_error (void);
+  virtual void confirmation_message_complete (void);
+  virtual void error_message_complete (void);
+  virtual JAWS_IO_Handler_Factory *factory (void);
+
+  virtual void done (void);
+
+private:
+  ACE_Message_Block *state_;
+  // This maintains the state of the request.
+
+  JAWS_IO *io_;
+  // The reference to our IO interface (synch vs. asynch)
+
+  JAWS_Pipeline *pipeline_;
+  // This is a reference to the next stage of the pipeline when the IO
+  // request completes.
+
+  JAWS_IO_Handler_Factory *factory_;
+};
+
+class JAWS_Synch_IO_Handler_Factory : public JAWS_IO_Handler_Factory
+{
+public:
+  JAWS_IO_Handler *create_io_handler (void);
+  // This creates a new HTTP_Handler
+
+  void destroy_io_handler (JAWS_IO_Handler *handler, JAWS_IO *io);
+  // The HTTP handler will call this method from HTTP_Handler::done to
+  // tell the factory to reap up the handler as it is now done with
+  // the protocol
+};
+
+// This only works on Win32
+#if defined (ACE_WIN32)
+
+class JAWS_Asynch_IO_Handler : protected JAWS_IO_Handler
+{
+public:
+  JAWS_Asynch_IO_Handler (void);
+  virtual ~JAWS_Asynch_IO_Handler (void);
+
+protected:
+  // Inherited from JAWS_IO_Handler
+
+  virtual void accept_complete (void);
+  virtual void accept_error (void);
+  virtual void read_complete (ACE_Message_Block &data);
+  virtual void read_error (void);
+  virtual void transmit_file_complete (void);
+  virtual void transmit_file_error (int result);
+  virtual void receive_file_complete (void);
+  virtual void receive_file_error (int result);
+  virtual void write_error (void);
+  virtual void confirmation_message_complete (void);
+  virtual void error_message_complete (void);
+  virtual JAWS_Handler_Factory *factory (void);
+
+private:
+  ACE_Message_Block *state_;
+  // This maintains the state of the request.
+
+  JAWS_Dispatch_Policy *policy_;
+  // The reference to our IO interface (synch vs. asynch)
+
+  JAWS_Pipeline *pipeline_;
+  // This is a reference to the next stage of the pipeline when the IO
+  // request completes.
+
+  JAWS_IO_Handler_Factory *factory_;
+};
+
+class JAWS_Asynch_IO_Handler_Factory : public JAWS_IO_Handler_Factory
+{
+public:
+  JAWS_IO_Handler *create_io_handler (void);
+  // This creates a new HTTP_Handler
+
+  void destroy_io_handler (JAWS_IO_Handler *handler, JAWS_IO *io);
+  // The HTTP handler will call this method from HTTP_Handler::done to
+  // tell the factory to reap up the handler as it is now done with
+  // the protocol
+};
+
+#endif /* ACE_WIN32 */
+#endif /* JAWS_IO_STATE_H */
diff --git a/apps/JAWS/PROTOTYPE/JAWS/Makefile b/apps/JAWS/PROTOTYPE/JAWS/Makefile
new file mode 100644
index 00000000000..5bb95561f9f
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/Makefile
@@ -0,0 +1,1087 @@
+#----------------------------------------------------------------------------
+#	$Id$
+#
+#	Makefile for the ACE Adapter Web Server (JAWS)
+#----------------------------------------------------------------------------
+
+#----------------------------------------------------------------------------
+#	Local macros
+#----------------------------------------------------------------------------
+
+#BIN   	= main
+
+LIB = libJAWS.a
+
+MYFILES  	= \
+	Pipeline \
+	Pipeline_Tasks \
+	Data_Block \
+	Policy \
+	Concurrency \
+	Server \
+	IO_Acceptor \
+	IO_Handler \
+	IO
+
+LSRC	= $(addsuffix .cpp,$(MYFILES))
+LOBJ	= $(addsuffix .o,$(MYFILES))
+
+#CFLAGS += -I$(ACE_ROOT)/apps/JAWS/server/PROTOTYPE
+
+VLDLIBS = $(LDLIBS:%=%$(VAR))
+
+#LDLIBS	= -lJAWS
+
+BUILD	= $(VOBJS) $(VLIB) #$(VBIN)
+
+#----------------------------------------------------------------------------
+#	Include macros and targets
+#----------------------------------------------------------------------------
+
+include		$(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU
+include		$(ACE_ROOT)/include/makeinclude/macros.GNU
+include		$(ACE_ROOT)/include/makeinclude/rules.common.GNU
+include		$(ACE_ROOT)/include/makeinclude/rules.nonested.GNU
+include		$(ACE_ROOT)/include/makeinclude/rules.lib.GNU
+# The contents of rules.bin.GNU are expanded in Local targets, below.
+# include		$(ACE_ROOT)/include/makeinclude/rules.bin.GNU
+# include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
+
+#----------------------------------------------------------------------------
+#	Local targets
+#----------------------------------------------------------------------------
+
+# Expand rules.bin.GNU, but without the $(VOBJS) dependencies.
+VBIN    = $(BIN:%=%$(VAR))
+
+$(BIN): %: $(VDIR)%.o
+	$(LINK.cc) -o $@ $^ $(LDFLAGS) $(VLDLIBS) $(POSTLINK)
+include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
+
+#----------------------------------------------------------------------------
+#	Dependencies
+#----------------------------------------------------------------------------
+# DO NOT DELETE THIS LINE -- g++dep uses it.
+# DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY.
+
+.obj/Pipeline.o .obj/Pipeline.so .shobj/Pipeline.o .shobj/Pipeline.so: Pipeline.cpp JAWS/Pipeline.h \
+ $(ACE_ROOT)/ace/Synch.h \
+ $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/config.h \
+ $(ACE_ROOT)/ace/config-g++-common.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Basic_Types.i \
+ $(ACE_ROOT)/ace/OS.i \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/Version.h \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/Log_Record.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(ACE_ROOT)/ace/Synch.i \
+ $(ACE_ROOT)/ace/Synch_T.h \
+ $(ACE_ROOT)/ace/Event_Handler.h \
+ $(ACE_ROOT)/ace/Event_Handler.i \
+ $(ACE_ROOT)/ace/Synch_T.i \
+ $(ACE_ROOT)/ace/Thread.h \
+ $(ACE_ROOT)/ace/Thread.i \
+ $(ACE_ROOT)/ace/Atomic_Op.i \
+ $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Service_Config.h \
+ $(ACE_ROOT)/ace/Service_Object.h \
+ $(ACE_ROOT)/ace/Shared_Object.h \
+ $(ACE_ROOT)/ace/Shared_Object.i \
+ $(ACE_ROOT)/ace/Service_Object.i \
+ $(ACE_ROOT)/ace/Signal.h \
+ $(ACE_ROOT)/ace/Containers.h \
+ $(ACE_ROOT)/ace/Containers.i \
+ $(ACE_ROOT)/ace/Containers.cpp \
+ $(ACE_ROOT)/ace/Malloc.h \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Free_List.h \
+ $(ACE_ROOT)/ace/Free_List.i \
+ $(ACE_ROOT)/ace/Free_List.cpp \
+ $(ACE_ROOT)/ace/Malloc_T.i \
+ $(ACE_ROOT)/ace/Malloc_T.cpp \
+ $(ACE_ROOT)/ace/Memory_Pool.h \
+ $(ACE_ROOT)/ace/Mem_Map.h \
+ $(ACE_ROOT)/ace/Mem_Map.i \
+ $(ACE_ROOT)/ace/Memory_Pool.i \
+ $(ACE_ROOT)/ace/Signal.i \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Service_Config.i \
+ $(ACE_ROOT)/ace/Reactor.h \
+ $(ACE_ROOT)/ace/Handle_Set.h \
+ $(ACE_ROOT)/ace/Handle_Set.i \
+ $(ACE_ROOT)/ace/Timer_Queue.h \
+ $(ACE_ROOT)/ace/Timer_Queue_T.h \
+ $(ACE_ROOT)/ace/Timer_Queue_T.i \
+ $(ACE_ROOT)/ace/Timer_Queue_T.cpp \
+ $(ACE_ROOT)/ace/Reactor.i \
+ $(ACE_ROOT)/ace/Reactor_Impl.h \
+ $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \
+ $(ACE_ROOT)/ace/Stream.h \
+ $(ACE_ROOT)/ace/IO_Cntl_Msg.h \
+ $(ACE_ROOT)/ace/Message_Block.h \
+ $(ACE_ROOT)/ace/Message_Block.i \
+ $(ACE_ROOT)/ace/Time_Value.h \
+ $(ACE_ROOT)/ace/Module.h \
+ $(ACE_ROOT)/ace/Task_T.h \
+ $(ACE_ROOT)/ace/Message_Queue.h \
+ $(ACE_ROOT)/ace/Strategies.h \
+ $(ACE_ROOT)/ace/Strategies_T.h \
+ $(ACE_ROOT)/ace/Synch_Options.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.cpp \
+ $(ACE_ROOT)/ace/Strategies_T.cpp \
+ $(ACE_ROOT)/ace/Service_Repository.h \
+ $(ACE_ROOT)/ace/Service_Types.h \
+ $(ACE_ROOT)/ace/Service_Types.i \
+ $(ACE_ROOT)/ace/Service_Repository.i \
+ $(ACE_ROOT)/ace/Thread_Manager.h \
+ $(ACE_ROOT)/ace/Thread_Manager.i \
+ $(ACE_ROOT)/ace/WFMO_Reactor.h \
+ $(ACE_ROOT)/ace/WFMO_Reactor.i \
+ $(ACE_ROOT)/ace/Message_Queue.i \
+ $(ACE_ROOT)/ace/Message_Queue.cpp \
+ $(ACE_ROOT)/ace/Task.h \
+ $(ACE_ROOT)/ace/Task.i \
+ $(ACE_ROOT)/ace/Task_T.i \
+ $(ACE_ROOT)/ace/Task_T.cpp \
+ $(ACE_ROOT)/ace/Module.i \
+ $(ACE_ROOT)/ace/Module.cpp \
+ $(ACE_ROOT)/ace/Stream_Modules.h \
+ $(ACE_ROOT)/ace/Stream_Modules.i \
+ $(ACE_ROOT)/ace/Stream_Modules.cpp \
+ $(ACE_ROOT)/ace/Stream.i \
+ $(ACE_ROOT)/ace/Stream.cpp \
+ JAWS/JAWS/Pipeline_Handler.h JAWS/JAWS/JAWS/Pipeline.h \
+ JAWS/JAWS/JAWS/Pipeline_Handler.cpp \
+ JAWS/JAWS/JAWS/JAWS/Pipeline_Handler.h JAWS/Pipeline_Handler.cpp
+.obj/Pipeline_Tasks.o .obj/Pipeline_Tasks.so .shobj/Pipeline_Tasks.o .shobj/Pipeline_Tasks.so: Pipeline_Tasks.cpp JAWS/Pipeline_Tasks.h \
+ $(ACE_ROOT)/ace/Singleton.h \
+ $(ACE_ROOT)/ace/Synch.h \
+ $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/config.h \
+ $(ACE_ROOT)/ace/config-g++-common.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Basic_Types.i \
+ $(ACE_ROOT)/ace/OS.i \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/Version.h \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/Log_Record.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(ACE_ROOT)/ace/Synch.i \
+ $(ACE_ROOT)/ace/Synch_T.h \
+ $(ACE_ROOT)/ace/Event_Handler.h \
+ $(ACE_ROOT)/ace/Event_Handler.i \
+ $(ACE_ROOT)/ace/Synch_T.i \
+ $(ACE_ROOT)/ace/Thread.h \
+ $(ACE_ROOT)/ace/Thread.i \
+ $(ACE_ROOT)/ace/Atomic_Op.i \
+ $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ JAWS/JAWS/Data_Block.h JAWS/JAWS/JAWS/Pipeline.h \
+ $(ACE_ROOT)/ace/Service_Config.h \
+ $(ACE_ROOT)/ace/Service_Object.h \
+ $(ACE_ROOT)/ace/Shared_Object.h \
+ $(ACE_ROOT)/ace/Shared_Object.i \
+ $(ACE_ROOT)/ace/Service_Object.i \
+ $(ACE_ROOT)/ace/Signal.h \
+ $(ACE_ROOT)/ace/Containers.h \
+ $(ACE_ROOT)/ace/Containers.i \
+ $(ACE_ROOT)/ace/Containers.cpp \
+ $(ACE_ROOT)/ace/Malloc.h \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Free_List.h \
+ $(ACE_ROOT)/ace/Free_List.i \
+ $(ACE_ROOT)/ace/Free_List.cpp \
+ $(ACE_ROOT)/ace/Malloc_T.i \
+ $(ACE_ROOT)/ace/Malloc_T.cpp \
+ $(ACE_ROOT)/ace/Memory_Pool.h \
+ $(ACE_ROOT)/ace/Mem_Map.h \
+ $(ACE_ROOT)/ace/Mem_Map.i \
+ $(ACE_ROOT)/ace/Memory_Pool.i \
+ $(ACE_ROOT)/ace/Signal.i \
+ $(ACE_ROOT)/ace/Service_Config.i \
+ $(ACE_ROOT)/ace/Reactor.h \
+ $(ACE_ROOT)/ace/Handle_Set.h \
+ $(ACE_ROOT)/ace/Handle_Set.i \
+ $(ACE_ROOT)/ace/Timer_Queue.h \
+ $(ACE_ROOT)/ace/Timer_Queue_T.h \
+ $(ACE_ROOT)/ace/Timer_Queue_T.i \
+ $(ACE_ROOT)/ace/Timer_Queue_T.cpp \
+ $(ACE_ROOT)/ace/Reactor.i \
+ $(ACE_ROOT)/ace/Reactor_Impl.h \
+ $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \
+ $(ACE_ROOT)/ace/Stream.h \
+ $(ACE_ROOT)/ace/IO_Cntl_Msg.h \
+ $(ACE_ROOT)/ace/Message_Block.h \
+ $(ACE_ROOT)/ace/Message_Block.i \
+ $(ACE_ROOT)/ace/Time_Value.h \
+ $(ACE_ROOT)/ace/Module.h \
+ $(ACE_ROOT)/ace/Task_T.h \
+ $(ACE_ROOT)/ace/Message_Queue.h \
+ $(ACE_ROOT)/ace/Strategies.h \
+ $(ACE_ROOT)/ace/Strategies_T.h \
+ $(ACE_ROOT)/ace/Synch_Options.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.cpp \
+ $(ACE_ROOT)/ace/Strategies_T.cpp \
+ $(ACE_ROOT)/ace/Service_Repository.h \
+ $(ACE_ROOT)/ace/Service_Types.h \
+ $(ACE_ROOT)/ace/Service_Types.i \
+ $(ACE_ROOT)/ace/Service_Repository.i \
+ $(ACE_ROOT)/ace/Thread_Manager.h \
+ $(ACE_ROOT)/ace/Thread_Manager.i \
+ $(ACE_ROOT)/ace/WFMO_Reactor.h \
+ $(ACE_ROOT)/ace/WFMO_Reactor.i \
+ $(ACE_ROOT)/ace/Message_Queue.i \
+ $(ACE_ROOT)/ace/Message_Queue.cpp \
+ $(ACE_ROOT)/ace/Task.h \
+ $(ACE_ROOT)/ace/Task.i \
+ $(ACE_ROOT)/ace/Task_T.i \
+ $(ACE_ROOT)/ace/Task_T.cpp \
+ $(ACE_ROOT)/ace/Module.i \
+ $(ACE_ROOT)/ace/Module.cpp \
+ $(ACE_ROOT)/ace/Stream_Modules.h \
+ $(ACE_ROOT)/ace/Stream_Modules.i \
+ $(ACE_ROOT)/ace/Stream_Modules.cpp \
+ $(ACE_ROOT)/ace/Stream.i \
+ $(ACE_ROOT)/ace/Stream.cpp \
+ JAWS/JAWS/JAWS/JAWS/Pipeline_Handler.h \
+ JAWS/JAWS/JAWS/JAWS/JAWS/Pipeline.h \
+ JAWS/JAWS/JAWS/JAWS/JAWS/Pipeline_Handler.cpp \
+ JAWS/JAWS/JAWS/JAWS/JAWS/JAWS/Pipeline_Handler.h JAWS/JAWS/Pipeline.h \
+ JAWS/Data_Block.h JAWS/Policy.h JAWS/JAWS/Concurrency.h \
+ JAWS/JAWS/JAWS/IO.h $(ACE_ROOT)/ace/Asynch_IO.h \
+ $(ACE_ROOT)/ace/SOCK_Stream.h \
+ $(ACE_ROOT)/ace/SOCK_IO.h \
+ $(ACE_ROOT)/ace/SOCK.h \
+ $(ACE_ROOT)/ace/Addr.h \
+ $(ACE_ROOT)/ace/Addr.i \
+ $(ACE_ROOT)/ace/IPC_SAP.h \
+ $(ACE_ROOT)/ace/IPC_SAP.i \
+ $(ACE_ROOT)/ace/SOCK.i \
+ $(ACE_ROOT)/ace/SOCK_IO.i \
+ $(ACE_ROOT)/ace/INET_Addr.h \
+ $(ACE_ROOT)/ace/INET_Addr.i \
+ $(ACE_ROOT)/ace/SOCK_Stream.i
+.obj/Data_Block.o .obj/Data_Block.so .shobj/Data_Block.o .shobj/Data_Block.so: Data_Block.cpp JAWS/Data_Block.h \
+ $(ACE_ROOT)/ace/Singleton.h \
+ $(ACE_ROOT)/ace/Synch.h \
+ $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/config.h \
+ $(ACE_ROOT)/ace/config-g++-common.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Basic_Types.i \
+ $(ACE_ROOT)/ace/OS.i \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/Version.h \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/Log_Record.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(ACE_ROOT)/ace/Synch.i \
+ $(ACE_ROOT)/ace/Synch_T.h \
+ $(ACE_ROOT)/ace/Event_Handler.h \
+ $(ACE_ROOT)/ace/Event_Handler.i \
+ $(ACE_ROOT)/ace/Synch_T.i \
+ $(ACE_ROOT)/ace/Thread.h \
+ $(ACE_ROOT)/ace/Thread.i \
+ $(ACE_ROOT)/ace/Atomic_Op.i \
+ $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ JAWS/JAWS/Pipeline.h \
+ $(ACE_ROOT)/ace/Service_Config.h \
+ $(ACE_ROOT)/ace/Service_Object.h \
+ $(ACE_ROOT)/ace/Shared_Object.h \
+ $(ACE_ROOT)/ace/Shared_Object.i \
+ $(ACE_ROOT)/ace/Service_Object.i \
+ $(ACE_ROOT)/ace/Signal.h \
+ $(ACE_ROOT)/ace/Containers.h \
+ $(ACE_ROOT)/ace/Containers.i \
+ $(ACE_ROOT)/ace/Containers.cpp \
+ $(ACE_ROOT)/ace/Malloc.h \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Free_List.h \
+ $(ACE_ROOT)/ace/Free_List.i \
+ $(ACE_ROOT)/ace/Free_List.cpp \
+ $(ACE_ROOT)/ace/Malloc_T.i \
+ $(ACE_ROOT)/ace/Malloc_T.cpp \
+ $(ACE_ROOT)/ace/Memory_Pool.h \
+ $(ACE_ROOT)/ace/Mem_Map.h \
+ $(ACE_ROOT)/ace/Mem_Map.i \
+ $(ACE_ROOT)/ace/Memory_Pool.i \
+ $(ACE_ROOT)/ace/Signal.i \
+ $(ACE_ROOT)/ace/Service_Config.i \
+ $(ACE_ROOT)/ace/Reactor.h \
+ $(ACE_ROOT)/ace/Handle_Set.h \
+ $(ACE_ROOT)/ace/Handle_Set.i \
+ $(ACE_ROOT)/ace/Timer_Queue.h \
+ $(ACE_ROOT)/ace/Timer_Queue_T.h \
+ $(ACE_ROOT)/ace/Timer_Queue_T.i \
+ $(ACE_ROOT)/ace/Timer_Queue_T.cpp \
+ $(ACE_ROOT)/ace/Reactor.i \
+ $(ACE_ROOT)/ace/Reactor_Impl.h \
+ $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \
+ $(ACE_ROOT)/ace/Stream.h \
+ $(ACE_ROOT)/ace/IO_Cntl_Msg.h \
+ $(ACE_ROOT)/ace/Message_Block.h \
+ $(ACE_ROOT)/ace/Message_Block.i \
+ $(ACE_ROOT)/ace/Time_Value.h \
+ $(ACE_ROOT)/ace/Module.h \
+ $(ACE_ROOT)/ace/Task_T.h \
+ $(ACE_ROOT)/ace/Message_Queue.h \
+ $(ACE_ROOT)/ace/Strategies.h \
+ $(ACE_ROOT)/ace/Strategies_T.h \
+ $(ACE_ROOT)/ace/Synch_Options.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.cpp \
+ $(ACE_ROOT)/ace/Strategies_T.cpp \
+ $(ACE_ROOT)/ace/Service_Repository.h \
+ $(ACE_ROOT)/ace/Service_Types.h \
+ $(ACE_ROOT)/ace/Service_Types.i \
+ $(ACE_ROOT)/ace/Service_Repository.i \
+ $(ACE_ROOT)/ace/Thread_Manager.h \
+ $(ACE_ROOT)/ace/Thread_Manager.i \
+ $(ACE_ROOT)/ace/WFMO_Reactor.h \
+ $(ACE_ROOT)/ace/WFMO_Reactor.i \
+ $(ACE_ROOT)/ace/Message_Queue.i \
+ $(ACE_ROOT)/ace/Message_Queue.cpp \
+ $(ACE_ROOT)/ace/Task.h \
+ $(ACE_ROOT)/ace/Task.i \
+ $(ACE_ROOT)/ace/Task_T.i \
+ $(ACE_ROOT)/ace/Task_T.cpp \
+ $(ACE_ROOT)/ace/Module.i \
+ $(ACE_ROOT)/ace/Module.cpp \
+ $(ACE_ROOT)/ace/Stream_Modules.h \
+ $(ACE_ROOT)/ace/Stream_Modules.i \
+ $(ACE_ROOT)/ace/Stream_Modules.cpp \
+ $(ACE_ROOT)/ace/Stream.i \
+ $(ACE_ROOT)/ace/Stream.cpp \
+ JAWS/JAWS/JAWS/Pipeline_Handler.h JAWS/JAWS/JAWS/JAWS/Pipeline.h \
+ JAWS/JAWS/JAWS/JAWS/Pipeline_Handler.cpp \
+ JAWS/JAWS/JAWS/JAWS/JAWS/Pipeline_Handler.h JAWS/Policy.h \
+ JAWS/JAWS/Concurrency.h JAWS/JAWS/JAWS/IO.h \
+ $(ACE_ROOT)/ace/Asynch_IO.h \
+ $(ACE_ROOT)/ace/SOCK_Stream.h \
+ $(ACE_ROOT)/ace/SOCK_IO.h \
+ $(ACE_ROOT)/ace/SOCK.h \
+ $(ACE_ROOT)/ace/Addr.h \
+ $(ACE_ROOT)/ace/Addr.i \
+ $(ACE_ROOT)/ace/IPC_SAP.h \
+ $(ACE_ROOT)/ace/IPC_SAP.i \
+ $(ACE_ROOT)/ace/SOCK.i \
+ $(ACE_ROOT)/ace/SOCK_IO.i \
+ $(ACE_ROOT)/ace/INET_Addr.h \
+ $(ACE_ROOT)/ace/INET_Addr.i \
+ $(ACE_ROOT)/ace/SOCK_Stream.i
+.obj/Policy.o .obj/Policy.so .shobj/Policy.o .shobj/Policy.so: Policy.cpp JAWS/Policy.h JAWS/JAWS/Concurrency.h \
+ $(ACE_ROOT)/ace/Singleton.h \
+ $(ACE_ROOT)/ace/Synch.h \
+ $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/config.h \
+ $(ACE_ROOT)/ace/config-g++-common.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Basic_Types.i \
+ $(ACE_ROOT)/ace/OS.i \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/Version.h \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/Log_Record.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(ACE_ROOT)/ace/Synch.i \
+ $(ACE_ROOT)/ace/Synch_T.h \
+ $(ACE_ROOT)/ace/Event_Handler.h \
+ $(ACE_ROOT)/ace/Event_Handler.i \
+ $(ACE_ROOT)/ace/Synch_T.i \
+ $(ACE_ROOT)/ace/Thread.h \
+ $(ACE_ROOT)/ace/Thread.i \
+ $(ACE_ROOT)/ace/Atomic_Op.i \
+ $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Task.h \
+ $(ACE_ROOT)/ace/Service_Object.h \
+ $(ACE_ROOT)/ace/Shared_Object.h \
+ $(ACE_ROOT)/ace/Shared_Object.i \
+ $(ACE_ROOT)/ace/Service_Object.i \
+ $(ACE_ROOT)/ace/Thread_Manager.h \
+ $(ACE_ROOT)/ace/Containers.h \
+ $(ACE_ROOT)/ace/Containers.i \
+ $(ACE_ROOT)/ace/Containers.cpp \
+ $(ACE_ROOT)/ace/Malloc.h \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Free_List.h \
+ $(ACE_ROOT)/ace/Free_List.i \
+ $(ACE_ROOT)/ace/Free_List.cpp \
+ $(ACE_ROOT)/ace/Malloc_T.i \
+ $(ACE_ROOT)/ace/Malloc_T.cpp \
+ $(ACE_ROOT)/ace/Memory_Pool.h \
+ $(ACE_ROOT)/ace/Signal.h \
+ $(ACE_ROOT)/ace/Signal.i \
+ $(ACE_ROOT)/ace/Mem_Map.h \
+ $(ACE_ROOT)/ace/Mem_Map.i \
+ $(ACE_ROOT)/ace/Memory_Pool.i \
+ $(ACE_ROOT)/ace/Thread_Manager.i \
+ $(ACE_ROOT)/ace/Task.i \
+ $(ACE_ROOT)/ace/Task_T.h \
+ $(ACE_ROOT)/ace/Message_Queue.h \
+ $(ACE_ROOT)/ace/Message_Block.h \
+ $(ACE_ROOT)/ace/Message_Block.i \
+ $(ACE_ROOT)/ace/IO_Cntl_Msg.h \
+ $(ACE_ROOT)/ace/Strategies.h \
+ $(ACE_ROOT)/ace/Strategies_T.h \
+ $(ACE_ROOT)/ace/Service_Config.h \
+ $(ACE_ROOT)/ace/Service_Config.i \
+ $(ACE_ROOT)/ace/Reactor.h \
+ $(ACE_ROOT)/ace/Handle_Set.h \
+ $(ACE_ROOT)/ace/Handle_Set.i \
+ $(ACE_ROOT)/ace/Timer_Queue.h \
+ $(ACE_ROOT)/ace/Timer_Queue_T.h \
+ $(ACE_ROOT)/ace/Timer_Queue_T.i \
+ $(ACE_ROOT)/ace/Timer_Queue_T.cpp \
+ $(ACE_ROOT)/ace/Reactor.i \
+ $(ACE_ROOT)/ace/Reactor_Impl.h \
+ $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \
+ $(ACE_ROOT)/ace/Synch_Options.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.cpp \
+ $(ACE_ROOT)/ace/Strategies_T.cpp \
+ $(ACE_ROOT)/ace/Service_Repository.h \
+ $(ACE_ROOT)/ace/Service_Types.h \
+ $(ACE_ROOT)/ace/Service_Types.i \
+ $(ACE_ROOT)/ace/Service_Repository.i \
+ $(ACE_ROOT)/ace/WFMO_Reactor.h \
+ $(ACE_ROOT)/ace/WFMO_Reactor.i \
+ $(ACE_ROOT)/ace/Message_Queue.i \
+ $(ACE_ROOT)/ace/Message_Queue.cpp \
+ $(ACE_ROOT)/ace/Task_T.i \
+ $(ACE_ROOT)/ace/Task_T.cpp \
+ $(ACE_ROOT)/ace/Module.h \
+ $(ACE_ROOT)/ace/Module.i \
+ $(ACE_ROOT)/ace/Module.cpp \
+ $(ACE_ROOT)/ace/Stream_Modules.h \
+ $(ACE_ROOT)/ace/Stream_Modules.i \
+ $(ACE_ROOT)/ace/Stream_Modules.cpp \
+ JAWS/JAWS/JAWS/IO.h $(ACE_ROOT)/ace/Asynch_IO.h \
+ $(ACE_ROOT)/ace/SOCK_Stream.h \
+ $(ACE_ROOT)/ace/SOCK_IO.h \
+ $(ACE_ROOT)/ace/SOCK.h \
+ $(ACE_ROOT)/ace/Addr.h \
+ $(ACE_ROOT)/ace/Addr.i \
+ $(ACE_ROOT)/ace/IPC_SAP.h \
+ $(ACE_ROOT)/ace/IPC_SAP.i \
+ $(ACE_ROOT)/ace/SOCK.i \
+ $(ACE_ROOT)/ace/SOCK_IO.i \
+ $(ACE_ROOT)/ace/INET_Addr.h \
+ $(ACE_ROOT)/ace/INET_Addr.i \
+ $(ACE_ROOT)/ace/SOCK_Stream.i JAWS/Concurrency.h \
+ JAWS/IO_Handler.h JAWS/IO_Acceptor.h \
+ $(ACE_ROOT)/ace/Asynch_Acceptor.h \
+ $(ACE_ROOT)/ace/LOCK_SOCK_Acceptor.h \
+ $(ACE_ROOT)/ace/SOCK_Acceptor.h \
+ $(ACE_ROOT)/ace/Time_Value.h \
+ $(ACE_ROOT)/ace/SOCK_Acceptor.i \
+ $(ACE_ROOT)/ace/LOCK_SOCK_Acceptor.cpp \
+ JAWS/JAWS/IO.h
+.obj/Concurrency.o .obj/Concurrency.so .shobj/Concurrency.o .shobj/Concurrency.so: Concurrency.cpp JAWS/Concurrency.h \
+ $(ACE_ROOT)/ace/Singleton.h \
+ $(ACE_ROOT)/ace/Synch.h \
+ $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/config.h \
+ $(ACE_ROOT)/ace/config-g++-common.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Basic_Types.i \
+ $(ACE_ROOT)/ace/OS.i \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/Version.h \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/Log_Record.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(ACE_ROOT)/ace/Synch.i \
+ $(ACE_ROOT)/ace/Synch_T.h \
+ $(ACE_ROOT)/ace/Event_Handler.h \
+ $(ACE_ROOT)/ace/Event_Handler.i \
+ $(ACE_ROOT)/ace/Synch_T.i \
+ $(ACE_ROOT)/ace/Thread.h \
+ $(ACE_ROOT)/ace/Thread.i \
+ $(ACE_ROOT)/ace/Atomic_Op.i \
+ $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Task.h \
+ $(ACE_ROOT)/ace/Service_Object.h \
+ $(ACE_ROOT)/ace/Shared_Object.h \
+ $(ACE_ROOT)/ace/Shared_Object.i \
+ $(ACE_ROOT)/ace/Service_Object.i \
+ $(ACE_ROOT)/ace/Thread_Manager.h \
+ $(ACE_ROOT)/ace/Containers.h \
+ $(ACE_ROOT)/ace/Containers.i \
+ $(ACE_ROOT)/ace/Containers.cpp \
+ $(ACE_ROOT)/ace/Malloc.h \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Free_List.h \
+ $(ACE_ROOT)/ace/Free_List.i \
+ $(ACE_ROOT)/ace/Free_List.cpp \
+ $(ACE_ROOT)/ace/Malloc_T.i \
+ $(ACE_ROOT)/ace/Malloc_T.cpp \
+ $(ACE_ROOT)/ace/Memory_Pool.h \
+ $(ACE_ROOT)/ace/Signal.h \
+ $(ACE_ROOT)/ace/Signal.i \
+ $(ACE_ROOT)/ace/Mem_Map.h \
+ $(ACE_ROOT)/ace/Mem_Map.i \
+ $(ACE_ROOT)/ace/Memory_Pool.i \
+ $(ACE_ROOT)/ace/Thread_Manager.i \
+ $(ACE_ROOT)/ace/Task.i \
+ $(ACE_ROOT)/ace/Task_T.h \
+ $(ACE_ROOT)/ace/Message_Queue.h \
+ $(ACE_ROOT)/ace/Message_Block.h \
+ $(ACE_ROOT)/ace/Message_Block.i \
+ $(ACE_ROOT)/ace/IO_Cntl_Msg.h \
+ $(ACE_ROOT)/ace/Strategies.h \
+ $(ACE_ROOT)/ace/Strategies_T.h \
+ $(ACE_ROOT)/ace/Service_Config.h \
+ $(ACE_ROOT)/ace/Service_Config.i \
+ $(ACE_ROOT)/ace/Reactor.h \
+ $(ACE_ROOT)/ace/Handle_Set.h \
+ $(ACE_ROOT)/ace/Handle_Set.i \
+ $(ACE_ROOT)/ace/Timer_Queue.h \
+ $(ACE_ROOT)/ace/Timer_Queue_T.h \
+ $(ACE_ROOT)/ace/Timer_Queue_T.i \
+ $(ACE_ROOT)/ace/Timer_Queue_T.cpp \
+ $(ACE_ROOT)/ace/Reactor.i \
+ $(ACE_ROOT)/ace/Reactor_Impl.h \
+ $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \
+ $(ACE_ROOT)/ace/Synch_Options.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.cpp \
+ $(ACE_ROOT)/ace/Strategies_T.cpp \
+ $(ACE_ROOT)/ace/Service_Repository.h \
+ $(ACE_ROOT)/ace/Service_Types.h \
+ $(ACE_ROOT)/ace/Service_Types.i \
+ $(ACE_ROOT)/ace/Service_Repository.i \
+ $(ACE_ROOT)/ace/WFMO_Reactor.h \
+ $(ACE_ROOT)/ace/WFMO_Reactor.i \
+ $(ACE_ROOT)/ace/Message_Queue.i \
+ $(ACE_ROOT)/ace/Message_Queue.cpp \
+ $(ACE_ROOT)/ace/Task_T.i \
+ $(ACE_ROOT)/ace/Task_T.cpp \
+ $(ACE_ROOT)/ace/Module.h \
+ $(ACE_ROOT)/ace/Module.i \
+ $(ACE_ROOT)/ace/Module.cpp \
+ $(ACE_ROOT)/ace/Stream_Modules.h \
+ $(ACE_ROOT)/ace/Stream_Modules.i \
+ $(ACE_ROOT)/ace/Stream_Modules.cpp JAWS/JAWS/IO.h \
+ $(ACE_ROOT)/ace/Asynch_IO.h \
+ $(ACE_ROOT)/ace/SOCK_Stream.h \
+ $(ACE_ROOT)/ace/SOCK_IO.h \
+ $(ACE_ROOT)/ace/SOCK.h \
+ $(ACE_ROOT)/ace/Addr.h \
+ $(ACE_ROOT)/ace/Addr.i \
+ $(ACE_ROOT)/ace/IPC_SAP.h \
+ $(ACE_ROOT)/ace/IPC_SAP.i \
+ $(ACE_ROOT)/ace/SOCK.i \
+ $(ACE_ROOT)/ace/SOCK_IO.i \
+ $(ACE_ROOT)/ace/INET_Addr.h \
+ $(ACE_ROOT)/ace/INET_Addr.i \
+ $(ACE_ROOT)/ace/SOCK_Stream.i JAWS/Pipeline.h \
+ $(ACE_ROOT)/ace/Stream.h \
+ $(ACE_ROOT)/ace/Time_Value.h \
+ $(ACE_ROOT)/ace/Stream.i \
+ $(ACE_ROOT)/ace/Stream.cpp \
+ JAWS/JAWS/Pipeline_Handler.h JAWS/JAWS/JAWS/Pipeline.h \
+ JAWS/JAWS/JAWS/Pipeline_Handler.cpp \
+ JAWS/JAWS/JAWS/JAWS/Pipeline_Handler.h JAWS/Policy.h \
+ JAWS/JAWS/Concurrency.h JAWS/Data_Block.h JAWS/JAWS/Pipeline.h
+.obj/Server.o .obj/Server.so .shobj/Server.o .shobj/Server.so: Server.cpp $(ACE_ROOT)/ace/Get_Opt.h \
+ $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/config.h \
+ $(ACE_ROOT)/ace/config-g++-common.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Basic_Types.i \
+ $(ACE_ROOT)/ace/OS.i \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/Version.h \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/Log_Record.i \
+ $(ACE_ROOT)/ace/Get_Opt.i JAWS/Server.h \
+ JAWS/JAWS/Data_Block.h $(ACE_ROOT)/ace/Singleton.h \
+ $(ACE_ROOT)/ace/Synch.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(ACE_ROOT)/ace/Synch.i \
+ $(ACE_ROOT)/ace/Synch_T.h \
+ $(ACE_ROOT)/ace/Event_Handler.h \
+ $(ACE_ROOT)/ace/Event_Handler.i \
+ $(ACE_ROOT)/ace/Synch_T.i \
+ $(ACE_ROOT)/ace/Thread.h \
+ $(ACE_ROOT)/ace/Thread.i \
+ $(ACE_ROOT)/ace/Atomic_Op.i \
+ $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ JAWS/JAWS/JAWS/Pipeline.h \
+ $(ACE_ROOT)/ace/Service_Config.h \
+ $(ACE_ROOT)/ace/Service_Object.h \
+ $(ACE_ROOT)/ace/Shared_Object.h \
+ $(ACE_ROOT)/ace/Shared_Object.i \
+ $(ACE_ROOT)/ace/Service_Object.i \
+ $(ACE_ROOT)/ace/Signal.h \
+ $(ACE_ROOT)/ace/Containers.h \
+ $(ACE_ROOT)/ace/Containers.i \
+ $(ACE_ROOT)/ace/Containers.cpp \
+ $(ACE_ROOT)/ace/Malloc.h \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Free_List.h \
+ $(ACE_ROOT)/ace/Free_List.i \
+ $(ACE_ROOT)/ace/Free_List.cpp \
+ $(ACE_ROOT)/ace/Malloc_T.i \
+ $(ACE_ROOT)/ace/Malloc_T.cpp \
+ $(ACE_ROOT)/ace/Memory_Pool.h \
+ $(ACE_ROOT)/ace/Mem_Map.h \
+ $(ACE_ROOT)/ace/Mem_Map.i \
+ $(ACE_ROOT)/ace/Memory_Pool.i \
+ $(ACE_ROOT)/ace/Signal.i \
+ $(ACE_ROOT)/ace/Service_Config.i \
+ $(ACE_ROOT)/ace/Reactor.h \
+ $(ACE_ROOT)/ace/Handle_Set.h \
+ $(ACE_ROOT)/ace/Handle_Set.i \
+ $(ACE_ROOT)/ace/Timer_Queue.h \
+ $(ACE_ROOT)/ace/Timer_Queue_T.h \
+ $(ACE_ROOT)/ace/Timer_Queue_T.i \
+ $(ACE_ROOT)/ace/Timer_Queue_T.cpp \
+ $(ACE_ROOT)/ace/Reactor.i \
+ $(ACE_ROOT)/ace/Reactor_Impl.h \
+ $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \
+ $(ACE_ROOT)/ace/Stream.h \
+ $(ACE_ROOT)/ace/IO_Cntl_Msg.h \
+ $(ACE_ROOT)/ace/Message_Block.h \
+ $(ACE_ROOT)/ace/Message_Block.i \
+ $(ACE_ROOT)/ace/Time_Value.h \
+ $(ACE_ROOT)/ace/Module.h \
+ $(ACE_ROOT)/ace/Task_T.h \
+ $(ACE_ROOT)/ace/Message_Queue.h \
+ $(ACE_ROOT)/ace/Strategies.h \
+ $(ACE_ROOT)/ace/Strategies_T.h \
+ $(ACE_ROOT)/ace/Synch_Options.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.cpp \
+ $(ACE_ROOT)/ace/Strategies_T.cpp \
+ $(ACE_ROOT)/ace/Service_Repository.h \
+ $(ACE_ROOT)/ace/Service_Types.h \
+ $(ACE_ROOT)/ace/Service_Types.i \
+ $(ACE_ROOT)/ace/Service_Repository.i \
+ $(ACE_ROOT)/ace/Thread_Manager.h \
+ $(ACE_ROOT)/ace/Thread_Manager.i \
+ $(ACE_ROOT)/ace/WFMO_Reactor.h \
+ $(ACE_ROOT)/ace/WFMO_Reactor.i \
+ $(ACE_ROOT)/ace/Message_Queue.i \
+ $(ACE_ROOT)/ace/Message_Queue.cpp \
+ $(ACE_ROOT)/ace/Task.h \
+ $(ACE_ROOT)/ace/Task.i \
+ $(ACE_ROOT)/ace/Task_T.i \
+ $(ACE_ROOT)/ace/Task_T.cpp \
+ $(ACE_ROOT)/ace/Module.i \
+ $(ACE_ROOT)/ace/Module.cpp \
+ $(ACE_ROOT)/ace/Stream_Modules.h \
+ $(ACE_ROOT)/ace/Stream_Modules.i \
+ $(ACE_ROOT)/ace/Stream_Modules.cpp \
+ $(ACE_ROOT)/ace/Stream.i \
+ $(ACE_ROOT)/ace/Stream.cpp \
+ JAWS/JAWS/JAWS/JAWS/Pipeline_Handler.h \
+ JAWS/JAWS/JAWS/JAWS/JAWS/Pipeline.h \
+ JAWS/JAWS/JAWS/JAWS/JAWS/Pipeline_Handler.cpp \
+ JAWS/JAWS/JAWS/JAWS/JAWS/JAWS/Pipeline_Handler.h JAWS/Data_Block.h \
+ JAWS/Concurrency.h JAWS/JAWS/IO.h \
+ $(ACE_ROOT)/ace/Asynch_IO.h \
+ $(ACE_ROOT)/ace/SOCK_Stream.h \
+ $(ACE_ROOT)/ace/SOCK_IO.h \
+ $(ACE_ROOT)/ace/SOCK.h \
+ $(ACE_ROOT)/ace/Addr.h \
+ $(ACE_ROOT)/ace/Addr.i \
+ $(ACE_ROOT)/ace/IPC_SAP.h \
+ $(ACE_ROOT)/ace/IPC_SAP.i \
+ $(ACE_ROOT)/ace/SOCK.i \
+ $(ACE_ROOT)/ace/SOCK_IO.i \
+ $(ACE_ROOT)/ace/INET_Addr.h \
+ $(ACE_ROOT)/ace/INET_Addr.i \
+ $(ACE_ROOT)/ace/SOCK_Stream.i JAWS/IO_Handler.h \
+ JAWS/IO_Acceptor.h \
+ $(ACE_ROOT)/ace/Asynch_Acceptor.h \
+ $(ACE_ROOT)/ace/LOCK_SOCK_Acceptor.h \
+ $(ACE_ROOT)/ace/SOCK_Acceptor.h \
+ $(ACE_ROOT)/ace/SOCK_Acceptor.i \
+ $(ACE_ROOT)/ace/LOCK_SOCK_Acceptor.cpp
+.obj/IO_Acceptor.o .obj/IO_Acceptor.so .shobj/IO_Acceptor.o .shobj/IO_Acceptor.so: IO_Acceptor.cpp JAWS/IO_Acceptor.h \
+ $(ACE_ROOT)/ace/Asynch_Acceptor.h \
+ $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/config.h \
+ $(ACE_ROOT)/ace/config-g++-common.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Basic_Types.i \
+ $(ACE_ROOT)/ace/OS.i \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/Version.h \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/Log_Record.i \
+ $(ACE_ROOT)/ace/LOCK_SOCK_Acceptor.h \
+ $(ACE_ROOT)/ace/SOCK_Acceptor.h \
+ $(ACE_ROOT)/ace/SOCK_Stream.h \
+ $(ACE_ROOT)/ace/SOCK_IO.h \
+ $(ACE_ROOT)/ace/SOCK.h \
+ $(ACE_ROOT)/ace/Addr.h \
+ $(ACE_ROOT)/ace/Addr.i \
+ $(ACE_ROOT)/ace/IPC_SAP.h \
+ $(ACE_ROOT)/ace/IPC_SAP.i \
+ $(ACE_ROOT)/ace/SOCK.i \
+ $(ACE_ROOT)/ace/SOCK_IO.i \
+ $(ACE_ROOT)/ace/INET_Addr.h \
+ $(ACE_ROOT)/ace/INET_Addr.i \
+ $(ACE_ROOT)/ace/SOCK_Stream.i \
+ $(ACE_ROOT)/ace/Time_Value.h \
+ $(ACE_ROOT)/ace/SOCK_Acceptor.i \
+ $(ACE_ROOT)/ace/LOCK_SOCK_Acceptor.cpp \
+ $(ACE_ROOT)/ace/Synch.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(ACE_ROOT)/ace/Synch.i \
+ $(ACE_ROOT)/ace/Synch_T.h \
+ $(ACE_ROOT)/ace/Event_Handler.h \
+ $(ACE_ROOT)/ace/Event_Handler.i \
+ $(ACE_ROOT)/ace/Synch_T.i \
+ $(ACE_ROOT)/ace/Thread.h \
+ $(ACE_ROOT)/ace/Thread.i \
+ $(ACE_ROOT)/ace/Atomic_Op.i \
+ $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.h \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp JAWS/JAWS/IO.h \
+ $(ACE_ROOT)/ace/Asynch_IO.h
+.obj/IO_Handler.o .obj/IO_Handler.so .shobj/IO_Handler.o .shobj/IO_Handler.so: IO_Handler.cpp JAWS/IO.h \
+ $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/config.h \
+ $(ACE_ROOT)/ace/config-g++-common.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Basic_Types.i \
+ $(ACE_ROOT)/ace/OS.i \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/Version.h \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/Log_Record.i \
+ $(ACE_ROOT)/ace/Asynch_IO.h \
+ $(ACE_ROOT)/ace/SOCK_Stream.h \
+ $(ACE_ROOT)/ace/SOCK_IO.h \
+ $(ACE_ROOT)/ace/SOCK.h \
+ $(ACE_ROOT)/ace/Addr.h \
+ $(ACE_ROOT)/ace/Addr.i \
+ $(ACE_ROOT)/ace/IPC_SAP.h \
+ $(ACE_ROOT)/ace/IPC_SAP.i \
+ $(ACE_ROOT)/ace/SOCK.i \
+ $(ACE_ROOT)/ace/SOCK_IO.i \
+ $(ACE_ROOT)/ace/INET_Addr.h \
+ $(ACE_ROOT)/ace/INET_Addr.i \
+ $(ACE_ROOT)/ace/SOCK_Stream.i \
+ $(ACE_ROOT)/ace/Singleton.h \
+ $(ACE_ROOT)/ace/Synch.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(ACE_ROOT)/ace/Synch.i \
+ $(ACE_ROOT)/ace/Synch_T.h \
+ $(ACE_ROOT)/ace/Event_Handler.h \
+ $(ACE_ROOT)/ace/Event_Handler.i \
+ $(ACE_ROOT)/ace/Synch_T.i \
+ $(ACE_ROOT)/ace/Thread.h \
+ $(ACE_ROOT)/ace/Thread.i \
+ $(ACE_ROOT)/ace/Atomic_Op.i \
+ $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ JAWS/IO_Handler.h JAWS/Data_Block.h JAWS/JAWS/Pipeline.h \
+ $(ACE_ROOT)/ace/Service_Config.h \
+ $(ACE_ROOT)/ace/Service_Object.h \
+ $(ACE_ROOT)/ace/Shared_Object.h \
+ $(ACE_ROOT)/ace/Shared_Object.i \
+ $(ACE_ROOT)/ace/Service_Object.i \
+ $(ACE_ROOT)/ace/Signal.h \
+ $(ACE_ROOT)/ace/Containers.h \
+ $(ACE_ROOT)/ace/Containers.i \
+ $(ACE_ROOT)/ace/Containers.cpp \
+ $(ACE_ROOT)/ace/Malloc.h \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Free_List.h \
+ $(ACE_ROOT)/ace/Free_List.i \
+ $(ACE_ROOT)/ace/Free_List.cpp \
+ $(ACE_ROOT)/ace/Malloc_T.i \
+ $(ACE_ROOT)/ace/Malloc_T.cpp \
+ $(ACE_ROOT)/ace/Memory_Pool.h \
+ $(ACE_ROOT)/ace/Mem_Map.h \
+ $(ACE_ROOT)/ace/Mem_Map.i \
+ $(ACE_ROOT)/ace/Memory_Pool.i \
+ $(ACE_ROOT)/ace/Signal.i \
+ $(ACE_ROOT)/ace/Service_Config.i \
+ $(ACE_ROOT)/ace/Reactor.h \
+ $(ACE_ROOT)/ace/Handle_Set.h \
+ $(ACE_ROOT)/ace/Handle_Set.i \
+ $(ACE_ROOT)/ace/Timer_Queue.h \
+ $(ACE_ROOT)/ace/Timer_Queue_T.h \
+ $(ACE_ROOT)/ace/Timer_Queue_T.i \
+ $(ACE_ROOT)/ace/Timer_Queue_T.cpp \
+ $(ACE_ROOT)/ace/Reactor.i \
+ $(ACE_ROOT)/ace/Reactor_Impl.h \
+ $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \
+ $(ACE_ROOT)/ace/Stream.h \
+ $(ACE_ROOT)/ace/IO_Cntl_Msg.h \
+ $(ACE_ROOT)/ace/Message_Block.h \
+ $(ACE_ROOT)/ace/Message_Block.i \
+ $(ACE_ROOT)/ace/Time_Value.h \
+ $(ACE_ROOT)/ace/Module.h \
+ $(ACE_ROOT)/ace/Task_T.h \
+ $(ACE_ROOT)/ace/Message_Queue.h \
+ $(ACE_ROOT)/ace/Strategies.h \
+ $(ACE_ROOT)/ace/Strategies_T.h \
+ $(ACE_ROOT)/ace/Synch_Options.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.cpp \
+ $(ACE_ROOT)/ace/Strategies_T.cpp \
+ $(ACE_ROOT)/ace/Service_Repository.h \
+ $(ACE_ROOT)/ace/Service_Types.h \
+ $(ACE_ROOT)/ace/Service_Types.i \
+ $(ACE_ROOT)/ace/Service_Repository.i \
+ $(ACE_ROOT)/ace/Thread_Manager.h \
+ $(ACE_ROOT)/ace/Thread_Manager.i \
+ $(ACE_ROOT)/ace/WFMO_Reactor.h \
+ $(ACE_ROOT)/ace/WFMO_Reactor.i \
+ $(ACE_ROOT)/ace/Message_Queue.i \
+ $(ACE_ROOT)/ace/Message_Queue.cpp \
+ $(ACE_ROOT)/ace/Task.h \
+ $(ACE_ROOT)/ace/Task.i \
+ $(ACE_ROOT)/ace/Task_T.i \
+ $(ACE_ROOT)/ace/Task_T.cpp \
+ $(ACE_ROOT)/ace/Module.i \
+ $(ACE_ROOT)/ace/Module.cpp \
+ $(ACE_ROOT)/ace/Stream_Modules.h \
+ $(ACE_ROOT)/ace/Stream_Modules.i \
+ $(ACE_ROOT)/ace/Stream_Modules.cpp \
+ $(ACE_ROOT)/ace/Stream.i \
+ $(ACE_ROOT)/ace/Stream.cpp \
+ JAWS/JAWS/JAWS/Pipeline_Handler.h JAWS/JAWS/JAWS/JAWS/Pipeline.h \
+ JAWS/JAWS/JAWS/JAWS/Pipeline_Handler.cpp \
+ JAWS/JAWS/JAWS/JAWS/JAWS/Pipeline_Handler.h
+.obj/IO.o .obj/IO.so .shobj/IO.o .shobj/IO.so: IO.cpp JAWS/IO.h $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/config.h \
+ $(ACE_ROOT)/ace/config-g++-common.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Basic_Types.i \
+ $(ACE_ROOT)/ace/OS.i \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/Version.h \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/Log_Record.i \
+ $(ACE_ROOT)/ace/Asynch_IO.h \
+ $(ACE_ROOT)/ace/SOCK_Stream.h \
+ $(ACE_ROOT)/ace/SOCK_IO.h \
+ $(ACE_ROOT)/ace/SOCK.h \
+ $(ACE_ROOT)/ace/Addr.h \
+ $(ACE_ROOT)/ace/Addr.i \
+ $(ACE_ROOT)/ace/IPC_SAP.h \
+ $(ACE_ROOT)/ace/IPC_SAP.i \
+ $(ACE_ROOT)/ace/SOCK.i \
+ $(ACE_ROOT)/ace/SOCK_IO.i \
+ $(ACE_ROOT)/ace/INET_Addr.h \
+ $(ACE_ROOT)/ace/INET_Addr.i \
+ $(ACE_ROOT)/ace/SOCK_Stream.i \
+ $(ACE_ROOT)/ace/Singleton.h \
+ $(ACE_ROOT)/ace/Synch.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(ACE_ROOT)/ace/Synch.i \
+ $(ACE_ROOT)/ace/Synch_T.h \
+ $(ACE_ROOT)/ace/Event_Handler.h \
+ $(ACE_ROOT)/ace/Event_Handler.i \
+ $(ACE_ROOT)/ace/Synch_T.i \
+ $(ACE_ROOT)/ace/Thread.h \
+ $(ACE_ROOT)/ace/Thread.i \
+ $(ACE_ROOT)/ace/Atomic_Op.i \
+ $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ JAWS/IO_Handler.h JAWS/IO_Acceptor.h \
+ $(ACE_ROOT)/ace/Asynch_Acceptor.h \
+ $(ACE_ROOT)/ace/LOCK_SOCK_Acceptor.h \
+ $(ACE_ROOT)/ace/SOCK_Acceptor.h \
+ $(ACE_ROOT)/ace/Time_Value.h \
+ $(ACE_ROOT)/ace/SOCK_Acceptor.i \
+ $(ACE_ROOT)/ace/LOCK_SOCK_Acceptor.cpp \
+ JAWS/JAWS/IO.h $(ACE_ROOT)/ace/Message_Block.h \
+ $(ACE_ROOT)/ace/Malloc.h \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Free_List.h \
+ $(ACE_ROOT)/ace/Free_List.i \
+ $(ACE_ROOT)/ace/Free_List.cpp \
+ $(ACE_ROOT)/ace/Malloc_T.i \
+ $(ACE_ROOT)/ace/Malloc_T.cpp \
+ $(ACE_ROOT)/ace/Memory_Pool.h \
+ $(ACE_ROOT)/ace/Signal.h \
+ $(ACE_ROOT)/ace/Containers.h \
+ $(ACE_ROOT)/ace/Containers.i \
+ $(ACE_ROOT)/ace/Containers.cpp \
+ $(ACE_ROOT)/ace/Signal.i \
+ $(ACE_ROOT)/ace/Mem_Map.h \
+ $(ACE_ROOT)/ace/Mem_Map.i \
+ $(ACE_ROOT)/ace/Memory_Pool.i \
+ $(ACE_ROOT)/ace/Message_Block.i \
+ $(ACE_ROOT)/ace/Filecache.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.cpp \
+ $(ACE_ROOT)/ace/Service_Config.h \
+ $(ACE_ROOT)/ace/Service_Object.h \
+ $(ACE_ROOT)/ace/Shared_Object.h \
+ $(ACE_ROOT)/ace/Shared_Object.i \
+ $(ACE_ROOT)/ace/Service_Object.i \
+ $(ACE_ROOT)/ace/Service_Config.i \
+ $(ACE_ROOT)/ace/Reactor.h \
+ $(ACE_ROOT)/ace/Handle_Set.h \
+ $(ACE_ROOT)/ace/Handle_Set.i \
+ $(ACE_ROOT)/ace/Timer_Queue.h \
+ $(ACE_ROOT)/ace/Timer_Queue_T.h \
+ $(ACE_ROOT)/ace/Timer_Queue_T.i \
+ $(ACE_ROOT)/ace/Timer_Queue_T.cpp \
+ $(ACE_ROOT)/ace/Reactor.i \
+ $(ACE_ROOT)/ace/Reactor_Impl.h \
+ $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \
+ $(ACE_ROOT)/ace/SString.h \
+ $(ACE_ROOT)/ace/SString.i
+
+# IF YOU PUT ANYTHING HERE IT WILL GO AWAY
diff --git a/apps/JAWS/PROTOTYPE/JAWS/Pipeline.cpp b/apps/JAWS/PROTOTYPE/JAWS/Pipeline.cpp
new file mode 100644
index 00000000000..5c8c7464882
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/Pipeline.cpp
@@ -0,0 +1,27 @@
+// $Id$
+
+#include "JAWS/Pipeline.h"
+
+JAWS_Pipeline::JAWS_Pipeline (void)
+{
+}
+
+int
+JAWS_Pipeline::open (void *)
+{
+  // Simply call into the virtual svc() method.
+  if (this->svc () == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "%p\n",
+                       "JAWS_Pipeline::svc"),
+                      -1);
+  return 0;
+}
+
+int
+JAWS_Pipeline::close (u_long)
+{
+  return 0;
+}
+
+#include "JAWS/Pipeline_Handler.cpp"
diff --git a/apps/JAWS/PROTOTYPE/JAWS/Pipeline.h b/apps/JAWS/PROTOTYPE/JAWS/Pipeline.h
new file mode 100644
index 00000000000..16bcc62cdf5
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/Pipeline.h
@@ -0,0 +1,34 @@
+/* -*- c++ -*- */
+// $Id$
+
+#if !defined (JAWS_PIPELINE_H)
+#define JAWS_PIPELINE_H
+
+#include "ace/Synch.h"
+#include "ace/Service_Config.h"
+#include "ace/Stream.h"
+#include "ace/Module.h"
+#include "ace/Task.h"
+
+typedef ACE_Stream<ACE_NULL_SYNCH> JAWS_Pipeline_Stream;
+typedef ACE_Module<ACE_NULL_SYNCH> JAWS_Pipeline_Module;
+typedef ACE_Task<ACE_NULL_SYNCH> JAWS_Pipeline_Task;
+
+class JAWS_IO_Handler;
+class JAWS_Dispatch_Policy;
+
+class JAWS_Pipeline : public JAWS_Pipeline_Task
+  // = TITLE
+  //   Methods that are common to pipeline components
+{
+public:
+  JAWS_Pipeline (void);
+  // ACE_Task hooks
+
+  virtual int open (void * = 0);
+  virtual int close (u_long = 0);
+};
+
+#include "JAWS/Pipeline_Handler.h"
+
+#endif /* !defined (JAWS_PIPELINE_H) */
diff --git a/apps/JAWS/PROTOTYPE/JAWS/Pipeline_Handler.cpp b/apps/JAWS/PROTOTYPE/JAWS/Pipeline_Handler.cpp
new file mode 100644
index 00000000000..64c904c3f96
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/Pipeline_Handler.cpp
@@ -0,0 +1,32 @@
+// $Id$
+
+#if !defined (JAWS_PIPELINE_HANDLER_CPP)
+#define JAWS_PIPELINE_HANDLER_CPP
+
+#include "JAWS/Pipeline_Handler.h"
+
+template <class TYPE>
+JAWS_Pipeline_Abstract_Handler<TYPE>::JAWS_Pipeline_Abstract_Handler (void)
+{
+}
+
+template <class TYPE>
+JAWS_Pipeline_Abstract_Handler<TYPE>::~JAWS_Pipeline_Abstract_Handler (void)
+{
+}
+
+template <class TYPE> int
+JAWS_Pipeline_Abstract_Handler<TYPE>::put (ACE_Message_Block *mb,
+                                           ACE_Time_Value *tv)
+{
+  TYPE *data = ACE_dynamic_cast (TYPE *,
+                                 mb->data_block ());
+
+  int status = this->handle_put (data, tv);
+
+  // If handle_put() is successful, we continue to the next stage of the
+  // pipeline.  Otherwise, we return.
+  return (status != -1) ? this->put_next (mb, tv) : -1;
+}
+
+#endif /* !defined (JAWS_PIPELINE_HANDLER_CPP) */
diff --git a/apps/JAWS/PROTOTYPE/JAWS/Pipeline_Handler.h b/apps/JAWS/PROTOTYPE/JAWS/Pipeline_Handler.h
new file mode 100644
index 00000000000..fb68d07f107
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/Pipeline_Handler.h
@@ -0,0 +1,31 @@
+/* -*- c++ -*- */
+// $Id$
+
+#if !defined (JAWS_PIPELINE_HANDLER_H)
+#define JAWS_PIPELINE_HANDLER_H
+
+#include "JAWS/Pipeline.h"
+
+template <class TYPE>
+class JAWS_Pipeline_Abstract_Handler : public JAWS_Pipeline_Task
+  // = TITLE
+  //   Methods that are common to pipeline components
+{
+public:
+  JAWS_Pipeline_Abstract_Handler (void);
+  virtual ~JAWS_Pipeline_Abstract_Handler (void);
+  // ACE_Task hooks
+
+  virtual int put (ACE_Message_Block *mb, ACE_Time_Value *tv = 0);
+  // inherited from ACE_Task
+
+  virtual int handle_put (TYPE *data, ACE_Time_Value *tv) = 0;
+  // Callback hook for specialized data processing
+
+};
+
+#if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
+#include "JAWS/Pipeline_Handler.cpp"
+#endif
+
+#endif /* !defined (JAWS_PIPELINE_HANDLER_H) */
diff --git a/apps/JAWS/PROTOTYPE/JAWS/Pipeline_Tasks.cpp b/apps/JAWS/PROTOTYPE/JAWS/Pipeline_Tasks.cpp
new file mode 100644
index 00000000000..57bae126682
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/Pipeline_Tasks.cpp
@@ -0,0 +1,60 @@
+// $Id$
+
+#include "JAWS/Pipeline_Tasks.h"
+#include "JAWS/Data_Block.h"
+#include "JAWS/IO_Handler.h"
+#include "JAWS/Policy.h"
+
+int
+JAWS_Pipeline_Accept_Task::handle_put (JAWS_Data_Block *data,
+                                       ACE_Time_Value *)
+{
+  int result = -1;
+
+  // JAWS_Data_Block should contain an INET_Addr and an IO
+  JAWS_IO_Handler *handler = data->io_handler ();
+  JAWS_Dispatch_Policy *policy = data->policy ();
+
+  // data->policy ()->update (handler);
+
+  JAWS_IO *io = policy->io ();
+  io->accept (handler);
+
+  // When accept returns, the resulting handle should be stored into
+  // the JAWS_DATA_BLOCK somewhere.
+
+  // Check the handler for status of the io call
+  switch (handler->status ())
+    {
+    case JAWS_IO_Handler::ACCEPT_OK:
+      result = 0;
+      // At this point need to move to the next task in the pipeline!
+      // The framework will automatically call the next stage.
+      break;
+    case JAWS_IO_Handler::ACCEPT_ERROR:
+      result = -1;
+      // Should recycle the thread
+      break;
+    default:
+      result = -1;
+      // Should mean that the IO is asynchronous, and the word isn't out
+      // yet
+      break;
+    }
+
+  // In asynchronous and synchronous models, we can --
+  //   have the io_handler set the new task in the data_block
+
+  // In asynchronous model, we can --
+  //   insert a wait task into the task queue
+
+  return result;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
+template class JAWS_Pipeline_Abstract_Handler<JAWS_Data_Block>;
+template class ACE_Singleton<JAWS_Pipeline_Accept_Task, ACE_SYNCH_MUTEX>;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate JAWS_Pipeline_Abstract_Handler<JAWS_Data_Block>
+#pragma instantiate ACE_Singleton<JAWS_Pipeline_Accept_Task, ACE_SYNCH_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
diff --git a/apps/JAWS/PROTOTYPE/JAWS/Pipeline_Tasks.h b/apps/JAWS/PROTOTYPE/JAWS/Pipeline_Tasks.h
new file mode 100644
index 00000000000..200ab5eadc0
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/Pipeline_Tasks.h
@@ -0,0 +1,25 @@
+/* -*- c++ -*- */
+// $Id$
+
+#if !defined (JAWS_PIPELINE_TASKS_H)
+#define JAWS_PIPELINE_TASKS_H
+
+#include "ace/Singleton.h"
+
+#include "JAWS/Pipeline.h"
+
+class JAWS_Data_Block;
+
+typedef JAWS_Pipeline_Abstract_Handler<JAWS_Data_Block>
+        JAWS_Pipeline_Handler;
+
+class JAWS_Pipeline_Accept_Task : public JAWS_Pipeline_Handler
+{
+public:
+  virtual int handle_put (JAWS_Data_Block *data, ACE_Time_Value *tv);
+};
+
+typedef ACE_Singleton<JAWS_Pipeline_Accept_Task, ACE_SYNCH_MUTEX>
+        JAWS_Pipeline_Accept_Task_Singleton;
+
+#endif /* !defined (JAWS_DATA_BLOCK_H) */
diff --git a/apps/JAWS/PROTOTYPE/JAWS/Policy.cpp b/apps/JAWS/PROTOTYPE/JAWS/Policy.cpp
new file mode 100644
index 00000000000..c4263b86b8e
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/Policy.cpp
@@ -0,0 +1,71 @@
+// $Id$
+
+#include "JAWS/Policy.h"
+#include "JAWS/Concurrency.h"
+#include "JAWS/IO_Handler.h"
+#include "JAWS/IO_Acceptor.h"
+
+JAWS_Dispatch_Policy::JAWS_Dispatch_Policy (void)
+{
+}
+
+JAWS_Dispatch_Policy::~JAWS_Dispatch_Policy (void)
+{
+}
+
+JAWS_Default_Dispatch_Policy::JAWS_Default_Dispatch_Policy (void)
+  : concurrency_ (JAWS_Thread_Pool_Singleton::instance ()),
+    ioh_factory_ (JAWS_Synch_IO_Handler_Factory_Singleton::instance ()),
+    acceptor_ (JAWS_IO_Synch_Acceptor_Singleton::instance ()),
+    io_ (JAWS_Synch_IO_Singleton::instance ())
+{
+}
+
+JAWS_Default_Dispatch_Policy::~JAWS_Default_Dispatch_Policy (void)
+{
+}
+
+JAWS_IO *
+JAWS_Default_Dispatch_Policy::io (void)
+{
+  return this->io_;
+}
+
+JAWS_IO_Handler_Factory *
+JAWS_Default_Dispatch_Policy::ioh_factory (void)
+{
+  return this->ioh_factory_;
+}
+
+JAWS_IO_Acceptor *
+JAWS_Default_Dispatch_Policy::acceptor (void)
+{
+  return this->acceptor_;
+}
+
+JAWS_Concurrency_Base *
+JAWS_Default_Dispatch_Policy::concurrency (void)
+{
+  return this->concurrency_;
+}
+
+void
+JAWS_Default_Dispatch_Policy::io (JAWS_IO *)
+{
+}
+
+void
+JAWS_Default_Dispatch_Policy::ioh_factory (JAWS_IO_Handler_Factory *)
+{
+}
+
+void
+JAWS_Default_Dispatch_Policy::acceptor (JAWS_IO_Acceptor *)
+{
+}
+
+void
+JAWS_Default_Dispatch_Policy::concurrency (JAWS_Concurrency_Base *concp)
+{
+  this->concurrency_ = concp;
+}
diff --git a/apps/JAWS/PROTOTYPE/JAWS/Policy.h b/apps/JAWS/PROTOTYPE/JAWS/Policy.h
new file mode 100644
index 00000000000..e4556169a6b
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/Policy.h
@@ -0,0 +1,59 @@
+/* -*- c++ -*- */
+// $Id$
+
+#if !defined (JAWS_POLICY_H)
+#define JAWS_POLICY_H
+
+#include "JAWS/Concurrency.h"
+
+class JAWS_IO;
+class JAWS_IO_Handler;
+class JAWS_IO_Handler_Factory;
+
+class JAWS_Dispatch_Policy
+  // = TITLE
+  //     Policy mechanism for choosing different concurrency models.
+  //
+  // = DESCRIPTION
+  //     Given some (unspecified) state, decides what the concurrency
+  //     model should be.  (For now, we always return the same model.)
+{
+public:
+  JAWS_Dispatch_Policy (void);
+  virtual ~JAWS_Dispatch_Policy (void);
+
+  virtual JAWS_IO * io (void) = 0;
+  virtual JAWS_IO_Handler_Factory *ioh_factory (void) = 0;
+  virtual JAWS_IO_Acceptor *acceptor (void) = 0;
+  virtual JAWS_Concurrency_Base * concurrency (void) = 0;
+
+  virtual void io (JAWS_IO *iop) = 0;
+  virtual void ioh_factory (JAWS_IO_Handler_Factory *factoryp) = 0;
+  virtual void acceptor (JAWS_IO_Acceptor *acceptorp) = 0;
+  virtual void concurrency (JAWS_Concurrency_Base *concp) = 0;
+};
+
+class JAWS_Default_Dispatch_Policy : public JAWS_Dispatch_Policy
+{
+public:
+  JAWS_Default_Dispatch_Policy (void);
+  virtual ~JAWS_Default_Dispatch_Policy (void);
+
+  virtual JAWS_IO *io (void);
+  virtual JAWS_IO_Handler_Factory *ioh_factory (void);
+  virtual JAWS_IO_Acceptor *acceptor (void);
+  virtual JAWS_Concurrency_Base *concurrency (void);
+
+  virtual void io (JAWS_IO *iop);
+  virtual void ioh_factory (JAWS_IO_Handler_Factory *factoryp);
+  virtual void acceptor (JAWS_IO_Acceptor *acceptorp);
+  virtual void concurrency (JAWS_Concurrency_Base *concp);
+
+private:
+  JAWS_Concurrency_Base *concurrency_;
+  JAWS_IO_Handler_Factory *ioh_factory_;
+  JAWS_IO_Acceptor *acceptor_;
+  JAWS_IO *io_;
+};
+
+#endif /* !defined (JAWS_POLICY_H) */
diff --git a/apps/JAWS/PROTOTYPE/JAWS/Server.cpp b/apps/JAWS/PROTOTYPE/JAWS/Server.cpp
new file mode 100644
index 00000000000..1aa003f5c7c
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/Server.cpp
@@ -0,0 +1,148 @@
+// $Id$
+
+#include "ace/Get_Opt.h"
+
+#include "JAWS/Server.h"
+#include "JAWS/Data_Block.h"
+#include "JAWS/Concurrency.h"
+#include "JAWS/IO_Handler.h"
+#include "JAWS/IO_Acceptor.h"
+#include "JAWS/Pipeline_Tasks.h"
+
+JAWS_Server::JAWS_Server (void)
+  : port_ (5432),
+    concurrency_ (0),
+    dispatch_ (0),
+    nthreads_ (5),
+    maxthreads_ (20),
+    flags_ (THR_NEW_LWP)
+{
+}
+
+JAWS_Server::JAWS_Server (int argc, char *argv[])
+  : port_ (5432),
+    concurrency_ (0),
+    dispatch_ (0),
+    nthreads_ (5),
+    maxthreads_ (20),
+    flags_ (THR_NEW_LWP)
+{
+  this->init (argc, argv);
+}
+
+void
+JAWS_Server::init (int argc, char *argv[])
+{
+  this->parse_args (argc, argv);
+
+  JAWS_Thread_Pool_Singleton::instance ()->open (this->flags_,
+                                                 this->nthreads_,
+                                                 this->maxthreads_);
+
+  JAWS_Thread_Per_Singleton::instance ()->open (this->flags_,
+                                                this->maxthreads_);
+
+}
+
+int
+JAWS_Server::open (JAWS_Pipeline_Handler *protocol)
+{
+  JAWS_Synch_IO_Handler_Factory synch_factory;
+#if defined (ACE_WIN32)
+  JAWS_Asynch_IO_Handler_Factory asynch_factory;
+#else
+  JAWS_Synch_IO_Handler_Factory &asynch_factory = synch_factory;
+#endif /* defined (ACE_WIN32) */
+
+  JAWS_IO_Handler_Factory *factory;
+  JAWS_IO_Handler *handler;
+  JAWS_Data_Block *db;
+
+  ACE_INET_Addr inet_addr (this->port_);
+  JAWS_IO_Synch_Acceptor_Singleton::instance ()->open (inet_addr);
+  JAWS_IO_Asynch_Acceptor_Singleton::instance ()->open (inet_addr);
+
+  // initialize an IO_Handler
+  factory = (this->dispatch_ == 0) ? &synch_factory : &asynch_factory;
+  handler = factory->create_io_handler ();
+  if (handler == 0)
+    {
+      factory->destroy_io_handler (handler);
+      ACE_DEBUG ((LM_DEBUG, "JAWS_Server::open, can't create handler\n"));
+      return -1;
+    }
+  // handler->task (protocol);
+
+  // initialize data block
+  db = new JAWS_Data_Block;
+  if (db == 0)
+    {
+      factory->destroy_io_handler (handler);
+      ACE_DEBUG ((LM_DEBUG, "JAWS_Server::open, can't create data block\n"));
+      return -1;
+    }
+
+  db->io_handler (handler);
+  db->task (JAWS_Pipeline_Accept_Task_Singleton::instance ());
+
+  // The message block should contain an INET_Addr, and call the
+  // io->accept (INET_Addr) method!
+
+  ACE_Message_Block mb (db);
+
+  JAWS_Concurrency_Base *concurrency;
+  concurrency = (this->concurrency_ == 0)
+    ? JAWS_Thread_Pool_Singleton::instance ()
+    : JAWS_Thread_Per_Singleton::instance ()
+    ;
+
+  concurrency->put (&mb);
+
+  while (ACE_OS::thr_join (0, NULL) != -1)
+    ;
+
+  return 0;
+}
+
+void
+JAWS_Server::parse_args (int argc, char *argv[])
+{
+  int c;
+
+  ACE_Get_Opt getopt (argc, argv, "p:c:d:n:m:f:");
+  while ((c = getopt ()) != -1)
+    switch (c)
+      {
+      case 'p':
+        this->port_ = ACE_OS::atoi (getopt.optarg);
+        break;
+      case 'c':
+        if (ACE_OS::strcmp (getopt.optarg, "PER_REQUEST") == 0)
+          this->concurrency_ = 1;
+        else this->concurrency_ = 0;
+        break;
+      case 'd':
+        if (ACE_OS::strcmp (getopt.optarg, "ASYNCH") == 0)
+          this->dispatch_ = 1;
+        else this->dispatch_ = 0;
+        break;
+      case 'n':
+        this->nthreads_ = ACE_OS::atoi (getopt.optarg);
+        break;
+      case 'm':
+        this->maxthreads_ = ACE_OS::atoi (getopt.optarg);
+        break;
+      case 'f':
+        if (ACE_OS::strcmp (getopt.optarg, "THR_BOUND") == 0)
+          this->flags_ |= THR_BOUND;
+        else if (ACE_OS::strcmp (getopt.optarg, "THR_DAEMON") == 0)
+          this->flags_ |= THR_DAEMON;
+        else if (ACE_OS::strcmp (getopt.optarg, "THR_DETACHED") == 0)
+          this->flags_ |= THR_DETACHED;
+        break;
+      }
+
+  if (this->port_ == 0) this->port_ = 5432;
+  if (this->nthreads_ == 0) this->nthreads_ = 5;
+  if (this->maxthreads_ == 0) this->maxthreads_ = 20;
+}
diff --git a/apps/JAWS/PROTOTYPE/JAWS/Server.h b/apps/JAWS/PROTOTYPE/JAWS/Server.h
new file mode 100644
index 00000000000..e2405e4b360
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/Server.h
@@ -0,0 +1,36 @@
+/* -*- c++ -*- */
+// $Id$
+
+#if !defined (JAWS_SERVER_H)
+#define JAWS_SERVER_H
+
+#include "JAWS/Data_Block.h"
+
+class JAWS_IO_Handler_Factory;
+
+class JAWS_Server
+{
+public:
+  JAWS_Server (void);
+  JAWS_Server (int argc, char *argv[]);
+
+  void init (int argc, char *argv[]);
+  int open (JAWS_Pipeline_Handler *ph);
+
+private:
+  void parse_args (int argc, char *argv[]);
+  // Parse arguments
+
+private:
+  int port_;            // port to listen on
+  int concurrency_;     // 0 => pool, 1 => per request
+  int dispatch_;        // 0 => synch, 1 => asynch
+  int nthreads_;        // number of threads
+  int maxthreads_;      // maximum number of threads
+  long flags_;          // thread creation flags
+
+  JAWS_IO_Handler_Factory *factory_;
+};
+
+
+#endif /* !defined (JAWS_SERVER_H) */
diff --git a/apps/JAWS/PROTOTYPE/Makefile b/apps/JAWS/PROTOTYPE/Makefile
new file mode 100644
index 00000000000..cc09a073937
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/Makefile
@@ -0,0 +1,355 @@
+#----------------------------------------------------------------------------
+#	$Id$
+#
+#	Makefile for the ACE Adapter Web Server (JAWS)
+#----------------------------------------------------------------------------
+
+#----------------------------------------------------------------------------
+#	Local macros
+#----------------------------------------------------------------------------
+
+BIN   	= main
+
+LIB = libJAWS.a
+
+MYFILES  	= \
+	HTTP_Server \
+	HTTP_Config \
+	HTTP_Handler \
+	HTTP_Helpers \
+	JAWS_Pipeline \
+	JAWS_Concurrency \
+	HTTP_Request \
+	HTTP_Response \
+	Parse_Headers \
+	IO_Acceptor \
+	IO
+
+LSRC	= $(addsuffix .cpp,$(MYFILES))
+LOBJ	= $(addsuffix .o,$(MYFILES))
+
+VLDLIBS = $(LDLIBS:%=%$(VAR))
+
+LDLIBS	= -lJAWS
+
+BUILD	= $(VOBJS) $(VLIB) $(VBIN)
+
+#----------------------------------------------------------------------------
+#	Include macros and targets
+#----------------------------------------------------------------------------
+
+include		$(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU
+include		$(ACE_ROOT)/include/makeinclude/macros.GNU
+include		$(ACE_ROOT)/include/makeinclude/rules.common.GNU
+include		$(ACE_ROOT)/include/makeinclude/rules.nonested.GNU
+include		$(ACE_ROOT)/include/makeinclude/rules.lib.GNU
+# The contents of rules.bin.GNU are expanded in Local targets, below.
+# include		$(ACE_ROOT)/include/makeinclude/rules.bin.GNU
+# include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
+
+#----------------------------------------------------------------------------
+#	Local targets
+#----------------------------------------------------------------------------
+
+# Expand rules.bin.GNU, but without the $(VOBJS) dependencies.
+VBIN    = $(BIN:%=%$(VAR))
+
+$(BIN): %: $(VDIR)%.o
+	$(LINK.cc) -o $@ $^ $(LDFLAGS) $(VLDLIBS) $(POSTLINK)
+include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
+
+#----------------------------------------------------------------------------
+#	Dependencies
+#----------------------------------------------------------------------------
+# DO NOT DELETE THIS LINE -- g++dep uses it.
+# DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY.
+
+.obj/HTTP_Server.o .obj/HTTP_Server.so .shobj/HTTP_Server.o .shobj/HTTP_Server.so: HTTP_Server.cpp \
+ $(ACE_ROOT)/ace/Get_Opt.h \
+ $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/config.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/Log_Record.i \
+ $(ACE_ROOT)/ace/Version.h \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/Asynch_Acceptor.h \
+ $(ACE_ROOT)/ace/LOCK_SOCK_Acceptor.h \
+ $(ACE_ROOT)/ace/SOCK_Acceptor.h \
+ $(ACE_ROOT)/ace/SOCK_Stream.h \
+ $(ACE_ROOT)/ace/SOCK_IO.h \
+ $(ACE_ROOT)/ace/SOCK.h \
+ $(ACE_ROOT)/ace/Addr.h \
+ $(ACE_ROOT)/ace/IPC_SAP.h \
+ $(ACE_ROOT)/ace/IPC_SAP.i \
+ $(ACE_ROOT)/ace/SOCK.i \
+ $(ACE_ROOT)/ace/SOCK_IO.i \
+ $(ACE_ROOT)/ace/INET_Addr.h \
+ $(ACE_ROOT)/ace/SOCK_Stream.i \
+ $(ACE_ROOT)/ace/Time_Value.h \
+ $(ACE_ROOT)/ace/Proactor.h \
+ $(ACE_ROOT)/ace/Asynch_IO.h \
+ $(ACE_ROOT)/ace/Thread_Manager.h \
+ $(ACE_ROOT)/ace/Thread.h \
+ $(ACE_ROOT)/ace/Synch.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(ACE_ROOT)/ace/Synch_T.h \
+ $(ACE_ROOT)/ace/Event_Handler.h \
+ $(ACE_ROOT)/ace/Containers.h \
+ $(ACE_ROOT)/ace/Timer_Queue.h \
+ $(ACE_ROOT)/ace/Timer_Queue_T.h \
+ $(ACE_ROOT)/ace/Free_List.h \
+ $(ACE_ROOT)/ace/Timer_List.h \
+ $(ACE_ROOT)/ace/Timer_List_T.h \
+ $(ACE_ROOT)/ace/Timer_Heap.h \
+ $(ACE_ROOT)/ace/Timer_Heap_T.h \
+ $(ACE_ROOT)/ace/Timer_Wheel.h \
+ $(ACE_ROOT)/ace/Timer_Wheel_T.h IO.h \
+ HTTP_Server.h $(ACE_ROOT)/ace/Service_Object.h \
+ $(ACE_ROOT)/ace/Shared_Object.h \
+ $(ACE_ROOT)/ace/Acceptor.h \
+ $(ACE_ROOT)/ace/Service_Config.h \
+ $(ACE_ROOT)/ace/Signal.h \
+ $(ACE_ROOT)/ace/Reactor.h \
+ $(ACE_ROOT)/ace/Handle_Set.h \
+ $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \
+ $(ACE_ROOT)/ace/Svc_Handler.h \
+ $(ACE_ROOT)/ace/Synch_Options.h \
+ $(ACE_ROOT)/ace/Task.h \
+ $(ACE_ROOT)/ace/Task_T.h \
+ $(ACE_ROOT)/ace/Message_Queue.h \
+ $(ACE_ROOT)/ace/Message_Block.h \
+ $(ACE_ROOT)/ace/Malloc.h \
+ $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Memory_Pool.h \
+ $(ACE_ROOT)/ace/Mem_Map.h \
+ $(ACE_ROOT)/ace/IO_Cntl_Msg.h \
+ $(ACE_ROOT)/ace/Strategies.h \
+ $(ACE_ROOT)/ace/Strategies_T.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.h \
+ $(ACE_ROOT)/ace/Dynamic.h \
+ $(ACE_ROOT)/ace/Singleton.h \
+ $(ACE_ROOT)/ace/Acceptor.i HTTP_Handler.h \
+ HTTP_Request.h Parse_Headers.h HTTP_Response.h
+.obj/HTTP_Config.o .obj/HTTP_Config.so .shobj/HTTP_Config.o .shobj/HTTP_Config.so: HTTP_Config.cpp \
+ $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/config.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/Version.h \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/Log_Record.i HTTP_Config.h
+.obj/HTTP_Handler.o .obj/HTTP_Handler.so .shobj/HTTP_Handler.o .shobj/HTTP_Handler.so: HTTP_Handler.cpp \
+ $(ACE_ROOT)/ace/Message_Block.h \
+ $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/config.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/Log_Record.i \
+ $(ACE_ROOT)/ace/Version.h \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/Malloc.h \
+ $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Synch.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(ACE_ROOT)/ace/Synch_T.h \
+ $(ACE_ROOT)/ace/Event_Handler.h \
+ $(ACE_ROOT)/ace/Free_List.h \
+ $(ACE_ROOT)/ace/Memory_Pool.h \
+ $(ACE_ROOT)/ace/Signal.h \
+ $(ACE_ROOT)/ace/Containers.h \
+ $(ACE_ROOT)/ace/Mem_Map.h \
+ $(ACE_ROOT)/ace/Filecache.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.h \
+ $(ACE_ROOT)/ace/SString.h HTTP_Handler.h \
+ $(ACE_ROOT)/ace/Asynch_IO.h HTTP_Request.h \
+ Parse_Headers.h HTTP_Response.h IO.h HTTP_Helpers.h
+.obj/HTTP_Helpers.o .obj/HTTP_Helpers.so .shobj/HTTP_Helpers.o .shobj/HTTP_Helpers.so: HTTP_Helpers.cpp HTTP_Helpers.h \
+ $(ACE_ROOT)/ace/Synch.h \
+ $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/config.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/Log_Record.i \
+ $(ACE_ROOT)/ace/Version.h \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(ACE_ROOT)/ace/Synch_T.h \
+ $(ACE_ROOT)/ace/Event_Handler.h
+.obj/Pipeline.o .obj/Pipeline.so .shobj/Pipeline.o .shobj/Pipeline.so: Pipeline.cpp Pipeline.h \
+ $(ACE_ROOT)/ace/Message_Block.h \
+ $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/config.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/Log_Record.i \
+ $(ACE_ROOT)/ace/Version.h \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/Malloc.h \
+ $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Synch.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(ACE_ROOT)/ace/Synch_T.h \
+ $(ACE_ROOT)/ace/Event_Handler.h \
+ $(ACE_ROOT)/ace/Free_List.h \
+ $(ACE_ROOT)/ace/Memory_Pool.h \
+ $(ACE_ROOT)/ace/Signal.h \
+ $(ACE_ROOT)/ace/Containers.h \
+ $(ACE_ROOT)/ace/Mem_Map.h \
+ $(ACE_ROOT)/ace/Service_Object.h \
+ $(ACE_ROOT)/ace/Shared_Object.h
+.obj/HTTP_Request.o .obj/HTTP_Request.so .shobj/HTTP_Request.o .shobj/HTTP_Request.so: HTTP_Request.cpp \
+ $(ACE_ROOT)/ace/Message_Block.h \
+ $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/config.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/Log_Record.i \
+ $(ACE_ROOT)/ace/Version.h \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/Malloc.h \
+ $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Synch.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(ACE_ROOT)/ace/Synch_T.h \
+ $(ACE_ROOT)/ace/Event_Handler.h \
+ $(ACE_ROOT)/ace/Free_List.h \
+ $(ACE_ROOT)/ace/Memory_Pool.h \
+ $(ACE_ROOT)/ace/Signal.h \
+ $(ACE_ROOT)/ace/Containers.h \
+ $(ACE_ROOT)/ace/Mem_Map.h HTTP_Request.h \
+ Parse_Headers.h HTTP_Helpers.h HTTP_Config.h
+.obj/HTTP_Response.o .obj/HTTP_Response.so .shobj/HTTP_Response.o .shobj/HTTP_Response.so: HTTP_Response.cpp \
+ $(ACE_ROOT)/ace/Process.h \
+ $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/config.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/Version.h \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/Log_Record.i \
+ $(ACE_ROOT)/ace/Mem_Map.h HTTP_Response.h \
+ HTTP_Request.h Parse_Headers.h HTTP_Helpers.h \
+ $(ACE_ROOT)/ace/Synch.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(ACE_ROOT)/ace/Synch_T.h \
+ $(ACE_ROOT)/ace/Event_Handler.h HTTP_Config.h \
+ IO.h $(ACE_ROOT)/ace/Asynch_IO.h
+.obj/Parse_Headers.o .obj/Parse_Headers.so .shobj/Parse_Headers.o .shobj/Parse_Headers.so: Parse_Headers.cpp Parse_Headers.h \
+ $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/config.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/Version.h \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/Log_Record.i
+.obj/IO.o .obj/IO.so .shobj/IO.o .shobj/IO.so: IO.cpp IO.h $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/config.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/Log_Record.i \
+ $(ACE_ROOT)/ace/Version.h \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/Asynch_IO.h HTTP_Helpers.h \
+ $(ACE_ROOT)/ace/Synch.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(ACE_ROOT)/ace/Synch_T.h \
+ $(ACE_ROOT)/ace/Event_Handler.h \
+ $(ACE_ROOT)/ace/Message_Block.h \
+ $(ACE_ROOT)/ace/Malloc.h \
+ $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Free_List.h \
+ $(ACE_ROOT)/ace/Memory_Pool.h \
+ $(ACE_ROOT)/ace/Signal.h \
+ $(ACE_ROOT)/ace/Containers.h \
+ $(ACE_ROOT)/ace/Mem_Map.h \
+ $(ACE_ROOT)/ace/SOCK_Stream.h \
+ $(ACE_ROOT)/ace/SOCK_IO.h \
+ $(ACE_ROOT)/ace/SOCK.h \
+ $(ACE_ROOT)/ace/Addr.h \
+ $(ACE_ROOT)/ace/IPC_SAP.h \
+ $(ACE_ROOT)/ace/IPC_SAP.i \
+ $(ACE_ROOT)/ace/SOCK.i \
+ $(ACE_ROOT)/ace/SOCK_IO.i \
+ $(ACE_ROOT)/ace/INET_Addr.h \
+ $(ACE_ROOT)/ace/SOCK_Stream.i \
+ $(ACE_ROOT)/ace/Filecache.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.h \
+ $(ACE_ROOT)/ace/SString.h
+
+# IF YOU PUT ANYTHING HERE IT WILL GO AWAY
diff --git a/apps/JAWS/PROTOTYPE/main.cpp b/apps/JAWS/PROTOTYPE/main.cpp
new file mode 100644
index 00000000000..01af87928f0
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/main.cpp
@@ -0,0 +1,16 @@
+// $Id$
+
+#include "JAWS/Server.h"
+#include "HTTP_10.h"
+
+int
+main (int argc, char *argv[])
+{
+  JAWS_Server server (argc, argv);
+  HTTP_Pipeline HTTP;
+
+  if (server.open (&HTTP) == -1)
+    ACE_DEBUG ((LM_DEBUG, "JAWS: Error openning server\n"));
+
+  return 0;
+}