Initial revision

INSTALL

@@ -0,0 +1,56 @@
+#
+#  $Id$
+#
+
+NOTE:  The string <release> should be replaced with
+       the appropriate release number of RTEMS.
+
+This file only discusses the installation of .tgz files.
+For more detailed information on the installation of RTEMS,
+refer to the Release Notes manual in the file 
+/pub/rtems/releases/<release>/doc/c_or_ada/relnotes.tgz on
+lancelot.gcs.redstone.army.mil.
+
+UNCOMPRESSING .tgz FILES
+===========================
+Many of the files found in this directory and its subdirectories 
+are gzip'ed, tar archive files.  These files have the ".tgz"
+extension.  They were compressed with gzip version 1.2.4.  
+
+Use a command sequence similar to the following to uncompress each
+file:
+
+   gzcat FILE.tgz | tar xvof -
+
+where FILE.tgz is the file to be installed.  This procedure will
+extract the files in the archive into the current directory.
+All of the .tgz files associated with this release RTEMS will
+place their contents in a subdirectory rtems-<release> in the current
+directory.
+
+If you are unsure of what is in an RTEMS archive file, then use
+the following command sequence to get a listing of the contents:
+
+   gzcat FILE.tgz | tar tvf -
+
+NOTES:  
+
+(1) The "-o" option to tar is included on the tar command line
+    so that the user extracting the tar archive will own the extracted
+    files.
+
+(2) gzcat is sometimes installed as zcat.  Be warned that on many
+    (most) UNIX machines, zcat is associated with compress (.Z files).
+
+(3) If you do not have gzip 1.2.4, it is available from numerous sites
+    including this one.  Other sites include prep.ai.mit.edu and
+    gatekeeper.dec.com.
+    
+(4) The GNU archive files included in this distribution are packaged
+    exactly like they are on official GNU ftp sites.  When extracting
+    GNU archives, they will not extract under a rtems-<version> 
+    directory.  They will extract themselves under a directory which
+    is the name and version of the tool in question.  For example,
+    gcc-2.5.8.tgz will extract its contents into the subdirectory 
+    gcc-2.5.8.
+    

LICENSE

@@ -0,0 +1,118 @@
+#
+#  $Id$
+# 
+                      LICENSE INFORMATION
+
+For the purposes of this document the Real Time Executive for
+Missile Systems (RTEMS) is defined to include all source code,
+documentation, shell utilities developed by On-Line Applications
+Research Corporation (OAR) under contract of the U.S. Army
+Missile Command.  OAR obtained the copyright for RTEMS and
+subsequently assigned ownership of said copyright to the
+U.S. Government.  As part of this transfer, OAR waived all
+claims of ownership for RTEMS.  Since OAR no longer makes claims
+of ownership of RTEMS, OAR in no event shall be held liable 
+for damages including any general, special, incidental or 
+consequential damages arising out of the use or inability 
+to use the RTEMS software or documentation or of the support 
+services provided (including but not limited to loss of data or 
+data being rendered inaccurate or losses sustained by you or 
+third parties or a failure of the program to operate with any 
+other programs), even if advised of the possibility of such damages.
+
+Simply stated any file containing the U.S. Government
+copyright notice or relocatables derived from one or more of
+these files are covered by this agreement.
+
+RTEMS may be reproduced by or for the U.S. Government pursuant
+to the copyright license under the clause at DFARS 252.227-7013.
+The following notice must appear in all copies of RTEMS and its
+derivatives:
+
+    COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+    On-Line Applications Research Corporation (OAR).
+    All rights assigned to U.S. Government, 1994.
+
+    This material may be reproduced by or for the U.S. Government
+    pursuant to the copyright license under the clause at DFARS
+    252.227-7013.  This notice must appear in all copies of this
+    material and its derivatives.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+  1. Redistributions of source code and documentation must retain the 
+     above copyright notice, this list of conditions and the following 
+     disclaimer.
+
+  2. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+     Redistributions in binary form must contain or make available the 
+     RTEMS source code.
+
+  3. All advertising materials mentioning features or use of this software
+     must display the following acknowledgement:
+       This product includes software developed for the U.S. Government 
+       by On-Line Applications Research Corp. 
+
+  4. Neither the name of the author nor the U.S. Government may be used to 
+     endorse or promote products derived from this software without specific 
+     prior written permission.
+ 
+
+RTEMS is provided "AS IS" without warranty of any kind, either
+expressed or implied, including, but not limited to, the implied
+warranties of merchantability, title and fitness for a
+particular purpose.  The U.S. Government does not warrant that 
+the RTEMS software or documentation will satisfy your requirements 
+or that the software and documentation are without defect or error 
+or that the operation of the software will be uninterrupted. 
+
+The U.S. Government shall in no event shall be held liable for 
+damages including any general, special, incidental or consequential 
+damages arising out of the use or inability to use the RTEMS software 
+or documentation or of the support services provided (including
+but not limited to loss of data or data being rendered
+inaccurate or losses sustained by you or third parties or a
+failure of the program to operate with any other programs), even
+if the U.S. Government has been advised of the possibility of such damages.
+
+The U.S. Government reserves the right to revise this material 
+and to make changes from time to time in the content hereof without
+obligation to notify anyone or any organization of such revision
+or changes.  
+
+OAR remains the sole organization authorized by contract to
+distribute or provide support and training for the Real-Time
+Executive for Military Systems (RTEMS).
+
+In order to promote future research activities within the U.S.
+Government, we request that potential users of RTEMS notify us
+as to the systems that RTEMS is being utilized.  This will allow
+us to publicize our Dual-Use / Reuse capabilities in support of
+the current administration's goals.  This can be accomplished by
+calling the RTEMS phone numbers published in the documentation
+or by electronic mail to "rtems@redstone-emh2.army.mil".  Your
+cooperation is greatly appreciated.  Again, thank you for using
+RTEMS.
+
+RTEMS
+U.S. ARMY Missile Command
+ATTN: AMSMI-RD-GC-S
+Redstone Arsenal, AL 35898-5254
+Voice: (205) 842-6906
+FAX:   (205) 842-6917
+EMAIL: rtems@redstone.army.mil
+
+
+On-Line Applications Research Corporation.
+2227 Drake Avenue SW
+Suite 10-F
+Huntsville, AL 35805
+(205) 883-0131
+
+
+
+

README

@@ -0,0 +1,93 @@
+#
+#  $Id$
+#
+
+Directory Overview
+==================
+
+This is the top level of the RTEMS directory structure.  The following 
+is a description of the files and directories in this directory:
+
+  INSTALL
+    Rudimentary installation instructions.  For more detailed
+    information please see the Release Notes.  The Postscript 
+    version of this manual can be found in the file
+    c_or_ada/doc/relnotes.tgz.
+
+  LICENSE
+    Required legalese.
+
+  README
+    This file.
+
+  c
+    This directory contains the source code for the C 
+    implementation of RTEMS as well as the test suites, sample 
+    applications, Board Support Packages, Device Drivers, and 
+    support libraries.
+
+  doc
+    This directory contains the PDL for the RTEMS executive.
+
+Ada versus C
+============
+
+There are two implementations of RTEMS in this source tree -- 
+in Ada and in C.  These two implementations are functionally
+and structurally equivalent.  The C implementation follows
+the packaging conventions and hiearchical nature of the Ada 
+implementation.  In addition, a style has been followed which 
+allows one to easily find the corresponding Ada and C 
+implementations.  
+
+File names in C and code placement was carefully designed to insure
+a close mapping to the Ada implementation.  The following file name 
+extensions are used:
+
+   .adb - Ada body
+   .ads - Ada specification
+   .adp - Ada body requiring preprocessing
+   .inc - include file for .adp files
+
+   .c   - C body (non-inlined routines)
+   .inl - C body (inlined routines)
+   .h   - C specification
+
+In the executive source, XYZ.c and XYZ.inl correspond directly to a 
+single XYZ.adb or XYZ.adp file.  A .h file corresponds directly to
+the .ads file.  There are only a handful of .inc files in the 
+Ada source and these are used to insure that the desired simple 
+inline textual expansion is performed.  This avoids scoping and
+calling convention side-effects in carefully constructed tests 
+which usually test context switch behavior.
+
+In addition, in Ada code and data name references are always fully
+qualified as PACKAGE.NAME.  In C, this convention is followed 
+by having the package name as part of the name itself and using a
+capital letter to indicate the presence of a "." level.  So we have
+PACKAGE.NAME in Ada and _Package_Name in C.  The leading "_" in C
+is used to avoid naming conflicts between RTEMS and user variables.
+By using these conventions, one can easily compare the C and Ada
+implementations.
+
+The most noticeable difference between the C and Ada83 code is 
+the inability to easily obtain a "typed pointer" in Ada83.  
+Using the "&" operator in C yields a pointer with a specific type.
+The 'Address attribute is the closest feature in Ada83.  This
+returns a System.Address and this must be coerced via Unchecked_Conversion
+into an access type of the desired type.  It is easy to view 
+System.Address as similar to a "void *" in C, but this is not the case.
+A "void *" can be assigned to any other pointer type without an
+explicit conversion.  
+
+The solution adopted to this problem was to provide two routines for
+each access type in the Ada implementation -- one to convert from
+System.Address to the access type and another to go the opposite
+direction.  This results in code which accomplishes the same thing
+as the corresponding C but it is easier to get lost in the clutter
+of the apparent subprogram invocations than the "less bulky"
+C equivalent.
+
+A related difference is the types which are only in Ada which are used 
+for pointers to arrays.  These types do not exist and are not needed 
+in the C implementation.

SUPPORT

@@ -0,0 +1,18 @@
+#
+#  $Id$
+#
+
+For support and training contact:
+
+On-Line Applications Research
+2227 Drake Avenue SW Suite 10-F
+Huntsville AL 35805
+(205) 883-0131
+
+OAR offers support and classes for RTEMS as well as custom 
+development services such as ports to new processors and 
+the development of custom board support packages and device
+drivers.
+
+OAR developed RTEMS under contract to the U.S. Army Missile Command.
+

c/ACKNOWLEDGEMENTS

@@ -0,0 +1,51 @@
+#
+#  $Id$
+#
+
+RTEMS was developed by On-Line Applications Research (OAR) under
+contract to the U.S. Army Missile Command.  Other than the
+contributions listed in this document, all code and documentation
+was developed by OAR for the Army.
+
+The RTEMS project would like to thank those who have made
+contributions to the project.  Together we make RTEMS a
+much better product.
+
+The following persons/organizations have made contributions:
+
++ Dr. Mikhail (Misha) Savitski (mms@eiscathq.irf.se) of the EISCAT Scientific
+  Association submitted the BSP and other miscellaneous support for the
+  Motorola MVME162 (M68040LC CPU) VMEbus single board computer.
+
++ Division Inc. of Chapel Hill, NC for sponsoring On-Line Applications
+  Research to port RTEMS to the Hewlett-Packard PA-RISC architecture (V1.1)
+  and the addition of HP-UX as a development host. Tony Bennett
+  (tbennett@divnc.com) was assisted in this effort by Joel Sherrill
+  (jsherril@redstone.army.mil).  Tony also deserves a big pat on the
+  back for contributing significantly to the overall organization
+  of the development environment and directory structure.  RTEMS
+  is much easier to build because of Tony.
+
++ Greg Allen of Division Inc. of Chapel Hill, NC for 
+  porting RTEMS to HP-UX.  This port treats a UNIX computer as simply
+  another RTEMS target processor.  This port can be used to develop 
+  and test code which will ultimately run on the embedded platform.
+
++ Doug McBride (mcbride@rodin.colorado.edu) of the Colorado Space Grant
+  College at the University of Colorado at Boulder submitted the BSP
+  for the Motorola IDP board (M68EC040 CPU) single board computer.  The
+  BSP leverages heavily off of the existing RTEMS BSP framework, the
+  examples in the back of the IDP user's manual, and the libgloss example
+  support for the IDP board from the newlib/libgloss distribution.
+
+Finally, the RTEMS project would like to thank those who have contributed
+to the other free software efforts which RTEMS utilizes.  The primary RTEMS
+development environment is from the Free Software Foundation (the GNU
+project).  The "newlib" C library was put together by Cygnus and is
+a collaboration of the efforts of numerous individuals and organizations.
+
+We would like to see your name here.  BSPs and ports are always welcome.
+Useful libraries which support RTEMS applications are also an important
+part of providing a strong foundation for the development of real-time
+embedded applications and are welcome as submission.
+

c/PROBLEMS

@@ -0,0 +1,39 @@
+#
+#  $Id$
+#
+
+This is the list of outstanding problems in this release.
+
+1.  The m68000 support is not complete.  Someone with target hardware
+    needs to complete the missing gaps.  Look for ifdef's based on the
+    M68K_* macros defined in c/make/cpu/m68k.cfg.  Most of the code
+    is present but none of it is tested.  An attempt was made to insert
+    "#warnings" preprocessor directives in the appropriate places.
+    So these are a good starting spot.
+
+2.  The only i960 family member tested is the CA.  No support for the
+    floating point support found in other family members is present.
+    This also implies that RTEMS may "think" of something as generic
+    across the i960 family when in fact it is specific to the CA.
+
+3.  The __read() system call in all of the BSPs using single
+    character input/output needs to be smarter.  The following
+    issues need to be addressed:
+
+       + echoing of characters on input
+       + CR/NL echoing
+       + backspaces
+       + tabs
+
+4.  Solaris 2.3 port notes:
+
+       + Some of the tests run correctly when run interactively but
+         the screen and output do not match when the output is 
+         redirected to a file.
+
+       + sometimes a stray SIGALRM is reported as spfatal completes.
+
+5.  Some of the tests may execute correctly and not produce the exact
+    ordering of lines in the screen file.  This appears to be a combination
+    of a number of factors including buffering, processor speed, IO
+    device overhead, and clock interrupt rate.

c/README

@@ -0,0 +1,45 @@
+#
+#  $Id$
+#
+
+This is the top level of the RTEMS directory structure.  The following
+is a description of the files and directories in this directory:
+
+  LICENSE
+    Required legalese.
+
+  Makefile
+    The top-level Make command file used to build the C implementation
+    of RTEMS.  [RTEMS assumes the use of GNU make.]
+
+  Modules
+    Example Modules command files used to configure the user's environment
+    for RTEMS.  These require the Modules system administration package
+    available from numerous ftp sites.
+
+  README
+    This file.
+
+  REQUIRES
+    A list of the other tools which are assumed to be installed
+    before RTEMS is built.
+
+  SUPPORT
+    Information on third-party support for RTEMS.
+
+  build-tools
+    This directory contains the source for various utilities
+    needed to build RTEMS.
+
+  make
+    Make command files "included" from those in the source distribution.
+    [RTEMS assumes the use of GNU make.]
+
+  patches
+    This directory contains patches for this release of RTEMS.
+
+  src
+    This directory contains the source code for the C
+    implementation of RTEMS as well as the test suites, sample
+    applications, Board Support Packages, Device Drivers, and
+    support libraries.

c/REQUIRES

@@ -0,0 +1,13 @@
+#
+#  $Id$
+#
+
+1.  The installation procedure assumes that "gcc" is installed
+    and is in your path for the installation of local tools.
+
+2.  gcc 2.6.3 with crossgcc patches (ftp.cygnus.com:/pub/embedded)
+
+3.  binutils 2.5.2
+
+4.  newlib with RTEMS configurations.
+

c/UPDATE_HELP

@@ -0,0 +1,17 @@
+#
+# $Id$
+#
+
+In the directory "update_tools", there are a set of tools to aid in
+making the application source changes necessary to address some
+of the changes in the RTEMS API between release 3.1.0 and 3.2.0.
+
+The primary change addressed by these tools is the addition of
+"rtems_" or "RTEMS_" as a prefix on EVERY user visible RTEMS
+provided constant and routine.  The primary factor in the decision
+to make such a sweeping change was conflicts between the
+the RTEMS and POSIX API's.
+
+WARNING: These tools modify the files IN PLACE!!! Backup your
+  source before using these tools.
+

c/build-tools/README

@@ -0,0 +1,32 @@
+#
+#  $Id$
+#
+
+Misc. support tools for RTEMS workspaces.
+More will be added later as they are converted from Teamware
+to CVS.
+
+install-if-change
+    Smart install script that also can append suffixes as it
+    installs (suffixes used for debug and profile variants).
+    Requires bash or ksh.
+
+rcs-clean
+    deletes all files from the current directory that can be
+    re-created from RCS.  Careful to not delete locked files.
+    May be used by 'gmake clobber'
+
+lock-directory
+unlock-directory
+    traverse a directory structure making it unwritable.
+    Useful to keep people from accidentally overwriting
+    "released" trees if they get confused about which
+    module they have loaded.
+
+rtems-glom
+    glom together all the rtems libraries in order to simplify
+    the link line used by applications.
+    Produces rtems.rel.
+    Not used by the RTEMS src tree at all.
+    Strictly optional.
+

c/build-tools/cklength.c

@@ -0,0 +1,364 @@
+/*
+ *  cklength - check the length of lines in a file
+ *
+ *  This program check to see if the files passed to it on the command line
+ *  contain a line which exceeds the maximum allowable length.  The default
+ *  maximum line length is 80.
+ *
+ *  usage:  cklength  [ -v ] [ arg ... ] files...
+ *           -l length   -- maximum line length
+ *           -v          -- verbose
+ *
+ * $Id$
+ * $Log$
+ */
+
+#define GETOPTARGS "l:nNv"
+
+char *USAGE = "\
+usage:  cklength  [ -v ] [ arg ... ] files... \n\
+            -l length   -- maximum line length\n\
+            -n          -- report line numbers for offending lines\n\
+            -N          -- report line numbers and length for offending lines\n\
+            -v          -- verbose\n\
+\n\
+Print the name of files which have at least 1 line which exceeds the\n\
+maximum line length.  The default maximum line length is 80.\n\
+";
+
+#include <stdio.h>
+#include <fcntl.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <memory.h>
+#include <stdarg.h>
+
+#define BUFFER_SIZE     512
+
+#define SUCCESS         0
+#define FAILURE         -1
+#define Failed(x)       (((int) (x)) == FAILURE)
+#define TRUE    1
+#define FALSE   0
+#define STREQ(a,b)      (strcmp(a,b) == 0)
+#define NUMELEMS(arr)   (sizeof(arr) / sizeof(arr[0]))
+
+/*
+ * Definitions for unsigned "ints"; especially for use in data structures
+ *  that will be shared among (potentially) different cpu's (we punt on
+ *  byte ordering problems tho)
+ */
+
+typedef unsigned char   u8;
+typedef unsigned short  u16;
+typedef unsigned long   u32;
+
+/*
+ * vars controlled by command line options
+ */
+
+int verbose = FALSE;                    /* be verbose */
+int report_line_numbers = FALSE;        /* report line numbers of offenders */
+int report_line_length = FALSE;         /* report line length of offenders */
+
+int line_length = 80;                   /* maximum allowable line length */
+
+extern char *optarg;                    /* getopt(3) control vars */
+extern int optind, opterr;
+extern int errno;
+
+char *progname;                         /* for error() */
+
+int process(char *arg);
+void error(int errn, ...);
+long getparm(char *s, long min, long max, char *msg);
+
+#define ERR_ERRNO  (1<<((sizeof(int) * 8) - 2)) /* hi bit; use 'errno' */
+#define ERR_FATAL  (ERR_ERRNO / 2)              /* fatal error ; no return */
+#define ERR_ABORT  (ERR_ERRNO / 4)              /* fatal error ; abort */
+#define ERR_MASK   (ERR_ERRNO | ERR_FATAL | ERR_ABORT) /* all */
+
+#define stol(p) strtol(p, (char **) NULL, 0)
+int  Open(), Read(), Write();
+
+int
+main(int argc, char **argv, char **env)
+{
+    register int c;
+    int showusage = FALSE;                      /* usage error? */
+    int rc = 0;
+
+    /*
+     * figure out invocation leaf-name
+     */
+
+    if ((progname = strrchr(argv[0], '/')) == (char *) NULL)
+        progname = argv[0];
+    else
+        progname++;
+
+    argv[0] = progname;                         /* for getopt err reporting */
+
+    /*
+     *  Check options and arguments.
+     */
+
+    opterr = 0;                                 /* we'll report all errors */
+    while ((c = getopt(argc, argv, GETOPTARGS)) != EOF)
+        switch (c)
+        {
+            case 'l':                            /* line length */
+                line_length = atoi( optarg );
+                if ( line_length < 0 || line_length > BUFFER_SIZE )
+                  error(ERR_FATAL, "(%d) is illegal line length\n",line_length);
+                break;
+
+            case 'n':                           /* toggle report_line_numbers */
+                report_line_numbers = ! report_line_numbers;
+                break;
+
+            case 'N':                           /* toggle both reports */
+                report_line_numbers = ! report_line_numbers;
+                report_line_length  = ! report_line_length;
+                break;
+
+            case 'v':                           /* toggle verbose */
+                verbose = ! verbose;
+                break;
+
+            case '?':
+                showusage = TRUE;
+        }
+
+    if (showusage)
+    {
+        (void) fprintf(stderr, "%s", USAGE);
+        exit(1);
+    }
+
+    /*
+     *  traverse and process the arguments
+     */
+
+    for ( ; argv[optind]; optind++)
+        if (Failed(process(argv[optind])))
+            rc = FAILURE;
+
+    return rc;
+}
+
+
+/*
+ * process(arg)
+ */
+
+int
+process(char *arg)
+{
+  FILE   *in;
+  char   *bptr;
+  char    buffer[ BUFFER_SIZE ];
+  int     line_number;
+  int     length;
+  int     count;
+  int     rc = SUCCESS;  /* succeed by default */
+
+  in = fopen( arg, "r" );
+  if (!in)
+    error( ERR_ERRNO | ERR_FATAL, "Unable to open file (%s)\n", arg );
+
+  count = 0;
+
+  for ( line_number=1 ; ; line_number++ ) {
+    bptr = fgets( buffer, BUFFER_SIZE, in );
+    if (!bptr)
+      break;
+
+    /*
+     *  Don't count the carriage return.
+     */
+
+    length = strlen( buffer ) - 1;
+
+    if ( length <= line_length )
+      continue;
+
+    if ( count == 0 ) {
+      fprintf( stderr, "%s\n", arg );
+      if ( !report_line_numbers )
+        break;
+    }
+
+    if ( verbose )
+      fprintf( stderr, "TOO LONG:%d: %s\n", line_number, buffer );
+
+    if ( report_line_numbers ) {
+      if ( report_line_length )
+        fprintf( stderr, "%d: %d\n" , line_number, length );
+      else
+        fprintf( stderr, "%d\n" , line_number );
+    }
+
+    count++;
+
+  }
+
+  fclose( in );
+  return rc;
+}
+
+/*
+ * error(errn, arglist)
+ *      report an error to stderr using printf(3) conventions.
+ *      Any output is preceded by '<progname>: '
+ *
+ * Uses ERR_FATAL bit to request exit(errn)
+ *      ERR_ABORT to request abort()
+ *      ERR_ERRNO to indicate use of errno instead of argument.
+ *
+ * If resulting 'errn' is non-zero, it is assumed to be an 'errno' and its
+ *      associated error message is appended to the output.
+ */
+
+/*VARARGS*/
+
+void
+error(int error_flag, ...)
+{
+    va_list arglist;
+    register char *format;
+    extern char *sys_errlist[];
+    extern int sys_nerr;
+    int local_errno;
+
+    extern int errno;
+
+    (void) fflush(stdout);          /* in case stdout/stderr same */
+
+    local_errno = error_flag & ~ERR_MASK;
+    if (error_flag & ERR_ERRNO)     /* use errno? */
+        local_errno = errno;
+
+    va_start(arglist, error_flag);
+    format = va_arg(arglist, char *);
+    (void) fprintf(stderr, "%s: ", progname);
+    (void) vfprintf(stderr, format, arglist);
+    va_end(arglist);
+
+    if (local_errno)
+        if ((local_errno > 0) && (local_errno < sys_nerr))
+            (void) fprintf(stderr, " (%s)\n", sys_errlist[local_errno]);
+        else
+            (void) fprintf(stderr, " (unknown errno=%d)\n", local_errno);
+    else
+        (void) fprintf(stderr, "\n");
+
+    (void) fflush(stderr);
+
+    if (error_flag & (ERR_FATAL | ERR_ABORT))
+    {
+        if (error_flag & ERR_FATAL)
+        {
+            error(0, local_errno ? "fatal error, exiting" : "exiting");
+            exit(local_errno);
+        }
+        else
+        {
+            error(0, "fatal error, aborting");
+            abort();
+        }
+    }
+}
+
+long
+getparm(char *s,
+        long min,
+        long max,
+        char *msg)
+{
+    long val;
+
+    if ( ! strchr("0123456789-", *s))
+    {
+        error(ERR_FATAL, "'%s' is not a number", s);
+        return min;
+    }
+
+    val = strtol(s, (char **) NULL, 0);
+    if ((val < min) || (val > max))
+    {
+        if (min == max)
+            error(ERR_FATAL, "%s can only be %ld", s, min);
+        else
+            error(ERR_FATAL, "%s must be between %ld and %ld", msg, min, max);
+    }
+
+    return val;
+}
+
+
+/*
+ * Open()
+ *      Perform open(2), returning the file descriptor.  Prints
+ *      error message if open fails.
+ */
+
+int
+Open(char *file,
+     int oflag,
+     int mode)
+{
+    int O_fd;
+
+    if (Failed(O_fd = open(file, oflag, mode)))
+        error(
+          ERR_ERRNO | ERR_FATAL,
+          "open('%s', 0x%x, 0%o) failed", file, oflag, mode
+        );
+
+    return O_fd;
+}
+
+/*
+ * Read()
+ *      Perform read(2); prints error message if fails.
+ */
+
+int
+Read(int file,
+     char *buffer,
+     unsigned int count)
+{
+    int nbytes;
+
+    if (Failed(nbytes = read(file, buffer, count)))
+        error(
+          ERR_ERRNO | ERR_FATAL,
+          "read(%d, 0x%x, %d) failed", file, buffer, count
+         );
+
+    return nbytes;
+}
+
+/*
+ * Write()
+ *      Perform write(2); prints error message if fails.
+ */
+
+int
+Write(int file,
+      char *buffer,
+      unsigned int count)
+{
+    int nbytes;
+
+    if (Failed(nbytes = write(file, buffer, count)))
+        error(
+          ERR_ERRNO | ERR_FATAL,
+          "write(%d, 0x%x, %d) failed", file, buffer, count
+        );
+
+    return nbytes;
+}

c/build-tools/eolstrip.c

@@ -0,0 +1,351 @@
+/*
+ *  eolstrip - strip white space from end of lines
+ *
+ *  This program strips the white space from the end of every line in the
+ *  specified program.
+ *
+ *  usage:  eolstrip  [ -v ] [ arg ... ] files...
+ *           -v          -- verbose
+ *
+ * $Id$
+ * $Log$
+ */
+
+#define GETOPTARGS "vt"
+
+char *USAGE = "\
+usage:  cklength  [ -v ] [ arg ... ] files... \n\
+            -v          -- verbose\n\
+            -t          -- test only .. DO NOT OVERWRITE FILE!!!\n\
+\n\
+Strip the white space from the end of every line on the list of files.\n\
+";
+
+#include <stdio.h>
+#include <fcntl.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <memory.h>
+#include <stdarg.h>
+
+#define BUFFER_SIZE     2048
+#define MAX_PATH        2048
+
+#define SUCCESS         0
+#define FAILURE         -1
+#define Failed(x)       (((int) (x)) == FAILURE)
+#define TRUE    1
+#define FALSE   0
+#define STREQ(a,b)      (strcmp(a,b) == 0)
+#define NUMELEMS(arr)   (sizeof(arr) / sizeof(arr[0]))
+
+/*
+ * Definitions for unsigned "ints"; especially for use in data structures
+ *  that will be shared among (potentially) different cpu's (we punt on
+ *  byte ordering problems tho)
+ */
+
+typedef unsigned char   u8;
+typedef unsigned short  u16;
+typedef unsigned long   u32;
+
+/*
+ * vars controlled by command line options
+ */
+
+int verbose = FALSE;                    /* be verbose */
+int test_only = FALSE;                  /* test only */
+
+extern char *optarg;                    /* getopt(3) control vars */
+extern int optind, opterr;
+extern int errno;
+
+char *progname;                         /* for error() */
+
+int process(char *arg);
+void error(int errn, ...);
+long getparm(char *s, long min, long max, char *msg);
+
+#define ERR_ERRNO  (1<<((sizeof(int) * 8) - 2)) /* hi bit; use 'errno' */
+#define ERR_FATAL  (ERR_ERRNO / 2)              /* fatal error ; no return */
+#define ERR_ABORT  (ERR_ERRNO / 4)              /* fatal error ; abort */
+#define ERR_MASK   (ERR_ERRNO | ERR_FATAL | ERR_ABORT) /* all */
+
+#define stol(p) strtol(p, (char **) NULL, 0)
+int  Open(), Read(), Write();
+
+int
+main(int argc, char **argv, char **env)
+{
+    register int c;
+    int showusage = FALSE;                      /* usage error? */
+    int rc = 0;
+
+    /*
+     * figure out invocation leaf-name
+     */
+
+    if ((progname = strrchr(argv[0], '/')) == (char *) NULL)
+        progname = argv[0];
+    else
+        progname++;
+
+    argv[0] = progname;                         /* for getopt err reporting */
+
+    /*
+     *  Check options and arguments.
+     */
+
+    opterr = 0;                                 /* we'll report all errors */
+    while ((c = getopt(argc, argv, GETOPTARGS)) != EOF)
+        switch (c)
+        {
+            case 't':                           /* toggle test only mode */
+                test_only = ! test_only;
+                break;
+
+            case 'v':                           /* toggle verbose */
+                verbose = ! verbose;
+                break;
+
+            case '?':
+                showusage = TRUE;
+        }
+
+    if (showusage)
+    {
+        (void) fprintf(stderr, "%s", USAGE);
+        exit(1);
+    }
+
+    /*
+     *  traverse and process the arguments
+     */
+
+    for ( ; argv[optind]; optind++)
+        if (Failed(process(argv[optind])))
+            rc = FAILURE;
+
+    return rc;
+}
+
+
+/*
+ * process(arg)
+ */
+
+int
+process(char *arg)
+{
+  FILE   *in;
+  FILE   *out = (FILE *) 0;
+  char    outname[ MAX_PATH ];
+  char   *bptr;
+  char    buffer[ BUFFER_SIZE ];
+  int     length;
+  int     line_number;
+  int     rc = SUCCESS;  /* succeed by default */
+
+  in = fopen( arg, "r" );
+  if (!in)
+    error( ERR_ERRNO | ERR_FATAL, "Unable to open file (%s)\n", arg );
+
+  if ( !test_only ) {
+    sprintf( outname, "%s.eoltmp", arg );
+
+    out = fopen( outname, "w" );
+    if (!out)
+      error( ERR_ERRNO | ERR_FATAL, "Unable to open file (%s)\n", arg );
+  }
+
+  if ( verbose )
+    fprintf( stderr, "Processing %s\n", arg );
+
+  for ( line_number=1 ; ; line_number++ ) {
+    bptr = fgets( buffer, BUFFER_SIZE, in );
+    if (!bptr)
+      break;
+
+    /*
+     *  Don't count the carriage return.
+     */
+
+    length = strlen( buffer ) - 1;
+
+    if ( buffer[ length ] != '\n' )
+      error(ERR_ERRNO|ERR_FATAL, "Line %d too long in %s\n", line_number, arg);
+
+    while ( isspace( buffer[ length ] ) )
+      buffer[ length-- ] = '\0';
+
+    if ( test_only ) {
+      fprintf( stderr, "%s\n", arg );
+      break;
+    }
+
+    fprintf( out, "%s\n", buffer );
+  }
+
+  fclose( in );
+  if ( !test_only ) {
+    fclose( out );
+    rename( outname, arg );
+  }
+  return rc;
+}
+
+/*
+ * error(errn, arglist)
+ *      report an error to stderr using printf(3) conventions.
+ *      Any output is preceded by '<progname>: '
+ *
+ * Uses ERR_FATAL bit to request exit(errn)
+ *      ERR_ABORT to request abort()
+ *      ERR_ERRNO to indicate use of errno instead of argument.
+ *
+ * If resulting 'errn' is non-zero, it is assumed to be an 'errno' and its
+ *      associated error message is appended to the output.
+ */
+
+/*VARARGS*/
+
+void
+error(int error_flag, ...)
+{
+    va_list arglist;
+    register char *format;
+    extern char *sys_errlist[];
+    extern int sys_nerr;
+    int local_errno;
+
+    extern int errno;
+
+    (void) fflush(stdout);          /* in case stdout/stderr same */
+
+    local_errno = error_flag & ~ERR_MASK;
+    if (error_flag & ERR_ERRNO)     /* use errno? */
+        local_errno = errno;
+
+    va_start(arglist, error_flag);
+    format = va_arg(arglist, char *);
+    (void) fprintf(stderr, "%s: ", progname);
+    (void) vfprintf(stderr, format, arglist);
+    va_end(arglist);
+
+    if (local_errno)
+        if ((local_errno > 0) && (local_errno < sys_nerr))
+            (void) fprintf(stderr, " (%s)\n", sys_errlist[local_errno]);
+        else
+            (void) fprintf(stderr, " (unknown errno=%d)\n", local_errno);
+    else
+        (void) fprintf(stderr, "\n");
+
+    (void) fflush(stderr);
+
+    if (error_flag & (ERR_FATAL | ERR_ABORT))
+    {
+        if (error_flag & ERR_FATAL)
+        {
+            error(0, local_errno ? "fatal error, exiting" : "exiting");
+            exit(local_errno);
+        }
+        else
+        {
+            error(0, "fatal error, aborting");
+            abort();
+        }
+    }
+}
+
+long
+getparm(char *s,
+        long min,
+        long max,
+        char *msg)
+{
+    long val;
+
+    if ( ! strchr("0123456789-", *s))
+    {
+        error(ERR_FATAL, "'%s' is not a number", s);
+        return min;
+    }
+
+    val = strtol(s, (char **) NULL, 0);
+    if ((val < min) || (val > max))
+    {
+        if (min == max)
+            error(ERR_FATAL, "%s can only be %ld", s, min);
+        else
+            error(ERR_FATAL, "%s must be between %ld and %ld", msg, min, max);
+    }
+
+    return val;
+}
+
+
+/*
+ * Open()
+ *      Perform open(2), returning the file descriptor.  Prints
+ *      error message if open fails.
+ */
+
+int
+Open(char *file,
+     int oflag,
+     int mode)
+{
+    int O_fd;
+
+    if (Failed(O_fd = open(file, oflag, mode)))
+        error(
+          ERR_ERRNO | ERR_FATAL,
+          "open('%s', 0x%x, 0%o) failed", file, oflag, mode
+        );
+
+    return O_fd;
+}
+
+/*
+ * Read()
+ *      Perform read(2); prints error message if fails.
+ */
+
+int
+Read(int file,
+     char *buffer,
+     unsigned int count)
+{
+    int nbytes;
+
+    if (Failed(nbytes = read(file, buffer, count)))
+        error(
+          ERR_ERRNO | ERR_FATAL,
+          "read(%d, 0x%x, %d) failed", file, buffer, count
+        );
+
+    return nbytes;
+}
+
+/*
+ * Write()
+ *      Perform write(2); prints error message if fails.
+ */
+
+int
+Write(int file,
+      char *buffer,
+      unsigned int count)
+{
+    int nbytes;
+
+    if (Failed(nbytes = write(file, buffer, count)))
+        error(
+          ERR_ERRNO | ERR_FATAL,
+          "write(%d, 0x%x, %d) failed", file, buffer, count
+        );
+
+    return nbytes;
+}

c/build-tools/packhex.c

@@ -0,0 +1,513 @@
+
+/*****  P A C K H E X . C  ************************************************
+ *
+ *   Packhex is a hex-file compaction utility.  It attempts to concatenate
+ *   hex records to produce more size-efficient packaging.
+ *
+ *   Limitations: Input files must be correctly formatted.  This utility
+ *                is not robust enough to detect hex-record formatting
+ *                errors.
+ *
+ *   Published:   5/93 Embedded Systems magazine
+ *
+ *   Compiler:    Microsoft C 6.0
+ *                cl /F 1000 packhex.c
+ *
+ *
+ *   $Id$
+ *
+ **************************************************************************/
+
+
+/* #define SMALLER_RECORDS */
+#ifdef SMALLER_RECORDS
+#define MAX_LEN_S1_RECS 128
+#define MAX_LEN_S2_RECS 128
+#define MAX_LEN_S3_RECS 128
+#else
+#define MAX_LEN_S1_RECS 252
+#define MAX_LEN_S2_RECS 251
+#define MAX_LEN_S3_RECS 250
+#endif
+
+
+/*--------------------------------- includes ---------------------------------*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(__unix__) && !defined(EXIT_FAILURE)
+#define EXIT_FAILURE -1
+#define EXIT_SUCCESS  0
+#endif
+
+/*--------------------------------- defines ----------------------------------*/
+
+#define YES                   1
+#define MAX_LINE_SIZE       600
+#define EOS                 '\0'
+
+
+/*---------------------------------- macros ----------------------------------*/
+
+/* Convert ASCII hexadecimal digit to value. */
+
+#define HEX_DIGIT( C )   ( ( ( ( C ) > '9' ) ? ( C ) + 25 : ( C ) ) & 0xF )
+
+
+/*--------------------------------- typedefs ---------------------------------*/
+
+typedef unsigned char   Boolean;
+typedef unsigned char   Uchar;
+typedef unsigned int    Uint;
+typedef unsigned long   Ulong;
+
+typedef struct   /* Functions and constant returning Hex-record vital stats. */
+{
+    Boolean    ( *is_data_record  )( char *              );
+    Ulong      ( *get_address     )( char *              );
+    Uint       ( *get_data_count  )( char *              );
+    const Uint    max_data_count;
+    char      *( *get_data_start  )( char *              );
+    void       ( *put_data_record )( Uint, Ulong, char * );
+} Rec_vitals;
+
+
+/*--------------------------- function prototypes ----------------------------*/
+
+Rec_vitals  * identify_first_data_record( char * );
+Ulong         get_ndigit_hex( char *, int );
+
+
+/*----------------------------- Intel Hex format -----------------------------*/
+
+/*
+ *    Intel Hex data-record layout
+ *
+ *    :aabbbbccd...dee
+ *
+ *    :      - header character
+ *    aa     - record data byte count, a 2-digit hex value
+ *    bbbb   - record address, a 4-digit hex value
+ *    cc     - record type, a 2-digit hex value:
+ *              "00" is a data record
+ *              "01" is an end-of-data record
+ *              "02" is an extended-address record
+ *              "03" is a start record
+ *    d...d  - data (always an even number of chars)
+ *    ee     - record checksum, a 2-digit hex value
+ *             checksum = 2's complement
+ *                 [ (sum of bytes: aabbbbccd...d) modulo 256 ]
+ */
+
+
+Boolean is_intel_data_rec( char * rec_str )
+{
+    return( ( rec_str[ 0 ] == ':' )  &&  ( rec_str[ 8 ] == '0' ) );
+}
+
+Uint get_intel_rec_data_count( char * rec_str )
+{
+    return( ( Uint ) get_ndigit_hex( rec_str + 1, 2 ) );
+}
+
+Ulong get_intel_rec_address( char * rec_str )
+{
+    return( get_ndigit_hex( rec_str + 3, 4 ) );
+}
+
+char * get_intel_rec_data_start( char * rec_str )
+{
+    return( rec_str + 9 );
+}
+
+void put_intel_data_rec( Uint count, Ulong address, char * data_str )
+{
+    char    *ptr;
+    Uint    sum = count + ( address >> 8 & 0xff ) + ( address & 0xff );
+
+    for ( ptr = data_str ; *ptr != EOS ; ptr += 2 )
+        sum += ( Uint ) get_ndigit_hex( ptr, 2 );
+
+    printf(
+      ":%02X%04lX00%s%02X\n", count, address, data_str, (~sum + 1) & 0xff
+    );
+}
+
+
+Rec_vitals  intel_hex =
+{
+    is_intel_data_rec,
+    get_intel_rec_address,
+    get_intel_rec_data_count,
+    255,                        /* Maximum data bytes in a record. */
+    get_intel_rec_data_start,
+    put_intel_data_rec
+};
+
+
+/*------------------------- Motorola S1-record format ------------------------*/
+
+/*
+ *    Motorola S-record data-record layout
+ *
+ *    Sabbc...cd...dee
+ *
+ *    S      - header character
+ *    a      - record type, a 1-digit value:
+ *               "0" is a header record
+ *               "1" is a 2-byte-address data record
+ *               "2" is a 3-byte-address data record
+ *               "3" is a 4-byte-address data record
+ *               "7" is a 4-byte-address end-of-data record
+ *               "8" is a 3-byte-address end-of-data record
+ *               "9" is a 2-byte-address end-of-data record
+ *    bb     - record length in bytes, a 2-digit hex value
+ *             (record length doesn't count the header/type
+ *              chars and checksum byte)
+ *    c...c  - record address, a 4-, 6-, or 8-digit value,
+ *               depending on record type
+ *    d...d  - data (always an even number of chars)
+ *    ee     - record checksum, a 2-digit hex value
+ *             checksum = 1's complement
+ *             [ (sum of all bytes: bbc..cd...d) modulo 256 ]
+ */
+
+#define S1_COUNT_OFFSET         3
+
+
+Boolean is_moto_s1_data_rec( char * rec_str )
+{
+    return ( ( rec_str[ 0 ] == 'S' )  &&  ( rec_str[ 1 ] == '1' ) );
+}
+
+Uint get_moto_s1_rec_data_count( char * rec_str )
+{
+    return( ( Uint ) get_ndigit_hex( rec_str + 2, 2 ) - S1_COUNT_OFFSET );
+}
+
+Ulong get_moto_s1_rec_address( char * rec_str )
+{
+    return( get_ndigit_hex( rec_str + 4, 4 ) );
+}
+
+char * get_moto_s1_rec_data_start( char * rec_str )
+{
+    return( rec_str + 8 );
+}
+
+void put_moto_s1_data_rec( Uint count, Ulong address, char * data_str )
+{
+    char   *ptr;
+    Uint    sum = S1_COUNT_OFFSET + count +
+                    ( address >> 8 & 0xff ) + ( address & 0xff );
+
+    for ( ptr = data_str ; *ptr != EOS ; ptr += 2 )
+        sum += ( Uint ) get_ndigit_hex( ptr, 2 );
+
+    printf(
+      "S1%02X%04lX%s%02X\n",
+      count + S1_COUNT_OFFSET, address, data_str, ~sum & 0xff
+    );
+}
+
+
+Rec_vitals  motorola_s1_rec =
+{
+    is_moto_s1_data_rec,
+    get_moto_s1_rec_address,
+    get_moto_s1_rec_data_count,
+    MAX_LEN_S1_RECS,            /* Maximum data bytes in a record. */
+    get_moto_s1_rec_data_start,
+    put_moto_s1_data_rec
+};
+
+
+/*------------------------- Motorola S2-record format ------------------------*/
+
+#define S2_COUNT_OFFSET         4
+
+Boolean is_moto_s2_data_rec( char * rec_str )
+{
+    return ( ( rec_str[ 0 ] == 'S' )  &&  ( rec_str[ 1 ] == '2' ) );
+}
+
+Uint get_moto_s2_rec_data_count( char * rec_str )
+{
+    return( ( Uint ) get_ndigit_hex( rec_str + 2, 2 ) - S2_COUNT_OFFSET );
+}
+
+Ulong get_moto_s2_rec_address( char * rec_str )
+{
+    return( get_ndigit_hex( rec_str + 4, 6 ) );
+}
+
+char * get_moto_s2_rec_data_start( char * rec_str )
+{
+    return( rec_str + 10 );
+}
+
+void put_moto_s2_data_rec( Uint count, Ulong address, char * data_str )
+{
+    char    *ptr;
+    Uint    sum = S2_COUNT_OFFSET + count + ( address >> 16 & 0xff ) +
+                                            ( address >>  8 & 0xff ) +
+                                            ( address       & 0xff );
+
+    for ( ptr = data_str ; *ptr != EOS ; ptr += 2 )
+        sum += ( Uint ) get_ndigit_hex( ptr, 2 );
+
+    printf(
+      "S2%02X%06lX%s%02X\n",
+      count + S2_COUNT_OFFSET, address, data_str, ~sum & 0xff
+    );
+}
+
+
+Rec_vitals  motorola_s2_rec =
+{
+    is_moto_s2_data_rec,
+    get_moto_s2_rec_address,
+    get_moto_s2_rec_data_count,
+    MAX_LEN_S2_RECS,            /* Maximum data bytes in a record. */
+    get_moto_s2_rec_data_start,
+    put_moto_s2_data_rec
+};
+
+
+/*------------------------- Motorola S3-record format ------------------------*/
+
+#define S3_COUNT_OFFSET         5
+
+Boolean is_moto_s3_data_rec( char * rec_str )
+{
+    return ( ( rec_str[ 0 ] == 'S' )  &&  ( rec_str[ 1 ] == '3' ) );
+}
+
+Uint get_moto_s3_rec_data_count( char * rec_str )
+{
+    return( ( Uint ) get_ndigit_hex( rec_str + 2, 2 ) - S3_COUNT_OFFSET );
+}
+
+Ulong get_moto_s3_rec_address( char * rec_str )
+{
+    return( get_ndigit_hex( rec_str + 4, 8 ) );
+}
+
+char * get_moto_s3_rec_data_start( char * rec_str )
+{
+    return( rec_str + 12 );
+}
+
+void put_moto_s3_data_rec( Uint count, Ulong address, char * data_str )
+{
+    char    *ptr;
+    Uint     sum = S3_COUNT_OFFSET + count + ( address >> 24 & 0xff ) +
+                                             ( address >> 16 & 0xff ) +
+                                             ( address >>  8 & 0xff ) +
+                                             ( address       & 0xff );
+
+    for ( ptr = data_str ; *ptr != EOS ; ptr += 2 )
+        sum += ( Uint ) get_ndigit_hex( ptr, 2 );
+
+    printf(
+      "S3%02X%08lX%s%02X\n",
+      count + S3_COUNT_OFFSET, address, data_str, ~sum & 0xff
+   );
+}
+
+
+Rec_vitals  motorola_s3_rec =
+{
+    is_moto_s3_data_rec,
+    get_moto_s3_rec_address,
+    get_moto_s3_rec_data_count,
+    MAX_LEN_S3_RECS,            /* Maximum data bytes in a record. */
+    get_moto_s3_rec_data_start,
+    put_moto_s3_data_rec
+};
+
+
+/*-------------------- Put your favorite hex format here ---------------------*/
+
+/*
+ *    * * *  The following is a template for an additional hex format:  * * *
+ *
+ *
+ *    Boolean is_X_data_rec( char * rec_str ) {}
+ *
+ *    Uint get_X_rec_data_count( char * rec_str ) {}
+ *
+ *    Ulong get_X_rec_address( char * rec_str ) {}
+ *
+ *    char * get_X_rec_data_start( char * rec_str ) {}
+ *
+ *    void put_X_data_rec( Uint count, Ulong address, char * data_str ) {}
+ *
+ *    Rec_vitals  X_rec =
+ *    {
+ *        is_X_data_rec,
+ *        get_X_rec_address,
+ *        get_X_rec_data_count,
+ *        MAXIMUM DATA BYTES IN A RECORD,
+ *        get_X_rec_data_start,
+ *        put_X_data_rec
+ *    };
+ *
+ */
+
+/*----------------------------------------------------------------------------*/
+
+
+/*
+ *   Put address of additional Rec_vitals structures
+ *   in this array, before the NULL entry.
+ */
+
+Rec_vitals  *formats[] =
+{
+    &intel_hex,
+    &motorola_s1_rec,
+    &motorola_s2_rec,
+    &motorola_s3_rec,
+    ( Rec_vitals * ) NULL
+};
+
+
+/****   main   *****************************************************************
+*
+*
+*       Expects: Nothing (no command-line parameters).
+*
+*       Returns: Exit status (EXIT_SUCCESS or EXIT_FAILURE).
+*
+*       Reads hex records on the standard input and attempts to
+*       splice adjacent data fields together.  Results appear on
+*       the standard output.
+*
+*******************************************************************************/
+
+void main( void )
+{
+
+    char       inbuff[ MAX_LINE_SIZE ], outbuff[ MAX_LINE_SIZE ];
+    char       *in_dptr, *out_dptr;
+    int        d_total, d_count, d_excess, n;
+    Ulong      in_rec_addr, out_rec_addr = 0;
+    Rec_vitals *rptr;
+
+
+    /* Sift through file until first hex record is identified.    */
+    if ( ( rptr = identify_first_data_record( inbuff ) ) == NULL )
+    {
+        fputs( "No hex records found.\n", stderr );
+        exit( EXIT_FAILURE );
+    }
+
+
+    /* Attempt data-record splicing until end-of-file is reached. */
+    d_total = 0;
+    do
+    {
+        if ( rptr->is_data_record( inbuff ) == YES )
+        { /* Input record is a data record. */
+            d_count     = rptr->get_data_count( inbuff );
+            in_rec_addr = rptr->get_address( inbuff );
+            in_dptr     = rptr->get_data_start( inbuff );
+
+            if ( d_total == 0  ||  in_rec_addr != out_rec_addr + d_total )
+            { /* Begin a new output record. */
+                if ( d_total != 0 )
+                    rptr->put_data_record( d_total, out_rec_addr, outbuff );
+                out_dptr     = outbuff;
+                n = d_total  = d_count;
+                out_rec_addr = in_rec_addr;
+            }
+            else if
+              ( ( d_excess = d_total + d_count - rptr->max_data_count ) > 0 )
+            { /* Output a maximum-length record, then start a new record. */
+                strncat( outbuff, in_dptr, 2 * ( d_count - d_excess ) );
+                rptr->put_data_record(
+                  rptr->max_data_count, out_rec_addr, outbuff
+                );
+                in_dptr      += 2 * ( d_count - d_excess );
+                out_dptr      = outbuff;
+                n = d_total   = d_excess;
+                out_rec_addr += rptr->max_data_count;
+            }
+            else
+            { /* Append input record's data field with accumulated data. */
+                out_dptr = outbuff + ( 2 * d_total );
+                d_total += n = d_count;
+            }
+            strncpy( out_dptr, in_dptr, 2 * n );
+            out_dptr[ 2 * n ] = EOS;
+        }
+        else
+        { /* Not a data record;
+           * flush accumulated data then echo non-data record.
+           */
+            if ( d_total != 0 )
+            {
+                rptr->put_data_record( d_total, out_rec_addr, outbuff );
+                d_total = 0;
+            }
+            puts( inbuff );
+        }
+    } while ( gets( inbuff ) != NULL );
+
+
+    exit( EXIT_SUCCESS );
+
+}
+
+
+/****   identify_first_data_record   *******************************************
+*
+*       Expects: Pointer to hex-record line buffer.
+*
+*       Returns: Pointer to hex-record structure (NULL if no match found).
+*
+*       Reads the standard input, line by line, searching for a valid
+*       record header character.  If a valid header is found, a pointer
+*       to the hex-record's type structure is returned, otherwise NULL.
+*
+*       The input-stream pointer is left pointing to the first valid hex record.
+*
+*******************************************************************************/
+
+Rec_vitals * identify_first_data_record( char * buff_ptr )
+{
+    Rec_vitals  ** ptr;
+
+    while ( gets( buff_ptr ) != NULL )
+    {
+        for ( ptr = formats ; *ptr != ( Rec_vitals * ) NULL ; ptr++ )
+            if ( ( *ptr )->is_data_record( buff_ptr ) == YES )
+                return( *ptr );        /* Successful return.        */
+
+        puts( buff_ptr );              /* Echo non-hex-record line. */
+    }
+
+    return( ( Rec_vitals * ) NULL );   /* Unsuccessful return.      */
+}
+
+
+/****   get_ndigit_hex   *******************************************************
+*
+*       Expects: Pointer to first ASCII hexadecimal digit, number of digits.
+*
+*       Returns: Value of hexadecimal string as an unsigned long.
+*
+*******************************************************************************/
+
+Ulong get_ndigit_hex( char * cptr, int digits )
+{
+    Ulong    value;
+
+    for ( value = 0 ; --digits >= 0 ; cptr++ )
+        value = ( value * 16L ) + HEX_DIGIT( *cptr );
+
+    return( value );
+}

c/build-tools/scripts/README

@@ -0,0 +1,32 @@
+#
+#  $Id$
+#
+
+Misc. support tools for RTEMS workspaces.
+More will be added later as they are converted from Teamware
+to CVS.
+
+install-if-change
+    Smart install script that also can append suffixes as it
+    installs (suffixes used for debug and profile variants).
+    Requires bash or ksh.
+
+rcs-clean
+    deletes all files from the current directory that can be
+    re-created from RCS.  Careful to not delete locked files.
+    May be used by 'gmake clobber'
+
+lock-directory
+unlock-directory
+    traverse a directory structure making it unwritable.
+    Useful to keep people from accidentally overwriting
+    "released" trees if they get confused about which
+    module they have loaded.
+
+rtems-glom
+    glom together all the rtems libraries in order to simplify
+    the link line used by applications.
+    Produces rtems.rel.
+    Not used by the RTEMS src tree at all.
+    Strictly optional.
+

c/build-tools/src/cklength.c

@@ -0,0 +1,364 @@
+/*
+ *  cklength - check the length of lines in a file
+ *
+ *  This program check to see if the files passed to it on the command line
+ *  contain a line which exceeds the maximum allowable length.  The default
+ *  maximum line length is 80.
+ *
+ *  usage:  cklength  [ -v ] [ arg ... ] files...
+ *           -l length   -- maximum line length
+ *           -v          -- verbose
+ *
+ * $Id$
+ * $Log$
+ */
+
+#define GETOPTARGS "l:nNv"
+
+char *USAGE = "\
+usage:  cklength  [ -v ] [ arg ... ] files... \n\
+            -l length   -- maximum line length\n\
+            -n          -- report line numbers for offending lines\n\
+            -N          -- report line numbers and length for offending lines\n\
+            -v          -- verbose\n\
+\n\
+Print the name of files which have at least 1 line which exceeds the\n\
+maximum line length.  The default maximum line length is 80.\n\
+";
+
+#include <stdio.h>
+#include <fcntl.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <memory.h>
+#include <stdarg.h>
+
+#define BUFFER_SIZE     512
+
+#define SUCCESS         0
+#define FAILURE         -1
+#define Failed(x)       (((int) (x)) == FAILURE)
+#define TRUE    1
+#define FALSE   0
+#define STREQ(a,b)      (strcmp(a,b) == 0)
+#define NUMELEMS(arr)   (sizeof(arr) / sizeof(arr[0]))
+
+/*
+ * Definitions for unsigned "ints"; especially for use in data structures
+ *  that will be shared among (potentially) different cpu's (we punt on
+ *  byte ordering problems tho)
+ */
+
+typedef unsigned char   u8;
+typedef unsigned short  u16;
+typedef unsigned long   u32;
+
+/*
+ * vars controlled by command line options
+ */
+
+int verbose = FALSE;                    /* be verbose */
+int report_line_numbers = FALSE;        /* report line numbers of offenders */
+int report_line_length = FALSE;         /* report line length of offenders */
+
+int line_length = 80;                   /* maximum allowable line length */
+
+extern char *optarg;                    /* getopt(3) control vars */
+extern int optind, opterr;
+extern int errno;
+
+char *progname;                         /* for error() */
+
+int process(char *arg);
+void error(int errn, ...);
+long getparm(char *s, long min, long max, char *msg);
+
+#define ERR_ERRNO  (1<<((sizeof(int) * 8) - 2)) /* hi bit; use 'errno' */
+#define ERR_FATAL  (ERR_ERRNO / 2)              /* fatal error ; no return */
+#define ERR_ABORT  (ERR_ERRNO / 4)              /* fatal error ; abort */
+#define ERR_MASK   (ERR_ERRNO | ERR_FATAL | ERR_ABORT) /* all */
+
+#define stol(p) strtol(p, (char **) NULL, 0)
+int  Open(), Read(), Write();
+
+int
+main(int argc, char **argv, char **env)
+{
+    register int c;
+    int showusage = FALSE;                      /* usage error? */
+    int rc = 0;
+
+    /*
+     * figure out invocation leaf-name
+     */
+
+    if ((progname = strrchr(argv[0], '/')) == (char *) NULL)
+        progname = argv[0];
+    else
+        progname++;
+
+    argv[0] = progname;                         /* for getopt err reporting */
+
+    /*
+     *  Check options and arguments.
+     */
+
+    opterr = 0;                                 /* we'll report all errors */
+    while ((c = getopt(argc, argv, GETOPTARGS)) != EOF)
+        switch (c)
+        {
+            case 'l':                            /* line length */
+                line_length = atoi( optarg );
+                if ( line_length < 0 || line_length > BUFFER_SIZE )
+                  error(ERR_FATAL, "(%d) is illegal line length\n",line_length);
+                break;
+
+            case 'n':                           /* toggle report_line_numbers */
+                report_line_numbers = ! report_line_numbers;
+                break;
+
+            case 'N':                           /* toggle both reports */
+                report_line_numbers = ! report_line_numbers;
+                report_line_length  = ! report_line_length;
+                break;
+
+            case 'v':                           /* toggle verbose */
+                verbose = ! verbose;
+                break;
+
+            case '?':
+                showusage = TRUE;
+        }
+
+    if (showusage)
+    {
+        (void) fprintf(stderr, "%s", USAGE);
+        exit(1);
+    }
+
+    /*
+     *  traverse and process the arguments
+     */
+
+    for ( ; argv[optind]; optind++)
+        if (Failed(process(argv[optind])))
+            rc = FAILURE;
+
+    return rc;
+}
+
+
+/*
+ * process(arg)
+ */
+
+int
+process(char *arg)
+{
+  FILE   *in;
+  char   *bptr;
+  char    buffer[ BUFFER_SIZE ];
+  int     line_number;
+  int     length;
+  int     count;
+  int     rc = SUCCESS;  /* succeed by default */
+
+  in = fopen( arg, "r" );
+  if (!in)
+    error( ERR_ERRNO | ERR_FATAL, "Unable to open file (%s)\n", arg );
+
+  count = 0;
+
+  for ( line_number=1 ; ; line_number++ ) {
+    bptr = fgets( buffer, BUFFER_SIZE, in );
+    if (!bptr)
+      break;
+
+    /*
+     *  Don't count the carriage return.
+     */
+
+    length = strlen( buffer ) - 1;
+
+    if ( length <= line_length )
+      continue;
+
+    if ( count == 0 ) {
+      fprintf( stderr, "%s\n", arg );
+      if ( !report_line_numbers )
+        break;
+    }
+
+    if ( verbose )
+      fprintf( stderr, "TOO LONG:%d: %s\n", line_number, buffer );
+
+    if ( report_line_numbers ) {
+      if ( report_line_length )
+        fprintf( stderr, "%d: %d\n" , line_number, length );
+      else
+        fprintf( stderr, "%d\n" , line_number );
+    }
+
+    count++;
+
+  }
+
+  fclose( in );
+  return rc;
+}
+
+/*
+ * error(errn, arglist)
+ *      report an error to stderr using printf(3) conventions.
+ *      Any output is preceded by '<progname>: '
+ *
+ * Uses ERR_FATAL bit to request exit(errn)
+ *      ERR_ABORT to request abort()
+ *      ERR_ERRNO to indicate use of errno instead of argument.
+ *
+ * If resulting 'errn' is non-zero, it is assumed to be an 'errno' and its
+ *      associated error message is appended to the output.
+ */
+
+/*VARARGS*/
+
+void
+error(int error_flag, ...)
+{
+    va_list arglist;
+    register char *format;
+    extern char *sys_errlist[];
+    extern int sys_nerr;
+    int local_errno;
+
+    extern int errno;
+
+    (void) fflush(stdout);          /* in case stdout/stderr same */
+
+    local_errno = error_flag & ~ERR_MASK;
+    if (error_flag & ERR_ERRNO)     /* use errno? */
+        local_errno = errno;
+
+    va_start(arglist, error_flag);
+    format = va_arg(arglist, char *);
+    (void) fprintf(stderr, "%s: ", progname);
+    (void) vfprintf(stderr, format, arglist);
+    va_end(arglist);
+
+    if (local_errno)
+        if ((local_errno > 0) && (local_errno < sys_nerr))
+            (void) fprintf(stderr, " (%s)\n", sys_errlist[local_errno]);
+        else
+            (void) fprintf(stderr, " (unknown errno=%d)\n", local_errno);
+    else
+        (void) fprintf(stderr, "\n");
+
+    (void) fflush(stderr);
+
+    if (error_flag & (ERR_FATAL | ERR_ABORT))
+    {
+        if (error_flag & ERR_FATAL)
+        {
+            error(0, local_errno ? "fatal error, exiting" : "exiting");
+            exit(local_errno);
+        }
+        else
+        {
+            error(0, "fatal error, aborting");
+            abort();
+        }
+    }
+}
+
+long
+getparm(char *s,
+        long min,
+        long max,
+        char *msg)
+{
+    long val;
+
+    if ( ! strchr("0123456789-", *s))
+    {
+        error(ERR_FATAL, "'%s' is not a number", s);
+        return min;
+    }
+
+    val = strtol(s, (char **) NULL, 0);
+    if ((val < min) || (val > max))
+    {
+        if (min == max)
+            error(ERR_FATAL, "%s can only be %ld", s, min);
+        else
+            error(ERR_FATAL, "%s must be between %ld and %ld", msg, min, max);
+    }
+
+    return val;
+}
+
+
+/*
+ * Open()
+ *      Perform open(2), returning the file descriptor.  Prints
+ *      error message if open fails.
+ */
+
+int
+Open(char *file,
+     int oflag,
+     int mode)
+{
+    int O_fd;
+
+    if (Failed(O_fd = open(file, oflag, mode)))
+        error(
+          ERR_ERRNO | ERR_FATAL,
+          "open('%s', 0x%x, 0%o) failed", file, oflag, mode
+        );
+
+    return O_fd;
+}
+
+/*
+ * Read()
+ *      Perform read(2); prints error message if fails.
+ */
+
+int
+Read(int file,
+     char *buffer,
+     unsigned int count)
+{
+    int nbytes;
+
+    if (Failed(nbytes = read(file, buffer, count)))
+        error(
+          ERR_ERRNO | ERR_FATAL,
+          "read(%d, 0x%x, %d) failed", file, buffer, count
+         );
+
+    return nbytes;
+}
+
+/*
+ * Write()
+ *      Perform write(2); prints error message if fails.
+ */
+
+int
+Write(int file,
+      char *buffer,
+      unsigned int count)
+{
+    int nbytes;
+
+    if (Failed(nbytes = write(file, buffer, count)))
+        error(
+          ERR_ERRNO | ERR_FATAL,
+          "write(%d, 0x%x, %d) failed", file, buffer, count
+        );
+
+    return nbytes;
+}

c/build-tools/src/eolstrip.c

@@ -0,0 +1,351 @@
+/*
+ *  eolstrip - strip white space from end of lines
+ *
+ *  This program strips the white space from the end of every line in the
+ *  specified program.
+ *
+ *  usage:  eolstrip  [ -v ] [ arg ... ] files...
+ *           -v          -- verbose
+ *
+ * $Id$
+ * $Log$
+ */
+
+#define GETOPTARGS "vt"
+
+char *USAGE = "\
+usage:  cklength  [ -v ] [ arg ... ] files... \n\
+            -v          -- verbose\n\
+            -t          -- test only .. DO NOT OVERWRITE FILE!!!\n\
+\n\
+Strip the white space from the end of every line on the list of files.\n\
+";
+
+#include <stdio.h>
+#include <fcntl.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <memory.h>
+#include <stdarg.h>
+
+#define BUFFER_SIZE     2048
+#define MAX_PATH        2048
+
+#define SUCCESS         0
+#define FAILURE         -1
+#define Failed(x)       (((int) (x)) == FAILURE)
+#define TRUE    1
+#define FALSE   0
+#define STREQ(a,b)      (strcmp(a,b) == 0)
+#define NUMELEMS(arr)   (sizeof(arr) / sizeof(arr[0]))
+
+/*
+ * Definitions for unsigned "ints"; especially for use in data structures
+ *  that will be shared among (potentially) different cpu's (we punt on
+ *  byte ordering problems tho)
+ */
+
+typedef unsigned char   u8;
+typedef unsigned short  u16;
+typedef unsigned long   u32;
+
+/*
+ * vars controlled by command line options
+ */
+
+int verbose = FALSE;                    /* be verbose */
+int test_only = FALSE;                  /* test only */
+
+extern char *optarg;                    /* getopt(3) control vars */
+extern int optind, opterr;
+extern int errno;
+
+char *progname;                         /* for error() */
+
+int process(char *arg);
+void error(int errn, ...);
+long getparm(char *s, long min, long max, char *msg);
+
+#define ERR_ERRNO  (1<<((sizeof(int) * 8) - 2)) /* hi bit; use 'errno' */
+#define ERR_FATAL  (ERR_ERRNO / 2)              /* fatal error ; no return */
+#define ERR_ABORT  (ERR_ERRNO / 4)              /* fatal error ; abort */
+#define ERR_MASK   (ERR_ERRNO | ERR_FATAL | ERR_ABORT) /* all */
+
+#define stol(p) strtol(p, (char **) NULL, 0)
+int  Open(), Read(), Write();
+
+int
+main(int argc, char **argv, char **env)
+{
+    register int c;
+    int showusage = FALSE;                      /* usage error? */
+    int rc = 0;
+
+    /*
+     * figure out invocation leaf-name
+     */
+
+    if ((progname = strrchr(argv[0], '/')) == (char *) NULL)
+        progname = argv[0];
+    else
+        progname++;
+
+    argv[0] = progname;                         /* for getopt err reporting */
+
+    /*
+     *  Check options and arguments.
+     */
+
+    opterr = 0;                                 /* we'll report all errors */
+    while ((c = getopt(argc, argv, GETOPTARGS)) != EOF)
+        switch (c)
+        {
+            case 't':                           /* toggle test only mode */
+                test_only = ! test_only;
+                break;
+
+            case 'v':                           /* toggle verbose */
+                verbose = ! verbose;
+                break;
+
+            case '?':
+                showusage = TRUE;
+        }
+
+    if (showusage)
+    {
+        (void) fprintf(stderr, "%s", USAGE);
+        exit(1);
+    }
+
+    /*
+     *  traverse and process the arguments
+     */
+
+    for ( ; argv[optind]; optind++)
+        if (Failed(process(argv[optind])))
+            rc = FAILURE;
+
+    return rc;
+}
+
+
+/*
+ * process(arg)
+ */
+
+int
+process(char *arg)
+{
+  FILE   *in;
+  FILE   *out = (FILE *) 0;
+  char    outname[ MAX_PATH ];
+  char   *bptr;
+  char    buffer[ BUFFER_SIZE ];
+  int     length;
+  int     line_number;
+  int     rc = SUCCESS;  /* succeed by default */
+
+  in = fopen( arg, "r" );
+  if (!in)
+    error( ERR_ERRNO | ERR_FATAL, "Unable to open file (%s)\n", arg );
+
+  if ( !test_only ) {
+    sprintf( outname, "%s.eoltmp", arg );
+
+    out = fopen( outname, "w" );
+    if (!out)
+      error( ERR_ERRNO | ERR_FATAL, "Unable to open file (%s)\n", arg );
+  }
+
+  if ( verbose )
+    fprintf( stderr, "Processing %s\n", arg );
+
+  for ( line_number=1 ; ; line_number++ ) {
+    bptr = fgets( buffer, BUFFER_SIZE, in );
+    if (!bptr)
+      break;
+
+    /*
+     *  Don't count the carriage return.
+     */
+
+    length = strlen( buffer ) - 1;
+
+    if ( buffer[ length ] != '\n' )
+      error(ERR_ERRNO|ERR_FATAL, "Line %d too long in %s\n", line_number, arg);
+
+    while ( isspace( buffer[ length ] ) )
+      buffer[ length-- ] = '\0';
+
+    if ( test_only ) {
+      fprintf( stderr, "%s\n", arg );
+      break;
+    }
+
+    fprintf( out, "%s\n", buffer );
+  }
+
+  fclose( in );
+  if ( !test_only ) {
+    fclose( out );
+    rename( outname, arg );
+  }
+  return rc;
+}
+
+/*
+ * error(errn, arglist)
+ *      report an error to stderr using printf(3) conventions.
+ *      Any output is preceded by '<progname>: '
+ *
+ * Uses ERR_FATAL bit to request exit(errn)
+ *      ERR_ABORT to request abort()
+ *      ERR_ERRNO to indicate use of errno instead of argument.
+ *
+ * If resulting 'errn' is non-zero, it is assumed to be an 'errno' and its
+ *      associated error message is appended to the output.
+ */
+
+/*VARARGS*/
+
+void
+error(int error_flag, ...)
+{
+    va_list arglist;
+    register char *format;
+    extern char *sys_errlist[];
+    extern int sys_nerr;
+    int local_errno;
+
+    extern int errno;
+
+    (void) fflush(stdout);          /* in case stdout/stderr same */
+
+    local_errno = error_flag & ~ERR_MASK;
+    if (error_flag & ERR_ERRNO)     /* use errno? */
+        local_errno = errno;
+
+    va_start(arglist, error_flag);
+    format = va_arg(arglist, char *);
+    (void) fprintf(stderr, "%s: ", progname);
+    (void) vfprintf(stderr, format, arglist);
+    va_end(arglist);
+
+    if (local_errno)
+        if ((local_errno > 0) && (local_errno < sys_nerr))
+            (void) fprintf(stderr, " (%s)\n", sys_errlist[local_errno]);
+        else
+            (void) fprintf(stderr, " (unknown errno=%d)\n", local_errno);
+    else
+        (void) fprintf(stderr, "\n");
+
+    (void) fflush(stderr);
+
+    if (error_flag & (ERR_FATAL | ERR_ABORT))
+    {
+        if (error_flag & ERR_FATAL)
+        {
+            error(0, local_errno ? "fatal error, exiting" : "exiting");
+            exit(local_errno);
+        }
+        else
+        {
+            error(0, "fatal error, aborting");
+            abort();
+        }
+    }
+}
+
+long
+getparm(char *s,
+        long min,
+        long max,
+        char *msg)
+{
+    long val;
+
+    if ( ! strchr("0123456789-", *s))
+    {
+        error(ERR_FATAL, "'%s' is not a number", s);
+        return min;
+    }
+
+    val = strtol(s, (char **) NULL, 0);
+    if ((val < min) || (val > max))
+    {
+        if (min == max)
+            error(ERR_FATAL, "%s can only be %ld", s, min);
+        else
+            error(ERR_FATAL, "%s must be between %ld and %ld", msg, min, max);
+    }
+
+    return val;
+}
+
+
+/*
+ * Open()
+ *      Perform open(2), returning the file descriptor.  Prints
+ *      error message if open fails.
+ */
+
+int
+Open(char *file,
+     int oflag,
+     int mode)
+{
+    int O_fd;
+
+    if (Failed(O_fd = open(file, oflag, mode)))
+        error(
+          ERR_ERRNO | ERR_FATAL,
+          "open('%s', 0x%x, 0%o) failed", file, oflag, mode
+        );
+
+    return O_fd;
+}
+
+/*
+ * Read()
+ *      Perform read(2); prints error message if fails.
+ */
+
+int
+Read(int file,
+     char *buffer,
+     unsigned int count)
+{
+    int nbytes;
+
+    if (Failed(nbytes = read(file, buffer, count)))
+        error(
+          ERR_ERRNO | ERR_FATAL,
+          "read(%d, 0x%x, %d) failed", file, buffer, count
+        );
+
+    return nbytes;
+}
+
+/*
+ * Write()
+ *      Perform write(2); prints error message if fails.
+ */
+
+int
+Write(int file,
+      char *buffer,
+      unsigned int count)
+{
+    int nbytes;
+
+    if (Failed(nbytes = write(file, buffer, count)))
+        error(
+          ERR_ERRNO | ERR_FATAL,
+          "write(%d, 0x%x, %d) failed", file, buffer, count
+        );
+
+    return nbytes;
+}

c/build-tools/src/packhex.c

@@ -0,0 +1,513 @@
+
+/*****  P A C K H E X . C  ************************************************
+ *
+ *   Packhex is a hex-file compaction utility.  It attempts to concatenate
+ *   hex records to produce more size-efficient packaging.
+ *
+ *   Limitations: Input files must be correctly formatted.  This utility
+ *                is not robust enough to detect hex-record formatting
+ *                errors.
+ *
+ *   Published:   5/93 Embedded Systems magazine
+ *
+ *   Compiler:    Microsoft C 6.0
+ *                cl /F 1000 packhex.c
+ *
+ *
+ *   $Id$
+ *
+ **************************************************************************/
+
+
+/* #define SMALLER_RECORDS */
+#ifdef SMALLER_RECORDS
+#define MAX_LEN_S1_RECS 128
+#define MAX_LEN_S2_RECS 128
+#define MAX_LEN_S3_RECS 128
+#else
+#define MAX_LEN_S1_RECS 252
+#define MAX_LEN_S2_RECS 251
+#define MAX_LEN_S3_RECS 250
+#endif
+
+
+/*--------------------------------- includes ---------------------------------*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(__unix__) && !defined(EXIT_FAILURE)
+#define EXIT_FAILURE -1
+#define EXIT_SUCCESS  0
+#endif
+
+/*--------------------------------- defines ----------------------------------*/
+
+#define YES                   1
+#define MAX_LINE_SIZE       600
+#define EOS                 '\0'
+
+
+/*---------------------------------- macros ----------------------------------*/
+
+/* Convert ASCII hexadecimal digit to value. */
+
+#define HEX_DIGIT( C )   ( ( ( ( C ) > '9' ) ? ( C ) + 25 : ( C ) ) & 0xF )
+
+
+/*--------------------------------- typedefs ---------------------------------*/
+
+typedef unsigned char   Boolean;
+typedef unsigned char   Uchar;
+typedef unsigned int    Uint;
+typedef unsigned long   Ulong;
+
+typedef struct   /* Functions and constant returning Hex-record vital stats. */
+{
+    Boolean    ( *is_data_record  )( char *              );
+    Ulong      ( *get_address     )( char *              );
+    Uint       ( *get_data_count  )( char *              );
+    const Uint    max_data_count;
+    char      *( *get_data_start  )( char *              );
+    void       ( *put_data_record )( Uint, Ulong, char * );
+} Rec_vitals;
+
+
+/*--------------------------- function prototypes ----------------------------*/
+
+Rec_vitals  * identify_first_data_record( char * );
+Ulong         get_ndigit_hex( char *, int );
+
+
+/*----------------------------- Intel Hex format -----------------------------*/
+
+/*
+ *    Intel Hex data-record layout
+ *
+ *    :aabbbbccd...dee
+ *
+ *    :      - header character
+ *    aa     - record data byte count, a 2-digit hex value
+ *    bbbb   - record address, a 4-digit hex value
+ *    cc     - record type, a 2-digit hex value:
+ *              "00" is a data record
+ *              "01" is an end-of-data record
+ *              "02" is an extended-address record
+ *              "03" is a start record
+ *    d...d  - data (always an even number of chars)
+ *    ee     - record checksum, a 2-digit hex value
+ *             checksum = 2's complement
+ *                 [ (sum of bytes: aabbbbccd...d) modulo 256 ]
+ */
+
+
+Boolean is_intel_data_rec( char * rec_str )
+{
+    return( ( rec_str[ 0 ] == ':' )  &&  ( rec_str[ 8 ] == '0' ) );
+}
+
+Uint get_intel_rec_data_count( char * rec_str )
+{
+    return( ( Uint ) get_ndigit_hex( rec_str + 1, 2 ) );
+}
+
+Ulong get_intel_rec_address( char * rec_str )
+{
+    return( get_ndigit_hex( rec_str + 3, 4 ) );
+}
+
+char * get_intel_rec_data_start( char * rec_str )
+{
+    return( rec_str + 9 );
+}
+
+void put_intel_data_rec( Uint count, Ulong address, char * data_str )
+{
+    char    *ptr;
+    Uint    sum = count + ( address >> 8 & 0xff ) + ( address & 0xff );
+
+    for ( ptr = data_str ; *ptr != EOS ; ptr += 2 )
+        sum += ( Uint ) get_ndigit_hex( ptr, 2 );
+
+    printf(
+      ":%02X%04lX00%s%02X\n", count, address, data_str, (~sum + 1) & 0xff
+    );
+}
+
+
+Rec_vitals  intel_hex =
+{
+    is_intel_data_rec,
+    get_intel_rec_address,
+    get_intel_rec_data_count,
+    255,                        /* Maximum data bytes in a record. */
+    get_intel_rec_data_start,
+    put_intel_data_rec
+};
+
+
+/*------------------------- Motorola S1-record format ------------------------*/
+
+/*
+ *    Motorola S-record data-record layout
+ *
+ *    Sabbc...cd...dee
+ *
+ *    S      - header character
+ *    a      - record type, a 1-digit value:
+ *               "0" is a header record
+ *               "1" is a 2-byte-address data record
+ *               "2" is a 3-byte-address data record
+ *               "3" is a 4-byte-address data record
+ *               "7" is a 4-byte-address end-of-data record
+ *               "8" is a 3-byte-address end-of-data record
+ *               "9" is a 2-byte-address end-of-data record
+ *    bb     - record length in bytes, a 2-digit hex value
+ *             (record length doesn't count the header/type
+ *              chars and checksum byte)
+ *    c...c  - record address, a 4-, 6-, or 8-digit value,
+ *               depending on record type
+ *    d...d  - data (always an even number of chars)
+ *    ee     - record checksum, a 2-digit hex value
+ *             checksum = 1's complement
+ *             [ (sum of all bytes: bbc..cd...d) modulo 256 ]
+ */
+
+#define S1_COUNT_OFFSET         3
+
+
+Boolean is_moto_s1_data_rec( char * rec_str )
+{
+    return ( ( rec_str[ 0 ] == 'S' )  &&  ( rec_str[ 1 ] == '1' ) );
+}
+
+Uint get_moto_s1_rec_data_count( char * rec_str )
+{
+    return( ( Uint ) get_ndigit_hex( rec_str + 2, 2 ) - S1_COUNT_OFFSET );
+}
+
+Ulong get_moto_s1_rec_address( char * rec_str )
+{
+    return( get_ndigit_hex( rec_str + 4, 4 ) );
+}
+
+char * get_moto_s1_rec_data_start( char * rec_str )
+{
+    return( rec_str + 8 );
+}
+
+void put_moto_s1_data_rec( Uint count, Ulong address, char * data_str )
+{
+    char   *ptr;
+    Uint    sum = S1_COUNT_OFFSET + count +
+                    ( address >> 8 & 0xff ) + ( address & 0xff );
+
+    for ( ptr = data_str ; *ptr != EOS ; ptr += 2 )
+        sum += ( Uint ) get_ndigit_hex( ptr, 2 );
+
+    printf(
+      "S1%02X%04lX%s%02X\n",
+      count + S1_COUNT_OFFSET, address, data_str, ~sum & 0xff
+    );
+}
+
+
+Rec_vitals  motorola_s1_rec =
+{
+    is_moto_s1_data_rec,
+    get_moto_s1_rec_address,
+    get_moto_s1_rec_data_count,
+    MAX_LEN_S1_RECS,            /* Maximum data bytes in a record. */
+    get_moto_s1_rec_data_start,
+    put_moto_s1_data_rec
+};
+
+
+/*------------------------- Motorola S2-record format ------------------------*/
+
+#define S2_COUNT_OFFSET         4
+
+Boolean is_moto_s2_data_rec( char * rec_str )
+{
+    return ( ( rec_str[ 0 ] == 'S' )  &&  ( rec_str[ 1 ] == '2' ) );
+}
+
+Uint get_moto_s2_rec_data_count( char * rec_str )
+{
+    return( ( Uint ) get_ndigit_hex( rec_str + 2, 2 ) - S2_COUNT_OFFSET );
+}
+
+Ulong get_moto_s2_rec_address( char * rec_str )
+{
+    return( get_ndigit_hex( rec_str + 4, 6 ) );
+}
+
+char * get_moto_s2_rec_data_start( char * rec_str )
+{
+    return( rec_str + 10 );
+}
+
+void put_moto_s2_data_rec( Uint count, Ulong address, char * data_str )
+{
+    char    *ptr;
+    Uint    sum = S2_COUNT_OFFSET + count + ( address >> 16 & 0xff ) +
+                                            ( address >>  8 & 0xff ) +
+                                            ( address       & 0xff );
+
+    for ( ptr = data_str ; *ptr != EOS ; ptr += 2 )
+        sum += ( Uint ) get_ndigit_hex( ptr, 2 );
+
+    printf(
+      "S2%02X%06lX%s%02X\n",
+      count + S2_COUNT_OFFSET, address, data_str, ~sum & 0xff
+    );
+}
+
+
+Rec_vitals  motorola_s2_rec =
+{
+    is_moto_s2_data_rec,
+    get_moto_s2_rec_address,
+    get_moto_s2_rec_data_count,
+    MAX_LEN_S2_RECS,            /* Maximum data bytes in a record. */
+    get_moto_s2_rec_data_start,
+    put_moto_s2_data_rec
+};
+
+
+/*------------------------- Motorola S3-record format ------------------------*/
+
+#define S3_COUNT_OFFSET         5
+
+Boolean is_moto_s3_data_rec( char * rec_str )
+{
+    return ( ( rec_str[ 0 ] == 'S' )  &&  ( rec_str[ 1 ] == '3' ) );
+}
+
+Uint get_moto_s3_rec_data_count( char * rec_str )
+{
+    return( ( Uint ) get_ndigit_hex( rec_str + 2, 2 ) - S3_COUNT_OFFSET );
+}
+
+Ulong get_moto_s3_rec_address( char * rec_str )
+{
+    return( get_ndigit_hex( rec_str + 4, 8 ) );
+}
+
+char * get_moto_s3_rec_data_start( char * rec_str )
+{
+    return( rec_str + 12 );
+}
+
+void put_moto_s3_data_rec( Uint count, Ulong address, char * data_str )
+{
+    char    *ptr;
+    Uint     sum = S3_COUNT_OFFSET + count + ( address >> 24 & 0xff ) +
+                                             ( address >> 16 & 0xff ) +
+                                             ( address >>  8 & 0xff ) +
+                                             ( address       & 0xff );
+
+    for ( ptr = data_str ; *ptr != EOS ; ptr += 2 )
+        sum += ( Uint ) get_ndigit_hex( ptr, 2 );
+
+    printf(
+      "S3%02X%08lX%s%02X\n",
+      count + S3_COUNT_OFFSET, address, data_str, ~sum & 0xff
+   );
+}
+
+
+Rec_vitals  motorola_s3_rec =
+{
+    is_moto_s3_data_rec,
+    get_moto_s3_rec_address,
+    get_moto_s3_rec_data_count,
+    MAX_LEN_S3_RECS,            /* Maximum data bytes in a record. */
+    get_moto_s3_rec_data_start,
+    put_moto_s3_data_rec
+};
+
+
+/*-------------------- Put your favorite hex format here ---------------------*/
+
+/*
+ *    * * *  The following is a template for an additional hex format:  * * *
+ *
+ *
+ *    Boolean is_X_data_rec( char * rec_str ) {}
+ *
+ *    Uint get_X_rec_data_count( char * rec_str ) {}
+ *
+ *    Ulong get_X_rec_address( char * rec_str ) {}
+ *
+ *    char * get_X_rec_data_start( char * rec_str ) {}
+ *
+ *    void put_X_data_rec( Uint count, Ulong address, char * data_str ) {}
+ *
+ *    Rec_vitals  X_rec =
+ *    {
+ *        is_X_data_rec,
+ *        get_X_rec_address,
+ *        get_X_rec_data_count,
+ *        MAXIMUM DATA BYTES IN A RECORD,
+ *        get_X_rec_data_start,
+ *        put_X_data_rec
+ *    };
+ *
+ */
+
+/*----------------------------------------------------------------------------*/
+
+
+/*
+ *   Put address of additional Rec_vitals structures
+ *   in this array, before the NULL entry.
+ */
+
+Rec_vitals  *formats[] =
+{
+    &intel_hex,
+    &motorola_s1_rec,
+    &motorola_s2_rec,
+    &motorola_s3_rec,
+    ( Rec_vitals * ) NULL
+};
+
+
+/****   main   *****************************************************************
+*
+*
+*       Expects: Nothing (no command-line parameters).
+*
+*       Returns: Exit status (EXIT_SUCCESS or EXIT_FAILURE).
+*
+*       Reads hex records on the standard input and attempts to
+*       splice adjacent data fields together.  Results appear on
+*       the standard output.
+*
+*******************************************************************************/
+
+void main( void )
+{
+
+    char       inbuff[ MAX_LINE_SIZE ], outbuff[ MAX_LINE_SIZE ];
+    char       *in_dptr, *out_dptr;
+    int        d_total, d_count, d_excess, n;
+    Ulong      in_rec_addr, out_rec_addr = 0;
+    Rec_vitals *rptr;
+
+
+    /* Sift through file until first hex record is identified.    */
+    if ( ( rptr = identify_first_data_record( inbuff ) ) == NULL )
+    {
+        fputs( "No hex records found.\n", stderr );
+        exit( EXIT_FAILURE );
+    }
+
+
+    /* Attempt data-record splicing until end-of-file is reached. */
+    d_total = 0;
+    do
+    {
+        if ( rptr->is_data_record( inbuff ) == YES )
+        { /* Input record is a data record. */
+            d_count     = rptr->get_data_count( inbuff );
+            in_rec_addr = rptr->get_address( inbuff );
+            in_dptr     = rptr->get_data_start( inbuff );
+
+            if ( d_total == 0  ||  in_rec_addr != out_rec_addr + d_total )
+            { /* Begin a new output record. */
+                if ( d_total != 0 )
+                    rptr->put_data_record( d_total, out_rec_addr, outbuff );
+                out_dptr     = outbuff;
+                n = d_total  = d_count;
+                out_rec_addr = in_rec_addr;
+            }
+            else if
+              ( ( d_excess = d_total + d_count - rptr->max_data_count ) > 0 )
+            { /* Output a maximum-length record, then start a new record. */
+                strncat( outbuff, in_dptr, 2 * ( d_count - d_excess ) );
+                rptr->put_data_record(
+                  rptr->max_data_count, out_rec_addr, outbuff
+                );
+                in_dptr      += 2 * ( d_count - d_excess );
+                out_dptr      = outbuff;
+                n = d_total   = d_excess;
+                out_rec_addr += rptr->max_data_count;
+            }
+            else
+            { /* Append input record's data field with accumulated data. */
+                out_dptr = outbuff + ( 2 * d_total );
+                d_total += n = d_count;
+            }
+            strncpy( out_dptr, in_dptr, 2 * n );
+            out_dptr[ 2 * n ] = EOS;
+        }
+        else
+        { /* Not a data record;
+           * flush accumulated data then echo non-data record.
+           */
+            if ( d_total != 0 )
+            {
+                rptr->put_data_record( d_total, out_rec_addr, outbuff );
+                d_total = 0;
+            }
+            puts( inbuff );
+        }
+    } while ( gets( inbuff ) != NULL );
+
+
+    exit( EXIT_SUCCESS );
+
+}
+
+
+/****   identify_first_data_record   *******************************************
+*
+*       Expects: Pointer to hex-record line buffer.
+*
+*       Returns: Pointer to hex-record structure (NULL if no match found).
+*
+*       Reads the standard input, line by line, searching for a valid
+*       record header character.  If a valid header is found, a pointer
+*       to the hex-record's type structure is returned, otherwise NULL.
+*
+*       The input-stream pointer is left pointing to the first valid hex record.
+*
+*******************************************************************************/
+
+Rec_vitals * identify_first_data_record( char * buff_ptr )
+{
+    Rec_vitals  ** ptr;
+
+    while ( gets( buff_ptr ) != NULL )
+    {
+        for ( ptr = formats ; *ptr != ( Rec_vitals * ) NULL ; ptr++ )
+            if ( ( *ptr )->is_data_record( buff_ptr ) == YES )
+                return( *ptr );        /* Successful return.        */
+
+        puts( buff_ptr );              /* Echo non-hex-record line. */
+    }
+
+    return( ( Rec_vitals * ) NULL );   /* Unsuccessful return.      */
+}
+
+
+/****   get_ndigit_hex   *******************************************************
+*
+*       Expects: Pointer to first ASCII hexadecimal digit, number of digits.
+*
+*       Returns: Value of hexadecimal string as an unsigned long.
+*
+*******************************************************************************/
+
+Ulong get_ndigit_hex( char * cptr, int digits )
+{
+    Ulong    value;
+
+    for ( value = 0 ; --digits >= 0 ; cptr++ )
+        value = ( value * 16L ) + HEX_DIGIT( *cptr );
+
+    return( value );
+}

c/build-tools/src/unhex.c

@@ -0,0 +1,719 @@
+/*
+ * unhex
+ *      convert a hex file to binary equivalent.  If more than one file name
+ *      is given, then the output will be logically concatenated together.
+ *      stdin and stdout are defaults. Verbose will enable checksum output.
+ *
+ *  Supported input formats are Intel hex, Motorola S records, and TI 'B'
+ *  records.
+ *
+ * Intel hex input format is
+ *      Byte
+ *       1          Colon :
+ *       2..3       Record length, eg: "20"
+ *       4..7       load address nibbles
+ *       8..9       record type: "00" (data) or "02" base addr
+ *       10..x      data bytes in ascii-hex
+ *       x+1..x+2   cksum (2's compl of (len+addr+data))
+ *       x+3        \n -- newline
+ */
+
+char *USAGE = "\
+usage:    unhex [-va] [ -o file ] [ file [file ... ] ]\n\
+                -v          -- verbose\n\
+                -a base     -- 1st byte of output corresponds to this address\n\
+                -l          -- linear, just writes data out\n\
+                -o file     -- output file; must not be input file\n\
+                -F k_bits   -- \"holes\" in input will be filled with 0xFF's\n\
+                                  up to \"k_bits\" * 1024 bits\n\
+";
+
+#include <stdio.h>
+#include <fcntl.h>
+#include <ctype.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdarg.h>
+
+#define OK      0
+#define FAILURE (-1)
+#define Failed(x)       ((x) == FAILURE)
+#define TRUE    1
+#define FALSE   0
+typedef char bool;
+#define STREQ(a,b)      (strcmp(a,b) == 0)
+
+typedef unsigned char u8;
+typedef unsigned short u16;
+typedef unsigned long u32;
+
+/*
+ * Pick out designated bytes
+ */
+
+#define B0(x)       ((x) & 0xff)
+#define B1(x)       B0((x) >> 8)
+#define B2(x)       B0((x) >> 16)
+#define B3(x)       B0((x) >> 24)
+
+typedef struct buffer_rec {
+    u32 dl_destaddr;
+    u32 dl_jumpaddr;
+    int dl_count;
+    u8  dl_buf[512];
+} buffer_rec;
+
+/*
+ * vars controlled by command line options
+ */
+
+bool verbose = FALSE;                   /* be verbose */
+bool linear = FALSE;                    /* just write out linear data */
+char *outfilename = "-";                /* default output is stdout */
+u32 base = 0L;                         /* base address */
+u32 FFfill = 0L;                       /* how far to fill w 0xFF's */
+
+extern char *optarg;                    /* getopt(3) control vars */
+extern int optind;
+extern int errno;
+
+char *progname;                         /* for error() */
+
+void error(int errn, ...);
+#define ERR_ERRNO  (1<<((sizeof(int) * 8) - 2)) /* hi bit; use 'errno' */
+#define ERR_FATAL  (ERR_ERRNO / 2)              /* error is fatal; no return */
+#define ERR_ABORT  (ERR_ERRNO / 4)              /* error is fatal; abort */
+#define ERR_MASK   (ERR_ERRNO | ERR_FATAL | ERR_ABORT) /* all */
+
+#define stol(p) strtol(p, (char **) NULL, 0)
+
+int   unhex(FILE *ifp, char *inm, FILE *ofp, char *onm);
+int   convert_Intel_records(FILE *ifp, char *inm, FILE *ofp, char *onm);
+int   convert_S_records(FILE *ifp, char *inm, FILE *ofp, char *onm);
+int   convert_TI_records(FILE *ifp, char *inm, FILE *ofp, char *onm);
+void  write_record(buffer_rec *tb, FILE *fp);
+int   getnibble(char **p);
+int   getbyte(char **p);
+long  getNbytes(char **p, int n);
+void  badformat(char *s, char *fname, char *msg);
+
+#define get1bytes(p)    ((int) getbyte(p))
+#define get2bytes(p)    ((int) getNbytes(p, 2))
+#define get3bytes(p)    getNbytes(p, 3)
+#define get4bytes(p)    getNbytes(p, 4)
+
+char *BADADDR = "Invalid record address";
+char *BADLEN  = "Invalid record length";
+char *BADBASE = "Bad base or starting address";
+char *BADFMT =  "Unrecognized record type";
+char *BADDATA = "Invalid data byte";
+char *BADCSUM = "Invalid checksum";
+char *MISCSUM = "Checksum mismatch";
+char *BADTYPE = "Unrecognized record type";
+char *MISTYPE = "Incompatible record types";
+
+int
+main(argc, argv)
+int argc;
+char **argv;
+{
+    register int c;
+    bool showusage = FALSE;                     /* usage error? */
+    int rc = 0;
+    FILE *outfp, *infp;
+
+    /*
+     * figure out invocation leaf-name
+     */
+
+    if ((progname = strrchr(argv[0], '/')) == (char *) NULL)
+        progname = argv[0];
+    else
+        progname++;
+
+    argv[0] = progname;                         /* for getopt err reporting */
+
+    /*
+     *  Check options and arguments.
+     */
+
+    progname = argv[0];
+    while ((c = getopt(argc, argv, "F:a:o:vl")) != EOF)
+        switch (c)
+        {
+            case 'a':                           /* base address */
+                base = stol(optarg);
+                break;
+
+            case 'l':                           /* linear output */
+                linear = TRUE;
+                break;
+
+            case 'v':                           /* toggle verbose */
+                verbose = ! verbose;
+                break;
+
+            case 'o':                           /* output file */
+                outfilename = optarg;
+                break;
+
+            case 'F':                           /* 0xFF fill amount (bytes) */
+                FFfill = stol(optarg) * 1024L / 8L;
+                break;
+
+            case '?':
+                showusage = TRUE;
+        }
+
+    if (showusage)
+    {
+        (void) fprintf(stderr, "%s", USAGE);
+        exit(1);
+    }
+
+    if (linear && (base != 0))
+    {
+        error(0, "-l and -a may not be specified in combination");
+        exit(1);
+    }
+
+    if (STREQ(outfilename, "-"))
+    {
+        outfp = stdout;
+        outfilename = "stdout";
+    }
+    else
+        if ((outfp = fopen(outfilename, "w")) == (FILE *) NULL)
+        {
+            error(-1, "couldn't open '%s' for output", outfilename);
+            exit(1);
+        }
+
+    /*
+     * Now process the input files (or stdin, if none specified)
+     */
+
+    if (argv[optind] == (char *) NULL)          /* just stdin */
+        exit(unhex(stdin, "stdin", outfp, outfilename));
+    else
+        for (; (optarg = argv[optind]); optind++)
+        {
+            if (STREQ(optarg, "-"))
+                rc += unhex(stdin, "stdin", outfp, outfilename);
+            else
+            {
+                if ((infp = fopen(optarg, "r")) == (FILE *) NULL)
+                {
+                    error(-1, "couldn't open '%s' for input", optarg);
+                    exit(1);
+                }
+                rc += unhex(infp, optarg, outfp, outfilename);
+            }
+        }
+
+    return(rc);
+}
+
+u16 filesum;
+
+int
+unhex(FILE *ifp,
+      char *inm,
+      FILE *ofp,
+      char *onm)
+{
+    int c;
+
+    filesum = 0;
+
+    /*
+     * Make sure holes will be filled with 0xFF's if requested.  We
+     *  do this the easy way by just filling the file with FF's before
+     *  getting started.  To do it more optimally would be quite a bit
+     *  more difficult since the user can skip around as much as he/she
+     *  likes in the input hex file addressing.
+     *
+     *  We'll clean this up later (after this program has run) with
+     *  'stripffs'
+     */
+
+    if (FFfill)
+    {
+        (void) fseek(ofp, 0, 0);
+        for (c = FFfill; c > 0; c--)
+            (void) fputc(0xFF, ofp);
+    }
+
+    /*
+     * Read the first char from file and determine record types
+     */
+
+    if ((c = getc(ifp)) != EOF)
+    {
+        ungetc(c, ifp);
+        switch(c)
+        {
+            case 'S':
+                convert_S_records(ifp, inm, ofp, onm);
+                break;
+
+            case ':':
+                convert_Intel_records(ifp, inm, ofp, onm);
+                break;
+
+            case '9':
+            case 'B':
+                convert_TI_records(ifp, inm, ofp, onm);
+                break;
+
+            default:
+            {
+                char tmp[2];
+                tmp[0] = c; tmp[1] = 0;
+                badformat(tmp, inm, BADFMT);
+            }
+        }
+    }
+
+    if (verbose)
+        fprintf(stderr, "'%s' checksum is 0x%04x\n", inm, filesum);
+
+    return 0;
+}
+
+int
+convert_Intel_records(
+    FILE *ifp,
+    char *inm,
+    FILE *ofp,
+    char *onm)
+{
+    char buff[512];
+    char *p;
+    u8 cksum;
+    int incksum;
+    int c;
+    int rectype;                    /* record type */
+    int len;                        /* data length of current line */
+    u32 addr;
+    u32 base_address = 0;
+    bool endrecord = FALSE;
+    buffer_rec tb;
+
+    while ( ! endrecord && (fgets(buff, sizeof(buff), ifp)))
+    {
+        p = &buff[0];
+
+        if (p[strlen(p)-1] == '\n')                 /* get rid of newline */
+            p[strlen(p)-1] = '\0';
+
+        if (p[strlen(p)-1] == '\r')                 /* get rid of any CR */
+            p[strlen(p)-1] = '\0';
+
+        tb.dl_count = 0;
+
+        if (*p != ':')
+            badformat(p, inm, BADFMT);
+        p++;
+
+        if ((len = getbyte(&p)) == -1)      /* record len */
+            badformat(buff, inm, BADLEN);
+
+        if ((addr = get2bytes(&p)) == -1L)          /* record addr */
+            badformat(buff, inm, BADADDR);
+
+        rectype = getbyte(&p);
+
+        cksum = len + B0(addr) + B1(addr) + rectype;
+
+        switch (rectype)
+        {
+            case 0x00:                  /* normal data record */
+                tb.dl_destaddr = base_address + addr;
+                while (len--)
+                {
+                    if ((c = getbyte(&p)) == -1)
+                        badformat(buff, inm, BADDATA);
+                    cksum += c;
+                    filesum += c;
+                    tb.dl_buf[tb.dl_count++] = c;
+                }
+                break;
+
+            case 0x01:                  /* execution start address */
+                base_address = addr;
+                endrecord = TRUE;
+                break;
+
+            case 0x02:                  /* new base */
+                if ((base_address = get2bytes(&p)) == -1L)
+                    badformat(buff, inm, BADBASE);
+                cksum += B0(base_address) + B1(base_address);
+                base_address <<= 4;
+                break;
+
+            case 0x03:                  /* seg/off execution start address */
+            {
+                u32 seg, off;
+
+                seg = get2bytes(&p);
+                off = get2bytes(&p);
+                if ((seg == -1L) || (off == -1L))
+                    badformat(buff, inm, BADADDR);
+
+                cksum += B0(seg) + B1(seg) + B0(off) + B1(off);
+
+                tb.dl_jumpaddr = (seg << 4) + off;
+                break;
+            }
+
+            default:
+                error(0, "unknown Intel-hex record type: 0x%02x", rectype);
+                badformat(buff, inm, BADTYPE);
+        }
+
+        /*
+         * Verify checksums are correct in file.
+         */
+
+        cksum = (-cksum) & 0xff;
+        if ((incksum = getbyte(&p)) == -1)
+            badformat(buff, inm, BADCSUM);
+        if (((u8) incksum) != cksum)
+            badformat(buff, inm, MISCSUM);
+
+        if (tb.dl_count)
+            write_record(&tb, ofp);
+    }
+    return 0;
+}
+
+int
+convert_S_records(
+    FILE *ifp,
+    char *inm,
+    FILE *ofp,
+    char *onm)
+{
+    char buff[512];
+    char *p;
+    u8 cksum;
+    int incksum;
+    int c;
+    int len;                        /* data length of current line */
+    int rectype;                    /* record type */
+    u32 addr;
+    bool endrecord = FALSE;
+    buffer_rec tb;
+
+    while ( ! endrecord && (fgets(buff, sizeof(buff), ifp)))
+    {
+        p = &buff[0];
+
+        if (p[strlen(p)-1] == '\n')                 /* get rid of newline */
+            p[strlen(p)-1] = '\0';
+
+        if (p[strlen(p)-1] == '\r')                 /* get rid of any CR */
+            p[strlen(p)-1] = '\0';
+
+        tb.dl_count = 0;
+
+        if (*p != 'S')
+            badformat(p, inm, BADFMT);
+        p++;
+
+        if ((rectype = getnibble(&p)) == -1)        /* record type */
+            badformat(buff, inm, BADTYPE);
+
+        if ((len = getbyte(&p)) == -1)              /* record len */
+            badformat(buff, inm, BADLEN);
+        cksum = len;
+
+        switch (rectype)
+        {
+            case 0x00:                  /* comment field, ignored */
+                goto write_it;
+
+            case 0x01:                          /* data record, 16 bit addr */
+                if ((addr = get2bytes(&p)) == -1L)
+                    badformat(buff, inm, BADADDR);
+                len -= 3;
+                goto doit;
+
+            case 0x02:                          /* ... 24 bit addr */
+                if ((addr = get3bytes(&p)) == -1L)
+                    badformat(buff, inm, BADADDR);
+                len -= 4;
+                goto doit;
+
+            case 0x03:                          /* ... 32 bit addr */
+                if ((addr = get4bytes(&p)) == -1L)
+                    badformat(buff, inm, BADADDR);
+                len -= 5;
+    doit:
+                cksum += B0(addr) + B1(addr) + B2(addr) + B3(addr);
+
+                tb.dl_destaddr = addr;
+                while (len--)
+                {
+                    if ((c = getbyte(&p)) == -1)
+                        badformat(buff, inm, BADDATA);
+                    cksum += c;
+                    filesum += c;
+                    tb.dl_buf[tb.dl_count++] = c;
+                }
+                break;
+
+            case 0x07:                  /* 32 bit end record */
+                if ((addr = get4bytes(&p)) == -1L)
+                    badformat(buff, inm, BADADDR);
+                goto end_rec;
+
+            case 0x08:                  /* 24 bit end record */
+                if ((addr = get3bytes(&p)) == -1L)
+                    badformat(buff, inm, BADADDR);
+                goto end_rec;
+
+            case 0x09:                  /* 16 bit end record */
+                if ((addr = get2bytes(&p)) == -1L)
+                    badformat(buff, inm, BADADDR);
+
+end_rec:
+                cksum += B0(addr) + B1(addr) + B2(addr) + B3(addr);
+                tb.dl_jumpaddr = addr;
+                break;
+
+            default:
+                error(0, "unknown Motorola-S record type: 0x%02x", rectype);
+                badformat(buff, inm, BADTYPE);
+                break;
+        }
+
+        /*
+         * Verify checksums are correct in file.
+         */
+
+        cksum = (~cksum) & 0xff;
+        if ((incksum = getbyte(&p)) == -1)
+            badformat(buff, inm, BADCSUM);
+        if (((u8) incksum) != cksum)
+            badformat(buff, inm, MISCSUM);
+
+write_it:
+        if (tb.dl_count)
+            write_record(&tb, ofp);
+    }
+    return 0;
+}
+
+int
+convert_TI_records(
+    FILE *ifp,
+    char *inm,
+    FILE *ofp,
+    char *onm)
+{
+    char buff[512];
+    char *p;
+    int c;
+    bool endrecord = FALSE;
+    bool eol;
+    buffer_rec tb;
+
+    while ( ! endrecord && (fgets(buff, sizeof(buff), ifp)))
+    {
+        if (p[strlen(p)-1] == '\n')                 /* get rid of newline */
+            p[strlen(p)-1] = '\0';
+
+        if (p[strlen(p)-1] == '\r')                 /* get rid of any CR */
+            p[strlen(p)-1] = '\0';
+
+        tb.dl_count = 0;
+
+        p = &buff[0];
+        eol = FALSE;
+        while ( ! eol && ! endrecord)
+        {
+            switch (*p++)
+            {
+                case '9':
+                    if (tb.dl_count)
+                        write_record(&tb, ofp);
+                    tb.dl_destaddr = get2bytes(&p);
+                    break;
+
+                case 'B':
+                    c = getbyte(&p);
+                    filesum += c;
+                    tb.dl_buf[tb.dl_count++] = c;
+                    c = getbyte(&p);
+                    filesum += c;
+                    tb.dl_buf[tb.dl_count++] = c;
+                    break;
+
+                case 'F':
+                    eol = TRUE;
+                    break;
+
+                case ':':
+                    endrecord = TRUE;
+                    break;
+
+                default:
+                    badformat(p, inm, BADFMT);
+            }
+        }
+        if (tb.dl_count)
+            write_record(&tb, ofp);
+    }
+    return 0;
+}
+
+void
+write_record(buffer_rec *tb,
+             FILE *fp)
+{
+    if ( ! linear)
+    {
+        if (tb->dl_destaddr < base)
+            error(ERR_FATAL, "record at address 0x%x precedes base of 0x%x",
+                     tb->dl_destaddr, base);
+        (void) fseek(fp, tb->dl_destaddr - base, 0);
+    }
+
+    (void) fwrite(tb->dl_buf, tb->dl_count, 1, fp);
+    tb->dl_destaddr += tb->dl_count;
+    tb->dl_count = 0;
+}
+
+int
+getnibble(char **p)
+{
+    register int val;
+
+    **p = toupper(**p);
+    switch (**p)
+    {
+        case '0': case '1': case '2': case '3': case '4':
+        case '5': case '6': case '7': case '8': case '9':
+            val = **p - '0';
+            break;
+
+        case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
+            val = 10 + (**p - 'A');
+            break;
+
+        default:
+            return(-1);
+    }
+    *p += 1;
+
+    return(val & 0x0f);
+}
+
+int
+getbyte(char **p)
+{
+    int n0, n1;
+
+    if ((n0 = getnibble(p)) == -1)
+        return(-1);
+    if ((n1 = getnibble(p)) == -1)
+        return(-1);
+
+    return(((n0 << 4) + n1) & 0xff);
+}
+
+long
+getNbytes(char **p,
+          int n)
+{
+    int t;
+    u32 val = 0;
+
+    while (n--)
+    {
+        if ((t = getbyte(p)) == -1)
+            return(-1L);
+        val <<= 8;
+        val += t;
+    }
+
+    return(val);
+}
+
+void
+badformat(char *s,
+          char *fname,
+          char *msg)
+{
+    if (s[strlen(s)-1] == '\n')             /* get rid of newline */
+        s[strlen(s)-1] = '\0';
+    error(0, "line '%s'::\n\tfrom file '%s'; %s", s, fname, msg);
+    exit(1);
+}
+
+/*
+ * error(errn, arglist)
+ *      report an error to stderr using printf(3) conventions.
+ *      Any output is preceded by '<progname>: '
+ *
+ * Uses ERR_EXIT  bit to request exit(errn)
+ *      ERR_ABORT to request abort()
+ *      ERR_ERRNO to indicate use of errno instead of argument.
+ *
+ * If resulting 'errn' is non-zero, it is assumed to be an 'errno' and its
+ *      associated error message is appended to the output.
+ */
+
+/*VARARGS*/
+
+void
+error(int error_flag, ...)
+{
+    va_list arglist;
+    register char *format;
+    extern char *sys_errlist[];
+    extern int sys_nerr;
+    int local_errno;
+
+    extern int errno;
+
+    (void) fflush(stdout);          /* in case stdout/stderr same */
+
+    local_errno = error_flag & ~ERR_MASK;
+    if (error_flag & ERR_ERRNO)     /* use errno? */
+        local_errno = errno;
+
+    va_start(arglist, error_flag);
+    format = va_arg(arglist, char *);
+    (void) fprintf(stderr, "%s: ", progname);
+    (void) vfprintf(stderr, format, arglist);
+    va_end(arglist);
+
+    if (local_errno)
+        if ((local_errno > 0) && (local_errno < sys_nerr))
+            (void) fprintf(stderr, " (%s)\n", sys_errlist[local_errno]);
+        else
+            (void) fprintf(stderr, " (unknown errno=%d)\n", local_errno);
+    else
+        (void) fprintf(stderr, "\n");
+
+    (void) fflush(stderr);
+
+    if (error_flag & (ERR_FATAL | ERR_ABORT))
+    {
+        if (error_flag & ERR_FATAL)
+        {
+            error(0, local_errno ? "fatal error, exiting" : "exiting");
+            exit(local_errno);
+        }
+        else
+        {
+            error(0, "fatal error, aborting");
+            abort();
+        }
+    }
+}
+

c/build-tools/unhex.c

@@ -0,0 +1,719 @@
+/*
+ * unhex
+ *      convert a hex file to binary equivalent.  If more than one file name
+ *      is given, then the output will be logically concatenated together.
+ *      stdin and stdout are defaults. Verbose will enable checksum output.
+ *
+ *  Supported input formats are Intel hex, Motorola S records, and TI 'B'
+ *  records.
+ *
+ * Intel hex input format is
+ *      Byte
+ *       1          Colon :
+ *       2..3       Record length, eg: "20"
+ *       4..7       load address nibbles
+ *       8..9       record type: "00" (data) or "02" base addr
+ *       10..x      data bytes in ascii-hex
+ *       x+1..x+2   cksum (2's compl of (len+addr+data))
+ *       x+3        \n -- newline
+ */
+
+char *USAGE = "\
+usage:    unhex [-va] [ -o file ] [ file [file ... ] ]\n\
+                -v          -- verbose\n\
+                -a base     -- 1st byte of output corresponds to this address\n\
+                -l          -- linear, just writes data out\n\
+                -o file     -- output file; must not be input file\n\
+                -F k_bits   -- \"holes\" in input will be filled with 0xFF's\n\
+                                  up to \"k_bits\" * 1024 bits\n\
+";
+
+#include <stdio.h>
+#include <fcntl.h>
+#include <ctype.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdarg.h>
+
+#define OK      0
+#define FAILURE (-1)
+#define Failed(x)       ((x) == FAILURE)
+#define TRUE    1
+#define FALSE   0
+typedef char bool;
+#define STREQ(a,b)      (strcmp(a,b) == 0)
+
+typedef unsigned char u8;
+typedef unsigned short u16;
+typedef unsigned long u32;
+
+/*
+ * Pick out designated bytes
+ */
+
+#define B0(x)       ((x) & 0xff)
+#define B1(x)       B0((x) >> 8)
+#define B2(x)       B0((x) >> 16)
+#define B3(x)       B0((x) >> 24)
+
+typedef struct buffer_rec {
+    u32 dl_destaddr;
+    u32 dl_jumpaddr;
+    int dl_count;
+    u8  dl_buf[512];
+} buffer_rec;
+
+/*
+ * vars controlled by command line options
+ */
+
+bool verbose = FALSE;                   /* be verbose */
+bool linear = FALSE;                    /* just write out linear data */
+char *outfilename = "-";                /* default output is stdout */
+u32 base = 0L;                         /* base address */
+u32 FFfill = 0L;                       /* how far to fill w 0xFF's */
+
+extern char *optarg;                    /* getopt(3) control vars */
+extern int optind;
+extern int errno;
+
+char *progname;                         /* for error() */
+
+void error(int errn, ...);
+#define ERR_ERRNO  (1<<((sizeof(int) * 8) - 2)) /* hi bit; use 'errno' */
+#define ERR_FATAL  (ERR_ERRNO / 2)              /* error is fatal; no return */
+#define ERR_ABORT  (ERR_ERRNO / 4)              /* error is fatal; abort */
+#define ERR_MASK   (ERR_ERRNO | ERR_FATAL | ERR_ABORT) /* all */
+
+#define stol(p) strtol(p, (char **) NULL, 0)
+
+int   unhex(FILE *ifp, char *inm, FILE *ofp, char *onm);
+int   convert_Intel_records(FILE *ifp, char *inm, FILE *ofp, char *onm);
+int   convert_S_records(FILE *ifp, char *inm, FILE *ofp, char *onm);
+int   convert_TI_records(FILE *ifp, char *inm, FILE *ofp, char *onm);
+void  write_record(buffer_rec *tb, FILE *fp);
+int   getnibble(char **p);
+int   getbyte(char **p);
+long  getNbytes(char **p, int n);
+void  badformat(char *s, char *fname, char *msg);
+
+#define get1bytes(p)    ((int) getbyte(p))
+#define get2bytes(p)    ((int) getNbytes(p, 2))
+#define get3bytes(p)    getNbytes(p, 3)
+#define get4bytes(p)    getNbytes(p, 4)
+
+char *BADADDR = "Invalid record address";
+char *BADLEN  = "Invalid record length";
+char *BADBASE = "Bad base or starting address";
+char *BADFMT =  "Unrecognized record type";
+char *BADDATA = "Invalid data byte";
+char *BADCSUM = "Invalid checksum";
+char *MISCSUM = "Checksum mismatch";
+char *BADTYPE = "Unrecognized record type";
+char *MISTYPE = "Incompatible record types";
+
+int
+main(argc, argv)
+int argc;
+char **argv;
+{
+    register int c;
+    bool showusage = FALSE;                     /* usage error? */
+    int rc = 0;
+    FILE *outfp, *infp;
+
+    /*
+     * figure out invocation leaf-name
+     */
+
+    if ((progname = strrchr(argv[0], '/')) == (char *) NULL)
+        progname = argv[0];
+    else
+        progname++;
+
+    argv[0] = progname;                         /* for getopt err reporting */
+
+    /*
+     *  Check options and arguments.
+     */
+
+    progname = argv[0];
+    while ((c = getopt(argc, argv, "F:a:o:vl")) != EOF)
+        switch (c)
+        {
+            case 'a':                           /* base address */
+                base = stol(optarg);
+                break;
+
+            case 'l':                           /* linear output */
+                linear = TRUE;
+                break;
+
+            case 'v':                           /* toggle verbose */
+                verbose = ! verbose;
+                break;
+
+            case 'o':                           /* output file */
+                outfilename = optarg;
+                break;
+
+            case 'F':                           /* 0xFF fill amount (bytes) */
+                FFfill = stol(optarg) * 1024L / 8L;
+                break;
+
+            case '?':
+                showusage = TRUE;
+        }
+
+    if (showusage)
+    {
+        (void) fprintf(stderr, "%s", USAGE);
+        exit(1);
+    }
+
+    if (linear && (base != 0))
+    {
+        error(0, "-l and -a may not be specified in combination");
+        exit(1);
+    }
+
+    if (STREQ(outfilename, "-"))
+    {
+        outfp = stdout;
+        outfilename = "stdout";
+    }
+    else
+        if ((outfp = fopen(outfilename, "w")) == (FILE *) NULL)
+        {
+            error(-1, "couldn't open '%s' for output", outfilename);
+            exit(1);
+        }
+
+    /*
+     * Now process the input files (or stdin, if none specified)
+     */
+
+    if (argv[optind] == (char *) NULL)          /* just stdin */
+        exit(unhex(stdin, "stdin", outfp, outfilename));
+    else
+        for (; (optarg = argv[optind]); optind++)
+        {
+            if (STREQ(optarg, "-"))
+                rc += unhex(stdin, "stdin", outfp, outfilename);
+            else
+            {
+                if ((infp = fopen(optarg, "r")) == (FILE *) NULL)
+                {
+                    error(-1, "couldn't open '%s' for input", optarg);
+                    exit(1);
+                }
+                rc += unhex(infp, optarg, outfp, outfilename);
+            }
+        }
+
+    return(rc);
+}
+
+u16 filesum;
+
+int
+unhex(FILE *ifp,
+      char *inm,
+      FILE *ofp,
+      char *onm)
+{
+    int c;
+
+    filesum = 0;
+
+    /*
+     * Make sure holes will be filled with 0xFF's if requested.  We
+     *  do this the easy way by just filling the file with FF's before
+     *  getting started.  To do it more optimally would be quite a bit
+     *  more difficult since the user can skip around as much as he/she
+     *  likes in the input hex file addressing.
+     *
+     *  We'll clean this up later (after this program has run) with
+     *  'stripffs'
+     */
+
+    if (FFfill)
+    {
+        (void) fseek(ofp, 0, 0);
+        for (c = FFfill; c > 0; c--)
+            (void) fputc(0xFF, ofp);
+    }
+
+    /*
+     * Read the first char from file and determine record types
+     */
+
+    if ((c = getc(ifp)) != EOF)
+    {
+        ungetc(c, ifp);
+        switch(c)
+        {
+            case 'S':
+                convert_S_records(ifp, inm, ofp, onm);
+                break;
+
+            case ':':
+                convert_Intel_records(ifp, inm, ofp, onm);
+                break;
+
+            case '9':
+            case 'B':
+                convert_TI_records(ifp, inm, ofp, onm);
+                break;
+
+            default:
+            {
+                char tmp[2];
+                tmp[0] = c; tmp[1] = 0;
+                badformat(tmp, inm, BADFMT);
+            }
+        }
+    }
+
+    if (verbose)
+        fprintf(stderr, "'%s' checksum is 0x%04x\n", inm, filesum);
+
+    return 0;
+}
+
+int
+convert_Intel_records(
+    FILE *ifp,
+    char *inm,
+    FILE *ofp,
+    char *onm)
+{
+    char buff[512];
+    char *p;
+    u8 cksum;
+    int incksum;
+    int c;
+    int rectype;                    /* record type */
+    int len;                        /* data length of current line */
+    u32 addr;
+    u32 base_address = 0;
+    bool endrecord = FALSE;
+    buffer_rec tb;
+
+    while ( ! endrecord && (fgets(buff, sizeof(buff), ifp)))
+    {
+        p = &buff[0];
+
+        if (p[strlen(p)-1] == '\n')                 /* get rid of newline */
+            p[strlen(p)-1] = '\0';
+
+        if (p[strlen(p)-1] == '\r')                 /* get rid of any CR */
+            p[strlen(p)-1] = '\0';
+
+        tb.dl_count = 0;
+
+        if (*p != ':')
+            badformat(p, inm, BADFMT);
+        p++;
+
+        if ((len = getbyte(&p)) == -1)      /* record len */
+            badformat(buff, inm, BADLEN);
+
+        if ((addr = get2bytes(&p)) == -1L)          /* record addr */
+            badformat(buff, inm, BADADDR);
+
+        rectype = getbyte(&p);
+
+        cksum = len + B0(addr) + B1(addr) + rectype;
+
+        switch (rectype)
+        {
+            case 0x00:                  /* normal data record */
+                tb.dl_destaddr = base_address + addr;
+                while (len--)
+                {
+                    if ((c = getbyte(&p)) == -1)
+                        badformat(buff, inm, BADDATA);
+                    cksum += c;
+                    filesum += c;
+                    tb.dl_buf[tb.dl_count++] = c;
+                }
+                break;
+
+            case 0x01:                  /* execution start address */
+                base_address = addr;
+                endrecord = TRUE;
+                break;
+
+            case 0x02:                  /* new base */
+                if ((base_address = get2bytes(&p)) == -1L)
+                    badformat(buff, inm, BADBASE);
+                cksum += B0(base_address) + B1(base_address);
+                base_address <<= 4;
+                break;
+
+            case 0x03:                  /* seg/off execution start address */
+            {
+                u32 seg, off;
+
+                seg = get2bytes(&p);
+                off = get2bytes(&p);
+                if ((seg == -1L) || (off == -1L))
+                    badformat(buff, inm, BADADDR);
+
+                cksum += B0(seg) + B1(seg) + B0(off) + B1(off);
+
+                tb.dl_jumpaddr = (seg << 4) + off;
+                break;
+            }
+
+            default:
+                error(0, "unknown Intel-hex record type: 0x%02x", rectype);
+                badformat(buff, inm, BADTYPE);
+        }
+
+        /*
+         * Verify checksums are correct in file.
+         */
+
+        cksum = (-cksum) & 0xff;
+        if ((incksum = getbyte(&p)) == -1)
+            badformat(buff, inm, BADCSUM);
+        if (((u8) incksum) != cksum)
+            badformat(buff, inm, MISCSUM);
+
+        if (tb.dl_count)
+            write_record(&tb, ofp);
+    }
+    return 0;
+}
+
+int
+convert_S_records(
+    FILE *ifp,
+    char *inm,
+    FILE *ofp,
+    char *onm)
+{
+    char buff[512];
+    char *p;
+    u8 cksum;
+    int incksum;
+    int c;
+    int len;                        /* data length of current line */
+    int rectype;                    /* record type */
+    u32 addr;
+    bool endrecord = FALSE;
+    buffer_rec tb;
+
+    while ( ! endrecord && (fgets(buff, sizeof(buff), ifp)))
+    {
+        p = &buff[0];
+
+        if (p[strlen(p)-1] == '\n')                 /* get rid of newline */
+            p[strlen(p)-1] = '\0';
+
+        if (p[strlen(p)-1] == '\r')                 /* get rid of any CR */
+            p[strlen(p)-1] = '\0';
+
+        tb.dl_count = 0;
+
+        if (*p != 'S')
+            badformat(p, inm, BADFMT);
+        p++;
+
+        if ((rectype = getnibble(&p)) == -1)        /* record type */
+            badformat(buff, inm, BADTYPE);
+
+        if ((len = getbyte(&p)) == -1)              /* record len */
+            badformat(buff, inm, BADLEN);
+        cksum = len;
+
+        switch (rectype)
+        {
+            case 0x00:                  /* comment field, ignored */
+                goto write_it;
+
+            case 0x01:                          /* data record, 16 bit addr */
+                if ((addr = get2bytes(&p)) == -1L)
+                    badformat(buff, inm, BADADDR);
+                len -= 3;
+                goto doit;
+
+            case 0x02:                          /* ... 24 bit addr */
+                if ((addr = get3bytes(&p)) == -1L)
+                    badformat(buff, inm, BADADDR);
+                len -= 4;
+                goto doit;
+
+            case 0x03:                          /* ... 32 bit addr */
+                if ((addr = get4bytes(&p)) == -1L)
+                    badformat(buff, inm, BADADDR);
+                len -= 5;
+    doit:
+                cksum += B0(addr) + B1(addr) + B2(addr) + B3(addr);
+
+                tb.dl_destaddr = addr;
+                while (len--)
+                {
+                    if ((c = getbyte(&p)) == -1)
+                        badformat(buff, inm, BADDATA);
+                    cksum += c;
+                    filesum += c;
+                    tb.dl_buf[tb.dl_count++] = c;
+                }
+                break;
+
+            case 0x07:                  /* 32 bit end record */
+                if ((addr = get4bytes(&p)) == -1L)
+                    badformat(buff, inm, BADADDR);
+                goto end_rec;
+
+            case 0x08:                  /* 24 bit end record */
+                if ((addr = get3bytes(&p)) == -1L)
+                    badformat(buff, inm, BADADDR);
+                goto end_rec;
+
+            case 0x09:                  /* 16 bit end record */
+                if ((addr = get2bytes(&p)) == -1L)
+                    badformat(buff, inm, BADADDR);
+
+end_rec:
+                cksum += B0(addr) + B1(addr) + B2(addr) + B3(addr);
+                tb.dl_jumpaddr = addr;
+                break;
+
+            default:
+                error(0, "unknown Motorola-S record type: 0x%02x", rectype);
+                badformat(buff, inm, BADTYPE);
+                break;
+        }
+
+        /*
+         * Verify checksums are correct in file.
+         */
+
+        cksum = (~cksum) & 0xff;
+        if ((incksum = getbyte(&p)) == -1)
+            badformat(buff, inm, BADCSUM);
+        if (((u8) incksum) != cksum)
+            badformat(buff, inm, MISCSUM);
+
+write_it:
+        if (tb.dl_count)
+            write_record(&tb, ofp);
+    }
+    return 0;
+}
+
+int
+convert_TI_records(
+    FILE *ifp,
+    char *inm,
+    FILE *ofp,
+    char *onm)
+{
+    char buff[512];
+    char *p;
+    int c;
+    bool endrecord = FALSE;
+    bool eol;
+    buffer_rec tb;
+
+    while ( ! endrecord && (fgets(buff, sizeof(buff), ifp)))
+    {
+        if (p[strlen(p)-1] == '\n')                 /* get rid of newline */
+            p[strlen(p)-1] = '\0';
+
+        if (p[strlen(p)-1] == '\r')                 /* get rid of any CR */
+            p[strlen(p)-1] = '\0';
+
+        tb.dl_count = 0;
+
+        p = &buff[0];
+        eol = FALSE;
+        while ( ! eol && ! endrecord)
+        {
+            switch (*p++)
+            {
+                case '9':
+                    if (tb.dl_count)
+                        write_record(&tb, ofp);
+                    tb.dl_destaddr = get2bytes(&p);
+                    break;
+
+                case 'B':
+                    c = getbyte(&p);
+                    filesum += c;
+                    tb.dl_buf[tb.dl_count++] = c;
+                    c = getbyte(&p);
+                    filesum += c;
+                    tb.dl_buf[tb.dl_count++] = c;
+                    break;
+
+                case 'F':
+                    eol = TRUE;
+                    break;
+
+                case ':':
+                    endrecord = TRUE;
+                    break;
+
+                default:
+                    badformat(p, inm, BADFMT);
+            }
+        }
+        if (tb.dl_count)
+            write_record(&tb, ofp);
+    }
+    return 0;
+}
+
+void
+write_record(buffer_rec *tb,
+             FILE *fp)
+{
+    if ( ! linear)
+    {
+        if (tb->dl_destaddr < base)
+            error(ERR_FATAL, "record at address 0x%x precedes base of 0x%x",
+                     tb->dl_destaddr, base);
+        (void) fseek(fp, tb->dl_destaddr - base, 0);
+    }
+
+    (void) fwrite(tb->dl_buf, tb->dl_count, 1, fp);
+    tb->dl_destaddr += tb->dl_count;
+    tb->dl_count = 0;
+}
+
+int
+getnibble(char **p)
+{
+    register int val;
+
+    **p = toupper(**p);
+    switch (**p)
+    {
+        case '0': case '1': case '2': case '3': case '4':
+        case '5': case '6': case '7': case '8': case '9':
+            val = **p - '0';
+            break;
+
+        case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
+            val = 10 + (**p - 'A');
+            break;
+
+        default:
+            return(-1);
+    }
+    *p += 1;
+
+    return(val & 0x0f);
+}
+
+int
+getbyte(char **p)
+{
+    int n0, n1;
+
+    if ((n0 = getnibble(p)) == -1)
+        return(-1);
+    if ((n1 = getnibble(p)) == -1)
+        return(-1);
+
+    return(((n0 << 4) + n1) & 0xff);
+}
+
+long
+getNbytes(char **p,
+          int n)
+{
+    int t;
+    u32 val = 0;
+
+    while (n--)
+    {
+        if ((t = getbyte(p)) == -1)
+            return(-1L);
+        val <<= 8;
+        val += t;
+    }
+
+    return(val);
+}
+
+void
+badformat(char *s,
+          char *fname,
+          char *msg)
+{
+    if (s[strlen(s)-1] == '\n')             /* get rid of newline */
+        s[strlen(s)-1] = '\0';
+    error(0, "line '%s'::\n\tfrom file '%s'; %s", s, fname, msg);
+    exit(1);
+}
+
+/*
+ * error(errn, arglist)
+ *      report an error to stderr using printf(3) conventions.
+ *      Any output is preceded by '<progname>: '
+ *
+ * Uses ERR_EXIT  bit to request exit(errn)
+ *      ERR_ABORT to request abort()
+ *      ERR_ERRNO to indicate use of errno instead of argument.
+ *
+ * If resulting 'errn' is non-zero, it is assumed to be an 'errno' and its
+ *      associated error message is appended to the output.
+ */
+
+/*VARARGS*/
+
+void
+error(int error_flag, ...)
+{
+    va_list arglist;
+    register char *format;
+    extern char *sys_errlist[];
+    extern int sys_nerr;
+    int local_errno;
+
+    extern int errno;
+
+    (void) fflush(stdout);          /* in case stdout/stderr same */
+
+    local_errno = error_flag & ~ERR_MASK;
+    if (error_flag & ERR_ERRNO)     /* use errno? */
+        local_errno = errno;
+
+    va_start(arglist, error_flag);
+    format = va_arg(arglist, char *);
+    (void) fprintf(stderr, "%s: ", progname);
+    (void) vfprintf(stderr, format, arglist);
+    va_end(arglist);
+
+    if (local_errno)
+        if ((local_errno > 0) && (local_errno < sys_nerr))
+            (void) fprintf(stderr, " (%s)\n", sys_errlist[local_errno]);
+        else
+            (void) fprintf(stderr, " (unknown errno=%d)\n", local_errno);
+    else
+        (void) fprintf(stderr, "\n");
+
+    (void) fflush(stderr);
+
+    if (error_flag & (ERR_FATAL | ERR_ABORT))
+    {
+        if (error_flag & ERR_FATAL)
+        {
+            error(0, local_errno ? "fatal error, exiting" : "exiting");
+            exit(local_errno);
+        }
+        else
+        {
+            error(0, "fatal error, aborting");
+            abort();
+        }
+    }
+}
+

c/src/README

@@ -0,0 +1,27 @@
+#
+#  $Id$
+#
+
+This is the top level directory of the C RTEMS environment.  The
+following is a description of the contents of each file and
+subdirectory directly in this directory:
+
+    tests
+
+       This directory contains the RTEMS Test Suites. Currently
+       this includes the following suites:
+
+         + Single Processor Test Suite
+         + Multiprocessor Test Suite
+         + Timing Test Suite
+         + Sample Application Suite
+
+    lib
+
+       This directory contains src for RTEMS libraries:
+          libc, board support (including drivers) and libcpu.
+
+    exec
+
+       This directory contains the source code for the RTEMS executive.
+

c/src/exec/libcsupport/include/clockdrv.h

@@ -0,0 +1,58 @@
+/*  clock.h
+ *
+ *  This file describes the Clock Driver for all boards.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __CLOCK_DRIVER_h
+#define __CLOCK_DRIVER_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* variables */
+
+extern volatile rtems_unsigned32 Clock_driver_ticks;
+
+/* functions */
+
+rtems_task Exit_task();
+void exit_task_init();
+
+void Install_clock( rtems_isr_entry );
+void ReInstall_clock( rtems_isr_entry );
+void Clock_exit();
+
+rtems_isr Clock_isr(
+  rtems_vector_number
+);
+
+/* driver entries */
+
+#define CLOCK_DRIVER_TABLE_ENTRY \
+  { Clock_initialize, NULL, NULL, NULL, NULL, NULL }
+
+rtems_device_driver Clock_initialize(
+  rtems_device_major_number,
+  rtems_device_minor_number,
+  void *,
+  rtems_id,
+  rtems_unsigned32 *
+);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/libcsupport/include/console.h

@@ -0,0 +1,40 @@
+/*  console.h
+ *
+ *  This file describes the Console Device Driver for all boards.
+ *  This driver provides support for the standard C Library.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef _CONSOLE_DRIVER_h
+#define _CONSOLE_DRIVER_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define CONSOLE_DRIVER_TABLE_ENTRY \
+  { console_initialize, NULL, NULL, NULL, NULL, NULL }
+
+rtems_device_driver console_initialize(
+  rtems_device_major_number,
+  rtems_device_minor_number,
+  void *,
+  rtems_id,
+  rtems_unsigned32 *
+);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/libcsupport/include/iosupp.h

@@ -0,0 +1,44 @@
+/*  iosupp.h
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __IOSUPP_h
+#define __IOSUPP_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* character constants */
+
+#define BS              0x08            /* backspace */
+#define LF              0x0a            /* line feed */
+#define CR              0x0d            /* carriage return */
+#define XON             0x11            /* control-Q */
+#define XOFF            0x13            /* control-S */
+
+/* structures */
+
+#ifdef IOSUPP_INIT
+#define IOSUPP_EXTERN
+#else
+#undef IOSUPP_EXTERN
+#define IOSUPP_EXTERN  extern
+#endif
+
+/* functions */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

c/src/exec/libcsupport/include/rtems/libcsupport.h

@@ -0,0 +1,47 @@
+/*  libcsupport.h
+ *
+ *  This include file contains the information regarding the
+ *  RTEMS specific support for the standard C library.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __LIBC_SUPPORT_h
+#define __LIBC_SUPPORT_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <sys/types.h>
+
+void RTEMS_Malloc_Initialize(
+  void   *start,
+  size_t  length,
+  size_t  sbrk_amount
+);
+
+extern void libc_init(int reentrant);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/libcsupport/include/spurious.h

@@ -0,0 +1,38 @@
+/*  spurious.h
+ *
+ *  This file describes the Spurious Interrupt Driver for all boards.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993.
+ *  On-Line Applications Research Corporation (OAR).
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __SPURIOUS_h
+#define __SPURIOUS_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define SPURIOUS_DRIVER_TABLE_ENTRY \
+  { Spurious_Initialize, NULL, NULL, NULL, NULL, NULL }
+
+rtems_device_driver Spurious_Initialize(
+  rtems_device_major_number,
+  rtems_device_minor_number,
+  void *,
+  rtems_id,
+  rtems_unsigned32 *
+);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/libcsupport/include/timerdrv.h

@@ -0,0 +1,40 @@
+/*  timerdrv.h
+ *
+ *  This file describes the Timer Driver for all boards.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __TIMER_DRIVER_h
+#define __TIMER_DRIVER_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* functions */
+
+void Timer_initialize( void );
+
+rtems_unsigned32 Read_timer( void );
+
+rtems_status_code Empty_function( void );
+
+void Set_find_average_overhead(
+  rtems_boolean find_flag
+);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/libcsupport/include/vmeintr.h

@@ -0,0 +1,58 @@
+/*
+ *  vmeintr.h
+ *
+ *  This file is the specification for the VMEbus interface library
+ *  which should be provided by all BSPs for VMEbus Single Board
+ *  Computers but currently only a few do so.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __VME_INTERRUPT_h
+#define __VME_INTERRUPT_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ *  This defines the mask which is used to determine which
+ *  interrupt levels are affected by a call to this package.
+ *  The LSB corresponds to VME interrupt 0 and the MSB
+ *  to VME interrupt 7.
+ *
+ */
+
+typedef rtems_unsigned8 VME_interrupt_Mask;
+
+/*
+ *  VME_interrupt_Disable
+ *
+ */
+
+void VME_interrupt_Disable (
+  VME_interrupt_Mask                mask                        /* IN  */
+);
+
+/*
+ *  VME_interrupt_Disable
+ *
+ */
+
+void VME_interrupt_Enable (
+  VME_interrupt_Mask                mask                        /* IN  */
+);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* end of include file */

c/src/exec/libcsupport/src/README

@@ -0,0 +1,37 @@
+--
+--  $Id$
+--
+
+Overview of newlib support (newlib is from CYGNUS)
+    Each task can have its own libc state including:
+        open stdio files
+        strtok
+        multi precision arithmetic state
+        etc.
+
+    This is implemented by a reentrancy data structure for each task.
+
+    When a task is "started" (in RTEMS sense) the reentrancy structure
+    is allocated.  Its address is stored in notepad[NOTEPAD_LAST].
+
+    When task is switched to, the value of global variable _impure_ptr
+    is changed to the value of the new tasks reentrancy structure.
+
+    When a task is deleted
+        atexit() processing (for that task) happens
+        task's stdio buffers are flushed
+
+    When exit(3) is called
+        calling task's atexit processing done
+        global libc state atexit processing done
+            (this will include any atexit routines installed by drivers)
+        executive is shutdown
+            causes a context switch back to bsp land
+
+
+NOTE:
+    libc extension are installed by bsp_libc_init()
+        iff we are using clock interrupts.
+        This hack is necessary to allow the tmtests to avoid
+        timing the extensions.
+

c/src/exec/libcsupport/src/__brk.c

@@ -0,0 +1,40 @@
+/*
+ *  RTEMS "Broken" __brk/__sbrk Implementation
+ *
+ *  NOTE: sbrk is BSP provided.
+ *
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#include <rtems.h>
+
+#include <signal.h>
+#include <errno.h>
+#include <sys/types.h>
+#ifdef RTEMS_NEWLIB
+#include <reent.h>
+#endif
+#include <unistd.h>
+
+/* we use RTEMS for memory management.  We don't need sbrk */
+
+void * __sbrk(int incr)
+{
+  errno = EINVAL;
+  return (void *)0;
+}
+
+int __brk( const void *endds )
+{
+  errno = EINVAL;
+  return -1;
+}

c/src/exec/libcsupport/src/__gettod.c

@@ -0,0 +1,84 @@
+#if !defined(RTEMS_UNIX)
+/*
+ *  RTEMS gettimeofday Implementation
+ *
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#include <rtems.h>
+
+#ifdef RTEMS_NEWLIB
+#include <sys/reent.h>
+#endif
+#include <time.h>
+#include <sys/time.h>
+#include <errno.h>
+#include <assert.h>
+
+/*
+ *  NOTE:  The solaris gettimeofday does not have a second parameter.
+ */
+
+int gettimeofday(
+   struct timeval  *tp,
+   struct timezone *tzp
+)
+{
+  rtems_status_code      status;
+  rtems_clock_time_value time;
+
+  if ( !tp || !tzp ) {
+    errno = EFAULT;
+    return -1;
+  }
+
+  /* "POSIX" does not seem to allow for not having a TOD */
+  status = rtems_clock_get( RTEMS_CLOCK_GET_TIME_VALUE, &time );
+  if ( status != RTEMS_SUCCESSFUL ) {
+    assert( 0 );
+    return -1;
+  }
+
+  tp->tv_sec  = time.seconds;
+  tp->tv_usec = time.microseconds;
+
+#if 0
+  tzp->minuteswest = timezone / 60; /* from seconds to minutes */
+  tzp->dsttime = daylight;
+#endif
+
+  /*
+   * newlib does not have timezone and daylight savings time
+   * yet.  When it does this needs to be fixed.
+   */
+
+  tzp->tz_minuteswest = 0;  /* at UTC */
+  tzp->tz_dsttime = 0;      /* no daylight savings */
+  return 0;
+}
+
+/*
+ *  "Reentrant" versions of the above routines implemented above.
+ */
+
+#if 0
+int _gettimeofday_r(
+   struct _reent   *ignored_reentrancy_stuff,
+   struct timeval  *tp,
+   struct timezone *tzp
+)
+{
+  return gettimeofday( tp, tzp );
+}
+#endif
+
+#endif

c/src/exec/libcsupport/src/__times.c

@@ -0,0 +1,65 @@
+/*
+ *  RTEMS _times Implementation
+ *
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#include <rtems.h>
+
+#include <sys/times.h>
+#include <time.h>
+#include <sys/time.h>
+#include <errno.h>
+#include <assert.h>
+
+clock_t _times(
+   struct tms  *ptms
+)
+{
+  rtems_status_code      status;
+  rtems_interval         ticks_since_boot;
+
+  if ( !ptms ) {
+    errno = EFAULT;
+    return -1;
+  }
+
+  /* "POSIX" does not seem to allow for not having a TOD */
+  status = rtems_clock_get(
+    RTEMS_CLOCK_GET_TICKS_SINCE_BOOT,
+    &ticks_since_boot
+  );
+  if ( status != RTEMS_SUCCESSFUL ) {
+    assert( 0 );
+    return -1;
+  }
+
+  /*
+   *  RTEMS has no notion of system versus user time and does
+   *  not (as of 3.2.0) keep track of CPU usage on a per task basis.
+   */
+
+  ptms->tms_utime  = ticks_since_boot;
+  ptms->tms_stime  = 0;
+  ptms->tms_cutime = 0;
+  ptms->tms_cstime = 0;
+
+  return 0;
+}
+
+clock_t times(
+   struct tms  *ptms
+)
+{
+  return _times( ptms );
+}
+

c/src/exec/libcsupport/src/malloc.c

@@ -0,0 +1,280 @@
+/*
+ *  RTEMS Malloc Family Implementation
+ *
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#include <rtems.h>
+#ifdef RTEMS_LIBC
+#include <memory.h>
+#endif
+#include "libcsupport.h"
+#ifdef RTEMS_NEWLIB
+#include <sys/reent.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <assert.h>
+#include <errno.h>
+#include <string.h>
+
+/* 
+ *  XXX: Do we really need to duplicate these? It appears that they
+ *       only cause typing problems.
+ */
+
+#if 0
+void *malloc(size_t);
+void *calloc(size_t, size_t);
+void *realloc(void *, size_t);
+void free(void *);
+void *sbrk(size_t);
+#endif
+
+rtems_id RTEMS_Malloc_Heap;
+size_t RTEMS_Malloc_Sbrk_amount;
+
+void RTEMS_Malloc_Initialize(
+  void   *start,
+  size_t  length,
+  size_t  sbrk_amount
+)
+{
+  rtems_status_code   status;
+  void               *starting_address;
+  rtems_unsigned32    u32_address;
+
+  /*
+   * If the starting address is 0 then we are to attempt to
+   * get length worth of memory using sbrk. Make sure we
+   * align the address that we get back.
+   */
+
+  starting_address = start;
+
+  if (!starting_address) {
+    u32_address = (unsigned int)sbrk(length);
+
+    if (u32_address == -1) {
+      rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
+      /* DOES NOT RETURN!!! */
+    }
+
+    if (u32_address & (CPU_ALIGNMENT-1)) {
+      u32_address = (u32_address + CPU_ALIGNMENT) & ~(CPU_ALIGNMENT-1);
+      /* XXX: if we do any alignment .. then length should be shortened */
+    }
+
+    starting_address = (void *)u32_address;
+  }
+
+  /*
+   *  Unfortunately we cannot use assert if this fails because if this
+   *  has failed we do not have a heap and if we do not have a heap
+   *  STDIO cannot work because there will be no buffers.
+   */
+
+  status = rtems_region_create(
+    rtems_build_name( 'H', 'E', 'A', 'P' ),
+    starting_address,
+    length,
+    8,                     /* XXX : use CPU dependent RTEMS constant */
+    RTEMS_DEFAULT_ATTRIBUTES,
+    &RTEMS_Malloc_Heap
+  );
+  if ( status != RTEMS_SUCCESSFUL )
+    rtems_fatal_error_occurred( status );
+}
+
+void *malloc(
+  size_t  size
+)
+{
+  void              *return_this;
+  void              *starting_address;
+  rtems_unsigned32   the_size;
+  rtems_unsigned32   sbrk_amount;
+  rtems_status_code  status;
+
+  if ( !size )
+    return (void *) 0;
+
+  /*
+   * Try to give a segment in the current region if there is not
+   * enough space then try to grow the region using rtems_region_extend().
+   * If this fails then return a NULL pointer.
+   */
+
+  status = rtems_region_get_segment(
+    RTEMS_Malloc_Heap,
+    size,
+    RTEMS_NO_WAIT,
+    RTEMS_NO_TIMEOUT,
+    &return_this
+  );
+
+  if ( status != RTEMS_SUCCESSFUL ) {
+    /*
+     *  Round to the "requested sbrk amount" so hopefully we won't have
+     *  to grow again for a while.  This effectively does sbrk() calls
+     *  in "page" amounts.
+     */
+
+    sbrk_amount = RTEMS_Malloc_Sbrk_amount;
+
+    if ( sbrk_amount == 0 )
+      return (void *) 0;
+
+    the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount);
+
+    if (((rtems_unsigned32)starting_address = sbrk(the_size)) == -1)
+      return (void *) 0;
+
+    /*
+    fprintf(stderr, "Extended the C heap starting at 0x%x for %d bytes\n",
+        (unsigned32)starting_address, the_size);
+     */
+
+    status = rtems_region_extend(
+      RTEMS_Malloc_Heap,
+      starting_address,
+      the_size
+    );
+    if ( status != RTEMS_SUCCESSFUL ) {
+      sbrk(-the_size);
+      return(FALSE);
+      errno = ENOMEM;
+      return (void *) 0;
+    }
+    status = rtems_region_get_segment(
+      RTEMS_Malloc_Heap,
+       size,
+       RTEMS_NO_WAIT,
+       RTEMS_NO_TIMEOUT,
+       &return_this
+    );
+    if ( status != RTEMS_SUCCESSFUL ) {
+      errno = ENOMEM;
+      return (void *) 0;
+    }
+  }
+
+  return return_this;
+}
+
+void *calloc(
+  size_t nelem,
+  size_t elsize
+)
+{
+  register char *cptr;
+  int length;
+
+  length = nelem * elsize;
+  cptr = malloc( length );
+  if ( cptr )
+    memset( cptr, '\0', length );
+
+  return cptr;
+}
+
+void *realloc(
+  void *ptr,
+  size_t size
+)
+{
+  rtems_unsigned32  old_size;
+  rtems_status_code status;
+  char *new_area;
+
+  if ( !ptr )
+    return malloc( size );
+
+  if ( !size ) {
+    free( ptr );
+    return (void *) 0;
+  }
+
+  status = rtems_region_get_segment_size( RTEMS_Malloc_Heap, ptr, &old_size );
+  if ( status != RTEMS_SUCCESSFUL ) {
+    errno = EINVAL;
+    return (void *) 0;
+  }
+
+  new_area = malloc( size );
+  if ( !new_area ) {
+    free( ptr );
+    return (void *) 0;
+  }
+
+  memcpy( new_area, ptr, (size < old_size) ? size : old_size );
+  free( ptr );
+
+  return new_area;
+
+}
+
+void free(
+  void *ptr
+)
+{
+  rtems_status_code status;
+
+  if ( !ptr )
+    return;
+
+  status = rtems_region_return_segment( RTEMS_Malloc_Heap, ptr );
+  if ( status != RTEMS_SUCCESSFUL ) {
+    errno = EINVAL;
+    assert( 0 );
+  }
+}
+
+/*
+ *  "Reentrant" versions of the above routines implemented above.
+ */
+
+#ifdef RTEMS_NEWLIB
+void *malloc_r(
+  struct _reent *ignored,
+  size_t  size
+)
+{
+  return malloc( size );
+}
+
+void *calloc_r(
+  size_t nelem,
+  size_t elsize
+)
+{
+  return calloc( nelem, elsize );
+}
+
+void *realloc_r(
+  void *ptr,
+  size_t size
+)
+{
+  return realloc_r( ptr, size );
+}
+
+void free_r(
+  void *ptr
+)
+{
+  free( ptr );
+}
+#endif
+

c/src/exec/libcsupport/src/newlibc.c

@@ -0,0 +1,292 @@
+/*
+ *	@(#)newlibc.c	1.8 - 95/04/25
+ *	
+ */
+
+#if defined(RTEMS_NEWLIB)
+
+/*
+ *  File:	$RCSfile$
+ *  Project:	PixelFlow
+ *  Created:	94/12/7
+ *  Revision:	$Revision$
+ *  Last Mod:	$Date$
+ *
+ *  COPYRIGHT (c) 1994 by Division Incorporated
+ *
+ *  To anyone who acknowledges that this file is provided "AS IS"
+ *  without any express or implied warranty:
+ *      permission to use, copy, modify, and distribute this file
+ *      for any purpose is hereby granted without fee, provided that
+ *      the above copyright notice and this notice appears in all
+ *      copies, and that the name of Division Incorporated not be
+ *      used in advertising or publicity pertaining to distribution
+ *      of the software without specific, written prior permission.
+ *      Division Incorporated makes no representations about the
+ *      suitability of this software for any purpose.
+ *
+ *  Description:
+ *      Implementation of hooks for the CYGNUS newlib libc
+ *      These hooks set things up so that:
+ *              '_REENT' is switched at task switch time.
+ *
+ *
+ *  TODO:
+ *
+ *  NOTE:
+ *
+ *  $Id$
+ *
+ */
+
+#include <rtems.h>
+#include <libcsupport.h>
+#include <stdlib.h>             /* for free() */
+#include <string.h>             /* for memset() */
+
+#include <sys/reent.h>          /* for extern of _REENT (aka _impure_ptr) */
+
+#include "internal.h"
+
+#define LIBC_NOTEPAD RTEMS_NOTEPAD_LAST
+
+
+int              libc_reentrant;        /* do we think we are reentrant? */
+struct _reent    libc_global_reent = _REENT_INIT(libc_global_reent);;
+
+/*
+ * CYGNUS newlib routine that does atexit() processing and flushes
+ *      stdio streams
+ *      undocumented
+ */
+
+extern void _wrapup_reent(struct _reent *);
+extern void _reclaim_reent(struct _reent *);
+
+void
+libc_wrapup(void)
+{
+    _wrapup_reent(0);
+    if (_REENT != &libc_global_reent)
+    {
+        _wrapup_reent(&libc_global_reent);
+#if 0
+        /* don't reclaim this one, just in case we do printfs */
+        /* on our way out to ROM */
+        _reclaim_reent(&libc_global_reent);
+#endif
+        _REENT = &libc_global_reent;
+    }
+}
+
+
+rtems_extension
+libc_create_hook(rtems_tcb *current_task,
+                 rtems_tcb *creating_task)
+{
+    MY_task_set_note(creating_task, LIBC_NOTEPAD, 0);
+}
+
+/*
+ * Called for all user TASKS (system tasks are SYSI and IDLE)
+ */
+
+rtems_extension
+libc_start_hook(rtems_tcb *current_task,
+                rtems_tcb *starting_task)
+{
+    struct _reent *ptr;
+
+    /* NOTE: our malloc is reentrant without a reent ptr since
+     *  it is based on region manager
+     */
+
+    ptr = (struct _reent *) malloc(sizeof(struct _reent));
+
+    /* GCC extension: structure constants */
+    *ptr = (struct _reent) _REENT_INIT((*ptr));
+
+    MY_task_set_note(starting_task, LIBC_NOTEPAD, (rtems_unsigned32) ptr);
+}
+
+rtems_extension
+libc_switch_hook(rtems_tcb *current_task,
+                 rtems_tcb *heir_task)
+{
+    rtems_unsigned32 impure_value;
+
+    /* XXX We can't use rtems_task_set_note() here since SYSI task has a
+     * tid of 0, which is treated specially (optimized, actually)
+     * by rtems_task_set_note
+     */
+
+    impure_value = (rtems_unsigned32) _REENT;
+    MY_task_set_note(current_task, LIBC_NOTEPAD, impure_value);
+
+    _REENT = (struct _reent *) MY_task_get_note(heir_task, LIBC_NOTEPAD);
+
+}
+
+/*
+ *  Function:   libc_delete_hook
+ *  Created:    94/12/10
+ *
+ *  Description:
+ *      Called when a task is deleted.
+ *      Must restore the new lib reentrancy state for the new current
+ *      task.
+ *
+ *  Parameters:
+ *
+ *
+ *  Returns:
+ *
+ *
+ *  Side Effects:
+ *
+ *  Notes:
+ *
+ *
+ *  Deficiencies/ToDo:
+ *
+ *
+ */
+rtems_extension
+libc_delete_hook(rtems_tcb *current_task,
+                 rtems_tcb *deleted_task)
+{
+    struct _reent *ptr;
+
+    /*
+     * The reentrancy structure was allocated by newlib using malloc()
+     */
+
+    if (current_task == deleted_task)
+    {
+        ptr = _REENT;
+    }
+    else
+    {
+        ptr = (struct _reent *) MY_task_get_note(deleted_task, LIBC_NOTEPAD);
+    }
+
+    if (ptr)
+    {
+        _wrapup_reent(ptr);
+        _reclaim_reent(ptr);
+    }
+
+    MY_task_set_note(deleted_task, LIBC_NOTEPAD, 0);
+
+    /*
+     * Require the switch back to another task to install its own
+     */
+
+    if (current_task == deleted_task)
+    {
+        _REENT = 0;
+    }
+}
+
+/*
+ *  Function:   libc_init
+ *  Created:    94/12/10
+ *
+ *  Description:
+ *      Init libc for CYGNUS newlib
+ *      Set up _REENT to use our global libc_global_reent.
+ *      (newlib provides a global of its own, but we prefer our
+ *      own name for it)
+ *
+ *      If reentrancy is desired (which it should be), then
+ *      we install the task extension hooks to maintain the
+ *      newlib reentrancy global variable _REENT on task
+ *      create, delete, switch, exit, etc.
+ *
+ *  Parameters:
+ *      reentrant               non-zero if reentrant library desired.
+ *
+ *  Returns:
+ *
+ *  Side Effects:
+ *      installs libc extensions if reentrant.
+ *
+ *  Notes:
+ *
+ *
+ *  Deficiencies/ToDo:
+ *
+ */
+
+void
+libc_init(int reentrant)
+{
+    rtems_extensions_table  libc_extension;
+    rtems_id                extension_id;
+    rtems_status_code       rc;
+
+    _REENT = &libc_global_reent;
+
+    if (reentrant)
+    {
+        memset(&libc_extension, 0, sizeof(libc_extension));
+
+        libc_extension.rtems_task_create  = libc_create_hook;
+        libc_extension.rtems_task_start   = libc_start_hook;
+        libc_extension.task_switch  = libc_switch_hook;
+        libc_extension.rtems_task_delete  = libc_delete_hook;
+
+        rc = rtems_extension_create(rtems_build_name('L', 'I', 'B', 'C'),
+                              &libc_extension, &extension_id);
+        if (rc != RTEMS_SUCCESSFUL)
+            rtems_fatal_error_occurred(rc);
+
+        libc_reentrant = reentrant;
+    }
+}
+
+
+void
+exit(int status)
+{
+    libc_wrapup();
+    rtems_shutdown_executive(status);
+}
+
+
+/*
+ *  Function:   _exit
+ *  Created:    94/12/10
+ *
+ *  Description:
+ *      Called from exit() after it does atexit() processing and stdio fflush's
+ *
+ *      called from bottom of exit() to really delete the task.
+ *      If we are using reentrant libc, then let the delete extension
+ *      do all the work, otherwise if a shutdown is in progress,
+ *      then just do it.
+ *
+ *  Parameters:
+ *      exit status
+ *
+ *  Returns:
+ *      does not return
+ *
+ *  Side Effects:
+ *
+ *  Notes:
+ *
+ *
+ *  Deficiencies/ToDo:
+ *
+ *
+ */
+
+#ifndef RTEMS_UNIX
+void _exit(int status)
+{
+    rtems_shutdown_executive(status);
+}
+#endif
+
+#endif

c/src/exec/libcsupport/src/no_libc.c

@@ -0,0 +1,45 @@
+#if  !defined(RTEMS_LIBC) && !defined(RTEMS_NEWLIB) && !defined(RTEMS_UNIX)
+
+/*  no_libc.h
+ *
+ *  This file contains stubs for the reentrancy hooks when
+ *  an unknown C library is used.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+
+#include <rtems.h>
+
+#include "libcsupport.h"
+#include "internal.h"
+
+#include <stdlib.h>             /* for free() */
+
+void
+libc_init(int reentrant)
+{
+}
+
+void libc_suspend_main(void)
+{
+}
+
+
+void libc_global_exit(rtems_unsigned32 code)
+{
+}
+
+void _exit(int status)
+{
+}
+
+#endif

c/src/exec/libcsupport/src/unixlibc.c

@@ -0,0 +1,7 @@
+#if defined(RTEMS_UNIXLIB)
+
+void libc_init(int reentrant)
+{
+}
+
+#endif

c/src/exec/rtems/headers/asr.h

@@ -0,0 +1,177 @@
+/*  asr.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the Asynchronous Signal Handler.  This Handler provides the low-level
+ *  support required by the Signal Manager.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_ASR_h
+#define __RTEMS_ASR_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/modes.h>
+
+/*
+ *
+ *  The following type defines the control block used to manage
+ *  each signal set.
+ */
+
+typedef unsigned32 rtems_signal_set;
+
+/*
+ *  Return type for ASR Handler
+ */
+
+typedef void rtems_asr;
+
+/*
+ *  The following type corresponds to the applications asynchronous
+ *  signal processing routine.
+ */
+
+typedef rtems_asr ( *rtems_asr_entry )(
+                 rtems_signal_set
+             );
+
+/*
+ *
+ *  The following defines the control structure used to manage
+ *  signals.  Each thread has a copy of this record.
+ */
+
+typedef struct {
+  rtems_asr_entry            handler;          /* address of RTEMS_ASR */
+  rtems_mode          mode_set;         /* RTEMS_ASR mode */
+  rtems_signal_set signals_posted;   /* signal set */
+  rtems_signal_set signals_pending;  /* pending signal set */
+  unsigned32             nest_level;       /* nest level of RTEMS_ASR */
+}   ASR_Information;
+
+/*
+ *  The following constants define the individual signals which may
+ *  be used to compose a signal set.
+ */
+
+#define RTEMS_SIGNAL_0    0x00000001
+#define RTEMS_SIGNAL_1    0x00000002
+#define RTEMS_SIGNAL_2    0x00000004
+#define RTEMS_SIGNAL_3    0x00000008
+#define RTEMS_SIGNAL_4    0x00000010
+#define RTEMS_SIGNAL_5    0x00000020
+#define RTEMS_SIGNAL_6    0x00000040
+#define RTEMS_SIGNAL_7    0x00000080
+#define RTEMS_SIGNAL_8    0x00000100
+#define RTEMS_SIGNAL_9    0x00000200
+#define RTEMS_SIGNAL_10   0x00000400
+#define RTEMS_SIGNAL_11   0x00000800
+#define RTEMS_SIGNAL_12   0x00001000
+#define RTEMS_SIGNAL_13   0x00002000
+#define RTEMS_SIGNAL_14   0x00004000
+#define RTEMS_SIGNAL_15   0x00008000
+#define RTEMS_SIGNAL_16   0x00010000
+#define RTEMS_SIGNAL_17   0x00020000
+#define RTEMS_SIGNAL_18   0x00040000
+#define RTEMS_SIGNAL_19   0x00080000
+#define RTEMS_SIGNAL_20   0x00100000
+#define RTEMS_SIGNAL_21   0x00200000
+#define RTEMS_SIGNAL_22   0x00400000
+#define RTEMS_SIGNAL_23   0x00800000
+#define RTEMS_SIGNAL_24   0x01000000
+#define RTEMS_SIGNAL_25   0x02000000
+#define RTEMS_SIGNAL_26   0x04000000
+#define RTEMS_SIGNAL_27   0x08000000
+#define RTEMS_SIGNAL_28   0x10000000
+#define RTEMS_SIGNAL_29   0x20000000
+#define RTEMS_SIGNAL_30   0x40000000
+#define RTEMS_SIGNAL_31   0x80000000
+
+/*
+ *  _ASR_Initialize
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine initializes the given RTEMS_ASR information record.
+ */
+
+STATIC INLINE void _ASR_Initialize (
+  ASR_Information *information
+);
+
+/*
+ *  _ASR_Swap_signals
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine atomically swaps the pending and posted signal
+ *  sets.  This is done when the thread alters its mode in such a
+ *  way that the RTEMS_ASR disable/enable flag changes.
+ */
+
+STATIC INLINE void _ASR_Swap_signals (
+  ASR_Information *information
+);
+
+/*
+ *  _ASR_Is_null_handler
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the given asr_handler is NULL and
+ *  FALSE otherwise.
+ */
+
+STATIC INLINE boolean _ASR_Is_null_handler (
+  rtems_asr_entry asr_handler
+);
+
+/*
+ *  _ASR_Are_signals_pending
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if there are signals pending in the
+ *  given RTEMS_ASR information record and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _ASR_Are_signals_pending (
+  ASR_Information *information
+);
+
+/*
+ *  _ASR_Post_signals
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine posts the given signals into the signal_set
+ *  passed in.  The result is returned to the user in signal_set.
+ *
+ *  NOTE:  This must be implemented as a macro.
+ */
+
+STATIC INLINE void _ASR_Post_signals(
+  rtems_signal_set  signals,
+  rtems_signal_set *signal_set
+);
+
+#include <rtems/asr.inl>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/headers/attr.h

@@ -0,0 +1,188 @@
+/*  attr.h
+ *
+ *  This include file contains all information about the Object Attributes
+ *  Handler.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_ATTRIBUTES_h
+#define __RTEMS_ATTRIBUTES_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* types */
+
+typedef unsigned32 rtems_attribute;
+
+/* constants */
+
+#define RTEMS_DEFAULT_ATTRIBUTES            0x00000000
+
+#define RTEMS_NO_FLOATING_POINT   0x00000000 /* don't use FP HW */
+#define RTEMS_FLOATING_POINT      0x00000001 /* utilize coprocessor */
+
+#define RTEMS_LOCAL               0x00000000 /* local resource */
+#define RTEMS_GLOBAL              0x00000002 /* global resource */
+
+#define RTEMS_FIFO                0x00000000 /* process RTEMS_FIFO */
+#define RTEMS_PRIORITY            0x00000004 /* process by priority */
+
+#define RTEMS_NO_LIMIT            0x00000000 /* unlimited Q entries */
+#define RTEMS_LIMIT               0x00000008 /* limit Q entries */
+
+#define RTEMS_COUNTING_SEMAPHORE  0x00000000
+#define RTEMS_BINARY_SEMAPHORE    0x00000010
+
+#define RTEMS_NO_INHERIT_PRIORITY 0x00000000
+#define RTEMS_INHERIT_PRIORITY    0x00000020
+
+#if ( CPU_HARDWARE_FP == TRUE )
+#define ATTRIBUTES_NOT_SUPPORTED       0
+#else
+#define ATTRIBUTES_NOT_SUPPORTED       RTEMS_FLOATING_POINT
+#endif
+
+#if ( CPU_ALL_TASKS_ARE_FP == TRUE )
+#define ATTRIBUTES_REQUIRED            RTEMS_FLOATING_POINT
+#else
+#define ATTRIBUTES_REQUIRED            0
+#endif
+
+/*
+ *  _Attributes_Handler_initialization
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs initialization for this handler.
+ *
+ *  NOTE: There is no initialization required in C.  Conditional compilation
+ *        takes care of this in C.
+ */
+
+#define _Attributes_Handler_initialization()
+
+/*
+ *  _Attributes_Set
+ *
+ *  DESCRIPTION:
+ *
+ *  This function sets the requested new_attributes in the attribute_set
+ *  passed in.  The result is returned to the user.
+ */
+
+STATIC INLINE rtems_attribute _Attributes_Set (
+   rtems_attribute new_attributes,
+   rtems_attribute attribute_set
+);
+
+/*
+ *  _Attributes_Clear
+ *
+ *  DESCRIPTION:
+ *
+ *  This function clears the requested new_attributes in the attribute_set
+ *  passed in.  The result is returned to the user.
+ */
+
+STATIC INLINE rtems_attribute _Attributes_Clear (
+   rtems_attribute attribute_set,
+   rtems_attribute mask
+);
+
+/*
+ *  _Attributes_Is_floating_point
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the floating point attribute is
+ *  enabled in the attribute_set and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Attributes_Is_floating_point(
+  rtems_attribute attribute_set
+);
+
+/*
+ *  _Attributes_Is_global
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the global object attribute is
+ *  enabled in the attribute_set and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Attributes_Is_global(
+  rtems_attribute attribute_set
+);
+
+/*
+ *  _Attributes_Is_priority
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the priority attribute is
+ *  enabled in the attribute_set and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Attributes_Is_priority(
+  rtems_attribute attribute_set
+);
+
+/*
+ *  _Attributes_Is_limit
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the limited attribute is
+ *  enabled in the attribute_set and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Attributes_Is_limit(
+  rtems_attribute attribute_set
+);
+
+/*
+ *  _Attributes_Is_binary_semaphore
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the binary semaphore attribute is
+ *  enabled in the attribute_set and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Attributes_Is_binary_semaphore(
+  rtems_attribute attribute_set
+);
+
+/*
+ *  _Attributes_Is_inherit_priority
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the priority inheritance attribute
+ *  is enabled in the attribute_set and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Attributes_Is_inherit_priority(
+  rtems_attribute attribute_set
+);
+
+#include <rtems/attr.inl>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/headers/clock.h

@@ -0,0 +1,102 @@
+/*  clock.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the Clock Manager.  This manager provides facilities to set, obtain,
+ *  and continually update the current date and time.
+ *
+ *  This manager provides directives to:
+ *
+ *     + set the current date and time
+ *     + obtain the current date and time
+ *     + announce a clock tick
+ *
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_CLOCK_h
+#define __RTEMS_CLOCK_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/tod.h>
+
+/*
+ *  List of things which can be returned by the rtems_clock_get directive.
+ */
+
+typedef enum {
+  RTEMS_CLOCK_GET_TOD,
+  RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH,
+  RTEMS_CLOCK_GET_TICKS_SINCE_BOOT,
+  RTEMS_CLOCK_GET_TICKS_PER_SECOND,
+  RTEMS_CLOCK_GET_TIME_VALUE
+} rtems_clock_get_options;
+
+/*
+ *  Standard flavor style to return TOD in for a rtems_clock_get option.
+ */
+
+typedef struct {
+  unsigned32  seconds;
+  unsigned32  microseconds;
+} rtems_clock_time_value;
+
+/*
+ *  rtems_clock_get
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_clock_get directive.  It returns
+ *  one of the following:
+ *    + current time of day
+ *    + seconds since epoch
+ *    + ticks since boot
+ *    + ticks per second
+ */
+
+rtems_status_code rtems_clock_get(
+  rtems_clock_get_options  option,
+  void              *time_buffer
+);
+
+/*
+ *  rtems_clock_set
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_clock_set directive.  It sets
+ *  the current time of day to that in the time_buffer record.
+ */
+
+rtems_status_code rtems_clock_set(
+  rtems_time_of_day *time_buffer
+);
+
+/*
+ *  rtems_clock_tick
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_clock_tick directive.  It is invoked
+ *  to inform RTEMS of the occurrence of a clock tick.
+ */
+
+rtems_status_code rtems_clock_tick( void );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/headers/dpmem.h

@@ -0,0 +1,210 @@
+/*  dpmem.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the Dual Ported Memory Manager. This manager provides a mechanism
+ *  for converting addresses between internal and external representations
+ *  for multiple dual-ported memory areas.
+ *
+ *  Directives provided are:
+ *
+ *     + create a port
+ *     + get ID of a port
+ *     + delete a port
+ *     + convert external to internal address
+ *     + convert internal to external address
+ *
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_DUAL_PORTED_MEMORY_h
+#define __RTEMS_DUAL_PORTED_MEMORY_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/object.h>
+
+/*
+ *  The following structure defines the port control block.  Each port
+ *  has a control block associated with it.  This control block contains
+ *  all information required to support the port related operations.
+ */
+
+typedef struct {
+  Objects_Control  Object;
+  void            *internal_base; /* base internal address */
+  void            *external_base; /* base external address */
+  unsigned32       length;        /* length of dual-ported area */
+}   Dual_ported_memory_Control;
+
+/*
+ *  The following define the internal Dual Ported Memory information.
+ */
+
+EXTERN Objects_Information  _Dual_ported_memory_Information;
+
+/*
+ *  _Dual_ported_memory_Manager_initialization
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the initialization necessary for this manager.
+ */
+
+void _Dual_ported_memory_Manager_initialization(
+  unsigned32 maximum_ports
+);
+
+/*
+ *  rtems_port_create
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_port_create directive.  The port
+ *  will have the name name.  The port maps onto an area of dual ported
+ *  memory of length bytes which has internal_start and external_start
+ *  as the internal and external starting addresses, respectively.
+ *  It returns the id of the created port in ID.
+ */
+
+rtems_status_code rtems_port_create(
+  Objects_Name  name,
+  void         *internal_start,
+  void         *external_start,
+  unsigned32    length,
+  Objects_Id   *id
+);
+
+/*
+ *  rtems_port_ident
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_port_ident directive.  This directive
+ *  returns the port ID associated with name.  If more than one port is
+ *  named name, then the port to which the ID belongs is arbitrary.
+ */
+
+rtems_status_code rtems_port_ident(
+  Objects_Name  name,
+  Objects_Id   *id
+);
+
+/*
+ *  rtems_port_delete
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_port_delete directive.  It deletes
+ *  the port associated with ID.
+ */
+
+rtems_status_code rtems_port_delete(
+  Objects_Id id
+);
+
+/*
+ *  rtems_port_external_to_internal
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_port_external_to_internal directive.
+ *  It returns the internal port address which maps to the provided
+ *  external port address for the specified port ID.
+ */
+
+rtems_status_code rtems_port_external_to_internal(
+  Objects_Id   id,
+  void        *external,
+  void       **internal
+);
+
+/*
+ *  rtems_port_internal_to_external
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the Port_internal_to_external directive.
+ *  It returns the external port address which maps to the provided
+ *  internal port address for the specified port ID.
+ */
+
+rtems_status_code rtems_port_internal_to_external(
+  Objects_Id   id,
+  void        *internal,
+  void       **external
+);
+
+/*
+ *  _Dual_ported_memory_Allocate
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine allocates a port control block from the inactive chain
+ *  of free port control blocks.
+ */
+
+STATIC INLINE Dual_ported_memory_Control
+  *_Dual_ported_memory_Allocate ( void );
+
+/*
+ *  _Dual_ported_memory_Free
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine frees a port control block to the inactive chain
+ *  of free port control blocks.
+ */
+
+STATIC INLINE void _Dual_ported_memory_Free (
+   Dual_ported_memory_Control *the_port
+);
+
+/*
+ *  _Dual_ported_memory_Get
+ *
+ *  DESCRIPTION:
+ *
+ *  This function maps port IDs to port control blocks.  If ID
+ *  corresponds to a local port, then it returns the_port control
+ *  pointer which maps to ID and location is set to OBJECTS_LOCAL.
+ *  Global ports are not supported, thus if ID  does not map to a
+ *  local port, location is set to OBJECTS_ERROR and the_port is
+ *  undefined.
+ */
+
+STATIC INLINE Dual_ported_memory_Control *_Dual_ported_memory_Get (
+  Objects_Id         id,
+  Objects_Locations *location
+);
+
+/*
+ *  _Dual_ported_memory_Is_null
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_port is NULL and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Dual_ported_memory_Is_null(
+  Dual_ported_memory_Control *the_port
+);
+
+#include <rtems/dpmem.inl>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/headers/event.h

@@ -0,0 +1,158 @@
+/*  event.h
+ *
+ *  This include file contains the information pertaining to the Event
+ *  Manager.  This manager provides a high performance method of communication
+ *  and synchronization.
+ *
+ *  Directives provided are:
+ *
+ *     + send an event set to a task
+ *     + receive event condition
+ *
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_EVENT_h
+#define __RTEMS_EVENT_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/object.h>
+#include <rtems/options.h>
+#include <rtems/thread.h>
+#include <rtems/watchdog.h>
+#include <rtems/eventset.h>
+
+/*
+ *  This constant is passed as the event_in to the
+ *  rtems_event_receive directive to determine which events are pending.
+ */
+
+#define EVENT_CURRENT  0
+
+/*
+ *  _Event_Manager_initialization
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the initialization necessary for this manager.
+ */
+
+STATIC INLINE void _Event_Manager_initialization( void );
+
+/*
+ *  rtems_event_send
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_event_send directive.  It sends
+ *  event_in to the task specified by ID.  If the task is blocked
+ *  waiting to receive events and the posting of event_in satisfies
+ *  the task's event condition, then it is unblocked.
+ */
+
+rtems_status_code rtems_event_send (
+  Objects_Id         id,
+  rtems_event_set event_in
+);
+
+/*
+ *  rtems_event_receive
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_event_receive directive.  This
+ *  directive is invoked when the calling task wishes to receive
+ *  the event_in event condition.  One of the fields in the option_set
+ *  parameter determines whether the receive request is satisfied if
+ *  any or all of the events are pending.   If the event condition
+ *  is not satisfied immediately, then the task may block with an
+ *  optional timeout of TICKS clock ticks or return immediately.
+ *  This determination is based on another field in the option_set
+ *  parameter.  This directive returns the events received in the
+ *  event_out parameter.
+ */
+
+rtems_status_code rtems_event_receive (
+  rtems_event_set  event_in,
+  rtems_option     option_set,
+  rtems_interval   ticks,
+  rtems_event_set *event_out
+);
+
+/*
+ *  _Event_Seize
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine determines if the event condition event_in is
+ *  satisfied.  If so or if the no_wait option is enabled in option_set,
+ *  then the procedure returns immediately.  If neither of these
+ *  conditions is true, then the calling task is blocked with an
+ *  optional timeout of ticks clock ticks.
+ */
+
+void _Event_Seize (
+  rtems_event_set event_in,
+  rtems_option    option_set,
+  rtems_interval  ticks
+);
+
+/*
+ *  _Event_Surrender
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine determines if the event condition of the_thread
+ *  has been satisfied.  If so, it unblocks the_thread.
+ */
+
+void _Event_Surrender (
+  Thread_Control *the_thread
+);
+
+/*
+ *  _Event_Timeout
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked when a task's event receive request
+ *  has not been satisfied after the specified timeout interval.
+ *  The task represented by ID will be unblocked and its status
+ *  code will be set in it's control block to indicate that a timeout
+ *  has occurred.
+ */
+
+void _Event_Timeout (
+  Objects_Id  id,
+  void       *ignored
+);
+
+/*
+ *  The following defines the synchronization flag used by the
+ *  Event Manager to insure that signals sent to the currently
+ *  executing thread are received properly.
+ */
+
+EXTERN boolean _Event_Sync;    /* event manager sync flag */
+
+#include <rtems/event.inl>
+#include <rtems/eventmp.h>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/headers/eventmp.h

@@ -0,0 +1,147 @@
+/*  eventmp.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the Multiprocessing Support in the Event Manager.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_EVENT_MP_h
+#define __RTEMS_EVENT_MP_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/event.h>
+#include <rtems/mppkt.h>
+#include <rtems/object.h>
+#include <rtems/thread.h>
+#include <rtems/watchdog.h>
+
+/*
+ *  The following enumerated type defines the list of
+ *  remote event operations.
+ */
+
+typedef enum {
+  EVENT_MP_SEND_REQUEST  =  0,
+  EVENT_MP_SEND_RESPONSE =  1,
+}   Event_MP_Remote_operations;
+
+/*
+ *  The following data structure defines the packet used to perform
+ *  remote event operations.
+ */
+
+typedef struct {
+  rtems_packet_prefix           Prefix;
+  Event_MP_Remote_operations operation;
+  rtems_event_set         event_in;
+}   Event_MP_Packet;
+
+/*
+ *  _Event_MP_Send_process_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  process operation can be performed on another node.
+ *
+ *  This routine is not needed since there are no process
+ *  packets to be sent by this manager.
+ */
+
+/*
+ *  _Event_MP_Send_request_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  directive operation can be initiated on another node.
+ */
+
+rtems_status_code _Event_MP_Send_request_packet (
+  Event_MP_Remote_operations operation,
+  Objects_Id                 event_id,
+  rtems_event_set         event_in
+);
+
+/*
+ *  _Event_MP_Send_response_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  directive can be performed on another node.
+ */
+
+void _Event_MP_Send_response_packet (
+  Event_MP_Remote_operations  operation,
+  Thread_Control             *the_thread
+);
+
+/*
+ *
+ *  _Event_MP_Process_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the actions specific to this package for
+ *  the request from another node.
+ */
+
+void _Event_MP_Process_packet (
+  rtems_packet_prefix *the_packet_prefix
+);
+
+/*
+ *  _Event_MP_Send_object_was_deleted
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked indirectly by the thread queue
+ *  when a proxy has been removed from the thread queue and
+ *  the remote node must be informed of this.
+ *
+ *  This routine is not needed since there are no objects
+ *  deleted by this manager.
+ */
+
+/*
+ *  _Event_MP_Send_extract_proxy
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked when a task is deleted and it
+ *  has a proxy which must be removed from a thread queue and
+ *  the remote node must be informed of this.
+ *
+ *  This routine is not needed since there are no objects
+ *  deleted by this manager.
+ */
+
+/*
+ *  _Event_MP_Get_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This function is used to obtain a event mp packet.
+ */
+
+Event_MP_Packet *_Event_MP_Get_packet ( void );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of file */

c/src/exec/rtems/headers/eventset.h

@@ -0,0 +1,142 @@
+/*  eventset.h
+ *
+ *  This include file contains the information pertaining to the
+ *  Event Sets Handler.  This handler provides methods for the manipulation
+ *  of event sets which will be sent and received by tasks.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_EVENT_SET_h
+#define __RTEMS_EVENT_SET_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ *  The following defines the type used to control event sets.
+ */
+
+typedef unsigned32 rtems_event_set;
+
+/*
+ *  The following constants define the individual events which may
+ *  be used to compose an event set.
+ */
+
+#define RTEMS_PENDING_EVENTS      0           /* receive pending events   */
+#define RTEMS_ALL_EVENTS  0xFFFFFFFF
+
+#define RTEMS_EVENT_0     0x00000001
+#define RTEMS_EVENT_1     0x00000002
+#define RTEMS_EVENT_2     0x00000004
+#define RTEMS_EVENT_3     0x00000008
+#define RTEMS_EVENT_4     0x00000010
+#define RTEMS_EVENT_5     0x00000020
+#define RTEMS_EVENT_6     0x00000040
+#define RTEMS_EVENT_7     0x00000080
+#define RTEMS_EVENT_8     0x00000100
+#define RTEMS_EVENT_9     0x00000200
+#define RTEMS_EVENT_10    0x00000400
+#define RTEMS_EVENT_11    0x00000800
+#define RTEMS_EVENT_12    0x00001000
+#define RTEMS_EVENT_13    0x00002000
+#define RTEMS_EVENT_14    0x00004000
+#define RTEMS_EVENT_15    0x00008000
+#define RTEMS_EVENT_16    0x00010000
+#define RTEMS_EVENT_17    0x00020000
+#define RTEMS_EVENT_18    0x00040000
+#define RTEMS_EVENT_19    0x00080000
+#define RTEMS_EVENT_20    0x00100000
+#define RTEMS_EVENT_21    0x00200000
+#define RTEMS_EVENT_22    0x00400000
+#define RTEMS_EVENT_23    0x00800000
+#define RTEMS_EVENT_24    0x01000000
+#define RTEMS_EVENT_25    0x02000000
+#define RTEMS_EVENT_26    0x04000000
+#define RTEMS_EVENT_27    0x08000000
+#define RTEMS_EVENT_28    0x10000000
+#define RTEMS_EVENT_29    0x20000000
+#define RTEMS_EVENT_30    0x40000000
+#define RTEMS_EVENT_31    0x80000000
+
+
+/*
+ *  The following constant is the value of an event set which
+ *  has no events pending.
+ */
+
+#define EVENT_SETS_NONE_PENDING 0
+
+/*
+ *  _Event_sets_Is_empty
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if on events are posted in the event_set,
+ *  and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Event_sets_Is_empty(
+  rtems_event_set the_event_set
+);
+
+/*
+ *  _Event_sets_Post
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine posts the given new_events into the event_set
+ *  passed in.  The result is returned to the user in event_set.
+ */
+
+STATIC INLINE void _Event_sets_Post(
+  rtems_event_set  the_new_events,
+  rtems_event_set *the_event_set
+);
+
+/*
+ *  _Event_sets_Get
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns the events in event_condition which are
+ *  set in event_set.
+ */
+
+STATIC INLINE rtems_event_set _Event_sets_Get(
+  rtems_event_set the_event_set,
+  rtems_event_set the_event_condition
+);
+
+/*
+ *  _Event_sets_Clear
+ *
+ *  DESCRIPTION:
+ *
+ *  This function removes the events in mask from the event_set
+ *  passed in.  The result is returned to the user in event_set.
+ */
+
+STATIC INLINE rtems_event_set _Event_sets_Clear(
+ rtems_event_set the_event_set,
+ rtems_event_set the_mask
+);
+
+#include <rtems/eventset.inl>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/headers/intr.h

@@ -0,0 +1,125 @@
+/*  intr.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the Interrupt Manager.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_INTERRUPT_h
+#define __RTEMS_INTERRUPT_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/isr.h>
+
+/*
+ *  Interrupt level type
+ */
+
+typedef ISR_Level rtems_interrupt_level;
+
+/*
+ *  _Interrupt_Manager_initialization
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine initializes the interrupt manager.
+ *
+ */
+
+void _Interrupt_Manager_initialization( void );
+
+/*
+ *  rtems_interrupt_catch
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_interrupt_catch directive.  This
+ *  directive installs new_isr_handler as the RTEMS interrupt service
+ *  routine for vector.  The previous RTEMS interrupt service
+ *  routine is returned in old_isr_handler.
+ */
+
+rtems_status_code rtems_interrupt_catch(
+  rtems_isr_entry    new_isr_handler,
+  rtems_vector_number  vector,
+  rtems_isr_entry   *old_isr_handler
+);
+
+/*
+ *  rtems_interrupt_disable
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine disables all maskable interrupts and returns the
+ *  previous level in _isr_cookie.
+ */
+
+#define rtems_interrupt_disable( _isr_cookie ) \
+    _ISR_Disable(_isr_cookie)
+        
+/*
+ *  rtems_interrupt_enable
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine enables maskable interrupts to the level indicated
+ *  _isr_cookie.
+ */
+
+#define rtems_interrupt_enable( _isr_cookie ) \
+    _ISR_Enable(_isr_cookie)
+        
+/*
+ *  rtems_interrupt_flash
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine temporarily enables maskable interrupts to the
+ *  level in _isr_cookie before redisabling them.
+ */
+
+#define rtems_interrupt_flash( _isr_cookie ) \
+    _ISR_Flash(_isr_cookie)
+
+/*
+ *  rtems_interrupt_cause
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine generates an interrupt.
+ *
+ *  NOTE:  No implementation.
+ */
+
+#define rtems_interrupt_cause( _interrupt_to_cause )
+
+/*
+ *  rtems_interrupt_cause
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine clears the specified interrupt.
+ *
+ *  NOTE:  No implementation.
+ */
+
+#define rtems_interrupt_clear( _interrupt_to_clear )
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/headers/message.h

@@ -0,0 +1,461 @@
+/*  message.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the Message Queue Manager.  This manager provides a mechanism for
+ *  communication and synchronization between tasks using messages.
+ *
+ *  Directives provided are:
+ *
+ *     + create a queue
+ *     + get ID of a queue
+ *     + delete a queue
+ *     + put a message at the rear of a queue
+ *     + put a message at the front of a queue
+ *     + broadcast N messages to a queue
+ *     + receive message from a queue
+ *     + flush all messages on a queue
+ *
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_MESSAGE_QUEUE_h
+#define __RTEMS_MESSAGE_QUEUE_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/chain.h>
+#include <rtems/object.h>
+#include <rtems/threadq.h>
+
+/*
+ *  The following defines the data types needed to manipulate
+ *  the contents of message buffers.
+ */
+
+typedef struct {
+  unsigned32 field1;
+  unsigned32 field2;
+  unsigned32 field3;
+  unsigned32 field4;
+}  Message_queue_Buffer;
+
+/*
+ *  The following records define the organization of a message
+ *  buffer.
+ */
+
+typedef struct {
+  Chain_Node           Node;
+  Message_queue_Buffer Contents;
+}   Message_queue_Buffer_control;
+
+/*
+ *  The following records define the control block used to manage
+ *  each message queue.
+ */
+
+typedef struct {
+  Objects_Control      Object;
+  Thread_queue_Control Wait_queue;
+  rtems_attribute   attribute_set;
+  unsigned32           maximum_pending_messages;
+  unsigned32           number_of_pending_messages;
+  Chain_Control        Pending_messages;
+}   Message_queue_Control;
+
+/*
+ *  The following defines the information control block used to
+ *  manage this class of objects.
+ */
+
+EXTERN Objects_Information  _Message_queue_Information;
+
+/*
+ *  The following defines the data structures used to
+ *  manage the pool of inactive message buffers.
+ */
+
+EXTERN Chain_Control _Message_queue_Inactive_messages;
+
+/*
+ *  The following enumerated type details the modes in which a message
+ *  may be submitted to a message queue.  The message may be posted
+ *  in a send or urgent fashion.
+ */
+
+typedef enum {
+  MESSAGE_QUEUE_SEND_REQUEST   = 0,
+  MESSAGE_QUEUE_URGENT_REQUEST = 1
+}  Message_queue_Submit_types;
+
+/*
+ *  _Message_queue_Manager_initialization
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the initialization necessary for this manager.
+ */
+
+void _Message_queue_Manager_initialization(
+  unsigned32 maximum_message_queues,
+  unsigned32 maximum_messages
+);
+
+/*
+ *  rtems_message_queue_create
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_message_queue_create directive.  The
+ *  message queue will have the name name.  If the attribute_set indicates
+ *  that the message queue is to be limited in the number of messages
+ *  that can be outstanding, then count indicates the maximum number of
+ *  messages that will be held.  It returns the id of the created
+ *  message queue in ID.
+ */
+
+rtems_status_code rtems_message_queue_create(
+  Objects_Name        name,
+  unsigned32          count,
+  rtems_attribute  attribute_set,
+  Objects_Id         *id
+);
+
+/*
+ *  rtems_message_queue_ident
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_message_queue_ident directive.
+ *  This directive returns the message queue ID associated with NAME.
+ *  If more than one message queue is named name, then the message
+ *  queue to which the ID belongs is arbitrary.  node indicates the
+ *  extent of the search for the ID of the message queue named name.
+ *  The search can be limited to a particular node or allowed to
+ *  encompass all nodes.
+ */
+
+rtems_status_code rtems_message_queue_ident(
+  Objects_Name  name,
+  unsigned32    node,
+  Objects_Id   *id
+);
+
+/*
+ *  rtems_message_queue_delete
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_message_queue_delete directive.  The
+ *  message queue indicated by ID is deleted.
+ */
+
+rtems_status_code rtems_message_queue_delete(
+  Objects_Id id
+);
+
+/*
+ *  rtems_message_queue_send
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_message_queue_send directive.
+ *  This directive sends the message buffer to the message queue
+ *  indicated by ID.  If one or more tasks is blocked waiting
+ *  to receive a message from this message queue, then one will
+ *  receive the message.  The task selected to receive the
+ *  message is based on the task queue discipline algorithm in
+ *  use by this particular message queue.  If no tasks are waiting,
+ *  then the message buffer will be placed at the rear of the
+ *  chain of pending messages for this message queue.
+ */
+
+rtems_status_code rtems_message_queue_send(
+  Objects_Id            id,
+  void                 *buffer
+);
+
+/*
+ *  rtems_message_queue_urgent
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_message_queue_send directive.
+ *  This directive sends the message buffer to the message queue
+ *  indicated by ID.  If one or more tasks is blocked waiting
+ *  to receive a message from this message queue, then one will
+ *  receive the message.  The task selected to receive the
+ *  message is based on the task queue discipline algorithm in
+ *  use by this particular message queue.  If no tasks are waiting,
+ *  then the message buffer will be placed at the rear of the
+ *  chain of pending messages for this message queue.
+ */
+
+rtems_status_code rtems_message_queue_urgent(
+  Objects_Id            id,
+  void                 *buffer
+);
+
+/*
+ *  rtems_message_queue_broadcast
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_message_queue_send directive.
+ *  This directive sends the message buffer to the message queue
+ *  indicated by ID.  If one or more tasks is blocked waiting
+ *  to receive a message from this message queue, then one will
+ *  receive the message.  The task selected to receive the
+ *  message is based on the task queue discipline algorithm in
+ *  use by this particular message queue.  If no tasks are waiting,
+ *  then the message buffer will be placed at the rear of the
+ *  chain of pending messages for this message queue.
+ */
+
+rtems_status_code rtems_message_queue_broadcast(
+  Objects_Id            id,
+  void                 *buffer,
+  unsigned32           *count
+);
+
+/*
+ *  rtems_message_queue_receive
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_message_queue_receive directive.
+ *  This directive is invoked when the calling task wishes to receive
+ *  a message from the message queue indicated by ID.  The received
+ *  message is to be placed in buffer.  If no messages are outstanding
+ *  and the option_set indicates that the task is willing to block,
+ *  then the task will be blocked until a message arrives or until,
+ *  optionally, timeout clock ticks have passed.
+ */
+
+rtems_status_code rtems_message_queue_receive(
+  Objects_Id            id,
+  void                 *buffer,
+  unsigned32            option_set,
+  rtems_interval     timeout
+);
+
+/*
+ *  rtems_message_queue_flush
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_message_queue_flush directive.
+ *  This directive takes all outstanding messages for the message
+ *  queue indicated by ID and returns them to the inactive message
+ *  chain.  The number of messages flushed is returned in COUNT.
+ */
+
+rtems_status_code rtems_message_queue_flush(
+  Objects_Id  id,
+  unsigned32 *count
+);
+
+/*
+ *  _Message_queue_Copy_buffer
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine copies the contents of the source message buffer
+ *  to the destination message buffer.
+ */
+
+STATIC INLINE void _Message_queue_Copy_buffer (
+  Message_queue_Buffer *source,
+  Message_queue_Buffer *destination
+);
+
+/*
+ *  _Message_queue_Seize
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine attempts to receive a message from the_message_queue.
+ *  If a message is available or if the RTEMS_NO_WAIT option is enabled in
+ *  option_set, then the routine returns.  Otherwise, the calling task
+ *  is blocked until a message is available.  If a message is returned
+ *  to the task, then buffer will contain its contents.
+ */
+
+boolean _Message_queue_Seize(
+  Message_queue_Control *the_message_queue,
+  unsigned32             option_set,
+  Message_queue_Buffer  *buffer
+);
+
+/*
+ *  _Message_queue_Flush_support
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine flushes all outstanding messages and returns
+ *  them to the inactive message chain.
+ */
+
+unsigned32 _Message_queue_Flush_support(
+  Message_queue_Control *the_message_queue
+);
+
+/*
+ *  _Message_queue_Submit
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine provides the common foundation for the
+ *  rtems_message_queue_send and rtems_message_queue_urgent directives.
+ */
+
+rtems_status_code _Message_queue_Submit(
+  Objects_Id                  id,
+  Message_queue_Buffer       *buffer,
+  Message_queue_Submit_types  submit_type
+);
+
+/*
+ *  _Message_queue_Allocate_message_buffer
+ *
+ *  DESCRIPTION:
+ *
+ *  This function allocates a message buffer from the inactive
+ *  message buffer chain.
+ */
+
+STATIC INLINE Message_queue_Buffer_control *
+  _Message_queue_Allocate_message_buffer ( void );
+
+/*
+ *  _Message_queue_Free_message_buffer
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine frees a message buffer to the inactive
+ *  message buffer chain.
+ */
+
+STATIC INLINE void _Message_queue_Free_message_buffer (
+  Message_queue_Buffer_control *the_message
+);
+
+/*
+ *  _Message_queue_Get_pending_message
+ *
+ *  DESCRIPTION:
+ *
+ *  This function removes the first message from the_message_queue
+ *  and returns a pointer to it.
+ */
+
+STATIC INLINE
+  Message_queue_Buffer_control *_Message_queue_Get_pending_message (
+  Message_queue_Control *the_message_queue
+);
+
+/*
+ *  _Message_queue_Append
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine places the_message at the rear of the outstanding
+ *  messages on the_message_queue.
+ */
+
+STATIC INLINE void _Message_queue_Append (
+  Message_queue_Control        *the_message_queue,
+  Message_queue_Buffer_control *the_message
+);
+
+/*
+ *  _Message_queue_Prepend
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine places the_message at the rear of the outstanding
+ *  messages on the_message_queue.
+ */
+
+STATIC INLINE void _Message_queue_Prepend (
+  Message_queue_Control        *the_message_queue,
+  Message_queue_Buffer_control *the_message
+);
+
+/*
+ *  _Message_queue_Is_null
+ *
+ *  DESCRIPTION:
+ *
+ *  This function places the_message at the rear of the outstanding
+ *  messages on the_message_queue.
+ */
+
+STATIC INLINE boolean _Message_queue_Is_null (
+  Message_queue_Control *the_message_queue
+);
+
+/*
+ *  _Message_queue_Allocate
+ *
+ *  DESCRIPTION:
+ *
+ *  This function allocates a message queue control block from
+ *  the inactive chain of free message queue control blocks.
+ */
+
+STATIC INLINE Message_queue_Control *_Message_queue_Allocate ( void );
+
+/*
+ *  _Message_queue_Free
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine allocates a message queue control block from
+ *  the inactive chain of free message queue control blocks.
+ */
+
+STATIC INLINE void _Message_queue_Free (
+  Message_queue_Control *the_message_queue
+);
+
+/*
+ *  _Message_queue_Get
+ *
+ *  DESCRIPTION:
+ *
+ *  This function maps message queue IDs to message queue control
+ *  blocks.  If ID corresponds to a local message queue, then it
+ *  returns the_message_queue control pointer which maps to ID
+ *  and location is set to OBJECTS_LOCAL.  If the message queue ID is
+ *  global and resides on a remote node, then location is set
+ *  to OBJECTS_REMOTE, and the_message_queue is undefined.
+ *  Otherwise, location is set to OBJECTS_ERROR and
+ *  the_message_queue is undefined.
+ */
+
+STATIC INLINE Message_queue_Control *_Message_queue_Get (
+  Objects_Id         id,
+  Objects_Locations *location
+);
+
+#include <rtems/message.inl>
+#include <rtems/msgmp.h>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/headers/modes.h

@@ -0,0 +1,183 @@
+/*  modes.h
+ *
+ *  This include file contains all constants and structures associated
+ *  with the RTEMS thread and RTEMS_ASR modes.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_MODES_h
+#define __RTEMS_MODES_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/isr.h>
+
+/*
+ *  The following type defines the control block used to manage
+ *  each a mode set.
+ */
+
+typedef unsigned32 rtems_mode;
+
+/*
+ *  The following constants define the individual modes and masks
+ *  which may be used to compose a mode set and to alter modes.
+ */
+
+#define RTEMS_ALL_MODE_MASKS     0x0000ffff
+
+#define RTEMS_DEFAULT_MODES     0x00000000
+#define RTEMS_CURRENT_MODE      0
+
+#define RTEMS_PREEMPT_MASK    0x00000100  /* preemption bit           */
+#define RTEMS_TIMESLICE_MASK  0x00000200  /* timeslice bit            */
+#define RTEMS_ASR_MASK        0x00000400  /* RTEMS_ASR enable bit           */
+#define RTEMS_INTERRUPT_MASK  CPU_MODES_INTERRUPT_MASK
+
+#define RTEMS_PREEMPT      0x00000000     /* enable preemption        */
+#define RTEMS_NO_PREEMPT   0x00000100     /* disable preemption       */
+
+#define RTEMS_NO_TIMESLICE 0x00000000     /* disable timeslicing      */
+#define RTEMS_TIMESLICE    0x00000200     /* enable timeslicing       */
+
+#define RTEMS_ASR          0x00000000     /* enable RTEMS_ASR               */
+#define RTEMS_NO_ASR       0x00000400     /* disable RTEMS_ASR              */
+
+/*
+ *  The number of bits for interrupt levels is CPU dependent.
+ *  RTEMS supports 0 to 256 levels in bits 0-7 of the mode.
+ */
+
+/*
+ *  RTEMS_INTERRUPT_LEVEL
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns the processor dependent interrupt
+ *  level which corresponds to the requested interrupt level.
+ *
+ * NOTE: RTEMS supports 256 interrupt levels using the least
+ *       significant eight bits of MODES.CONTROL.  On any
+ *       particular CPU, fewer than 256 levels may be supported.
+ */
+
+STATIC INLINE unsigned32 RTEMS_INTERRUPT_LEVEL (
+  rtems_mode mode_set
+);
+
+/*
+ *  _Modes_Mask_changed
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if any of the mode flags in mask
+ *  are set in mode_set, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Modes_Mask_changed (
+  rtems_mode mode_set,
+  rtems_mode masks
+);
+
+/*
+ *  _Modes_Is_asr_disabled
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if mode_set indicates that Asynchronous
+ *  Signal Processing is disabled, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Modes_Is_asr_disabled (
+  rtems_mode mode_set
+);
+
+/*
+ *  _Modes_Is_preempt
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if mode_set indicates that preemption
+ *  is enabled, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Modes_Is_preempt (
+  rtems_mode mode_set
+);
+
+/*
+ *  _Modes_Is_timeslice
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if mode_set indicates that timeslicing
+ *  is enabled, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Modes_Is_timeslice (
+  rtems_mode mode_set
+);
+
+/*
+ *  _Modes_Get_interrupt_level
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns the interrupt level portion of the mode_set.
+ */
+
+STATIC INLINE ISR_Level _Modes_Get_interrupt_level (
+  rtems_mode mode_set
+);
+
+/*
+ *  _Modes_Set_interrupt_level
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine sets the current interrupt level to that specified
+ *  in the mode_set.
+ */
+
+STATIC INLINE void _Modes_Set_interrupt_level (
+  rtems_mode mode_set
+);
+
+/*
+ *  _Modes_Change
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine changes the modes in old_mode_set indicated by
+ *  mask to the requested values in new_mode_set.  The resulting
+ *  mode set is returned in out_mode_set and the modes that changed
+ *  is returned in changed.
+ */
+
+STATIC INLINE void _Modes_Change (
+  rtems_mode  old_mode_set,
+  rtems_mode  new_mode_set,
+  rtems_mode  mask,
+  rtems_mode *out_mode_set,
+  rtems_mode *changed
+);
+
+#include <rtems/modes.inl>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/headers/mp.h

@@ -0,0 +1,67 @@
+/*  mp.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the Multiprocessing Manager.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_MP_h
+#define __RTEMS_MP_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ *
+ *  _Multiprocessing_Manager_initialization
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the initialization necessary for this manager.
+ */
+
+void _Multiprocessing_Manager_initialization ( void );
+
+/*
+ *
+ *  rtems_multiprocessing_announce
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the MULTIPROCESSING_ANNOUNCE directive.
+ *  It is invoked by the MPCI layer to indicate that an MPCI packet
+ *  has been received.
+ */
+
+void rtems_multiprocessing_announce ( void );
+
+/*
+ *
+ *  _Multiprocessing_Receive_server
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is a server thread which processes remote requests
+ *  from other nodes.
+ */
+
+Thread _Multiprocessing_Receive_server (
+  Thread_Argument ignored
+);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/*  end of include file */

c/src/exec/rtems/headers/msgmp.h

@@ -0,0 +1,175 @@
+/*  msgmp.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the Multiprocessing Support in the Message Manager.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_MESSAGE_QUEUE_MP_h
+#define __RTEMS_MESSAGE_QUEUE_MP_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/message.h>
+#include <rtems/mppkt.h>
+#include <rtems/object.h>
+#include <rtems/options.h>
+#include <rtems/thread.h>
+#include <rtems/watchdog.h>
+
+/*
+ *  The following enumerated type defines the list of
+ *  remote message queue operations.
+ */
+
+typedef enum {
+  MESSAGE_QUEUE_MP_ANNOUNCE_CREATE     =  0,
+  MESSAGE_QUEUE_MP_ANNOUNCE_DELETE     =  1,
+  MESSAGE_QUEUE_MP_EXTRACT_PROXY       =  2,
+  MESSAGE_QUEUE_MP_RECEIVE_REQUEST     =  3,
+  MESSAGE_QUEUE_MP_RECEIVE_RESPONSE    =  4,
+  MESSAGE_QUEUE_MP_SEND_REQUEST        =  5,
+  MESSAGE_QUEUE_MP_SEND_RESPONSE       =  6,
+  MESSAGE_QUEUE_MP_URGENT_REQUEST      =  7,
+  MESSAGE_QUEUE_MP_URGENT_RESPONSE     =  8,
+  MESSAGE_QUEUE_MP_BROADCAST_REQUEST   =  9,
+  MESSAGE_QUEUE_MP_BROADCAST_RESPONSE  = 10,
+  MESSAGE_QUEUE_MP_FLUSH_REQUEST       = 11,
+  MESSAGE_QUEUE_MP_FLUSH_RESPONSE      = 12
+}   Message_queue_MP_Remote_operations;
+
+/*
+ *  The following data structure defines the packet used to perform
+ *  remote message queue operations.
+ */
+
+typedef struct {
+  rtems_packet_prefix                   Prefix;
+  Message_queue_MP_Remote_operations operation;
+  Objects_Name                       name;
+  rtems_option                    option_set;
+  Objects_Id                         proxy_id;
+  unsigned32                         count;
+  unsigned32                         pad0;
+  unsigned32                         pad1;
+  unsigned32                         pad2;
+  Message_queue_Buffer               Buffer;
+}   Message_queue_MP_Packet;
+
+/*
+ *  _Message_queue_MP_Send_process_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  process operation can be performed on another node.
+ */
+
+void _Message_queue_MP_Send_process_packet (
+  Message_queue_MP_Remote_operations operation,
+  Objects_Id                         message_queue_id,
+  Objects_Name                       name,
+  Objects_Id                         proxy_id
+);
+
+/*
+ *  _Message_queue_MP_Send_request_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  directive operation can be initiated on another node.
+ */
+
+rtems_status_code _Message_queue_MP_Send_request_packet (
+  Message_queue_MP_Remote_operations  operation,
+  Objects_Id                          message_queue_id,
+  Message_queue_Buffer               *buffer,
+  rtems_option                     option_set,
+  rtems_interval                   timeout
+);
+
+/*
+ *  _Message_queue_MP_Send_response_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  directive can be performed on another node.
+ */
+
+void _Message_queue_MP_Send_response_packet (
+  Message_queue_MP_Remote_operations  operation,
+  Objects_Id                          message_queue_id,
+  Thread_Control                     *the_thread
+);
+
+/*
+ *
+ *  _Message_queue_MP_Process_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the actions specific to this package for
+ *  the request from another node.
+ */
+
+void _Message_queue_MP_Process_packet (
+  rtems_packet_prefix *the_packet_prefix
+);
+
+/*
+ *  _Message_queue_MP_Send_object_was_deleted
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked indirectly by the thread queue
+ *  when a proxy has been removed from the thread queue and
+ *  the remote node must be informed of this.
+ */
+
+void _Message_queue_MP_Send_object_was_deleted (
+  Thread_Control *the_proxy
+);
+
+/*
+ *  _Message_queue_MP_Send_extract_proxy
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked when a task is deleted and it
+ *  has a proxy which must be removed from a thread queue and
+ *  the remote node must be informed of this.
+ */
+
+void _Message_queue_MP_Send_extract_proxy (
+  Thread_Control *the_thread
+);
+
+/*
+ *  _Message_queue_MP_Get_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This function is used to obtain a message queue mp packet.
+ */
+
+Message_queue_MP_Packet *_Message_queue_MP_Get_packet ( void );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of file */

c/src/exec/rtems/headers/options.h

@@ -0,0 +1,79 @@
+/*  options.h
+ *
+ *  This include file contains information which defines the
+ *  options available on many directives.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_OPTIONS_h
+#define __RTEMS_OPTIONS_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ *  The following type defines the control block used to manage
+ *  option sets.
+ */
+
+typedef unsigned32 rtems_option;
+
+/*
+ *  The following constants define the individual options which may
+ *  be used to compose an option set.
+ */
+
+#define RTEMS_DEFAULT_OPTIONS   0x00000000
+
+#define RTEMS_WAIT      0x00000000        /* wait on resource */
+#define RTEMS_NO_WAIT   0x00000001        /* do not wait on resource */
+
+#define RTEMS_EVENT_ALL 0x00000000        /* wait for all events */
+#define RTEMS_EVENT_ANY 0x00000002        /* wait on any event */
+
+/*
+ *  _Options_Is_no_wait
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the RTEMS_NO_WAIT option is enabled in
+ *  option_set, and FALSE otherwise.
+ *
+ */
+
+STATIC INLINE boolean _Options_Is_no_wait (
+  rtems_option option_set
+);
+
+/*
+ *  _Options_Is_any
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the RTEMS_EVENT_ANY option is enabled in
+ *  OPTION_SET, and FALSE otherwise.
+ *
+ */
+
+STATIC INLINE boolean _Options_Is_any (
+  rtems_option option_set
+);
+
+#include <rtems/options.inl>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/headers/part.h

@@ -0,0 +1,290 @@
+/*  partition.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the Partition Manager.  This manager provides facilities to
+ *  dynamically allocate memory in fixed-sized units which are returned
+ *  as buffers.
+ *
+ *  Directives provided are:
+ *
+ *     + create a partition
+ *     + get an ID of a partition
+ *     + delete a partition
+ *     + get a buffer from a partition
+ *     + return a buffer to a partition
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_PARTITION_h
+#define __RTEMS_PARTITION_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/address.h>
+#include <rtems/attr.h>
+#include <rtems/object.h>
+
+/*
+ *  The following defines the control block used to manage each partition.
+ */
+
+typedef struct {
+  Objects_Control     Object;
+  void               *starting_address;      /* physical address */
+  unsigned32          length;                /* in bytes */
+  unsigned32          buffer_size;           /* in bytes */
+  rtems_attribute  attribute_set;         /* attributes */
+  unsigned32          number_of_used_blocks; /* or allocated buffers */
+  Chain_Control       Memory;                /* buffer chain */
+}   Partition_Control;
+
+/*
+ *  The following defines the information control block used to
+ *  manage this class of objects.
+ */
+
+EXTERN Objects_Information _Partition_Information;
+
+/*
+ *  _Partition_Manager_initialization
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the initialization necessary for this manager.
+ */
+
+void _Partition_Manager_initialization(
+  unsigned32 maximum_partitions
+);
+
+/*
+ *  rtems_partition_create
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_partition_create directive.  The
+ *  partition will have the name name.  The memory area managed by
+ *  the partition is of length bytes and starts at starting_address.
+ *  The memory area will be divided into as many buffers of
+ *  buffer_size bytes as possible.   The attribute_set determines if
+ *  the partition is global or local.  It returns the id of the
+ *  created partition in ID.
+ */
+
+rtems_status_code rtems_partition_create(
+  Objects_Name        name,
+  void               *starting_address,
+  unsigned32          length,
+  unsigned32          buffer_size,
+  rtems_attribute  attribute_set,
+  Objects_Id         *id
+);
+
+/*
+ *  rtems_partition_ident
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_partition_ident directive.
+ *  This directive returns the partition ID associated with name.
+ *  If more than one partition is named name, then the partition
+ *  to which the ID belongs is arbitrary.  node indicates the
+ *  extent of the search for the ID of the partition named name.
+ *  The search can be limited to a particular node or allowed to
+ *  encompass all nodes.
+ */
+
+rtems_status_code rtems_partition_ident(
+  Objects_Name  name,
+  unsigned32    node,
+  Objects_Id   *id
+);
+
+/*
+ *  rtems_partition_delete
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_partition_delete directive.  The
+ *  partition indicated by ID is deleted.
+ */
+
+rtems_status_code rtems_partition_delete(
+  Objects_Id id
+);
+
+/*
+ *  rtems_partition_get_buffer
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_partition_get_buffer directive.  It
+ *  attempts to allocate a buffer from the partition associated with ID.
+ *  If a buffer is allocated, its address is returned in buffer.
+ */
+
+rtems_status_code rtems_partition_get_buffer(
+  Objects_Id  id,
+  void       **buffer
+);
+
+/*
+ *  rtems_partition_return_buffer
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_partition_return_buffer directive.  It
+ *  frees the buffer to the partition associated with ID.  The buffer must
+ *  have been previously allocated from the same partition.
+ */
+
+rtems_status_code rtems_partition_return_buffer(
+  Objects_Id  id,
+  void       *buffer
+);
+
+/*
+ *  _Partition_Allocate_buffer
+ *
+ *  DESCRIPTION:
+ *
+ *  This function attempts to allocate a buffer from the_partition.
+ *  If successful, it returns the address of the allocated buffer.
+ *  Otherwise, it returns NULL.
+ */
+
+STATIC INLINE void *_Partition_Allocate_buffer (
+   Partition_Control *the_partition
+);
+
+/*
+ *  _Partition_Free_buffer
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine frees the_buffer to the_partition.
+ */
+
+STATIC INLINE void _Partition_Free_buffer (
+  Partition_Control *the_partition,
+  Chain_Node        *the_buffer
+);
+
+/*
+ *  _Partition_Is_buffer_on_boundary
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_buffer is on a valid buffer
+ *  boundary for the_partition, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Partition_Is_buffer_on_boundary (
+  void              *the_buffer,
+  Partition_Control *the_partition
+);
+
+/*
+ *  _Partition_Is_buffer_valid
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_buffer is a valid buffer from
+ *  the_partition, otherwise FALSE is returned.
+ */
+
+STATIC INLINE boolean _Partition_Is_buffer_valid (
+  Chain_Node        *the_buffer,
+  Partition_Control *the_partition
+);
+
+/*
+ *  _Partition_Is_buffer_size_aligned
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the use of the specified buffer_size
+ *  will result in the allocation of buffers whose first byte is
+ *  properly aligned, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Partition_Is_buffer_size_aligned (
+  unsigned32 buffer_size
+);
+
+/*
+ *  _Partition_Allocate
+ *
+ *  DESCRIPTION:
+ *
+ *  This function allocates a partition control block from
+ *  the inactive chain of free partition control blocks.
+ */
+
+STATIC INLINE Partition_Control *_Partition_Allocate ( void );
+
+/*
+ *  _Partition_Free
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine frees a partition control block to the
+ *  inactive chain of free partition control blocks.
+ */
+
+STATIC INLINE void _Partition_Free (
+  Partition_Control *the_partition
+);
+
+/*
+ *  _Partition_Get
+ *
+ *  DESCRIPTION:
+ *
+ *  This function maps partition IDs to partition control blocks.
+ *  If ID corresponds to a local partition, then it returns
+ *  the_partition control pointer which maps to ID and location
+ *  is set to OBJECTS_LOCAL.  If the partition ID is global and
+ *  resides on a remote node, then location is set to OBJECTS_REMOTE,
+ *  and the_partition is undefined.  Otherwise, location is set
+ *  to OBJECTS_ERROR and the_partition is undefined.
+ */
+
+STATIC INLINE Partition_Control *_Partition_Get (
+  Objects_Id         id,
+  Objects_Locations *location
+);
+
+/*
+ *  _Partition_Is_null
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_partition is NULL
+ *  and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Partition_Is_null (
+  Partition_Control *the_partition
+);
+
+#include <rtems/part.inl>
+#include <rtems/partmp.h>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/headers/partmp.h

@@ -0,0 +1,160 @@
+/*  partmp.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the Multiprocessing Support in the Partition Manager.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_PARTITION_MP_h
+#define __RTEMS_PARTITION_MP_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/mppkt.h>
+#include <rtems/object.h>
+#include <rtems/options.h>
+#include <rtems/part.h>
+#include <rtems/thread.h>
+
+/*
+ *  The following enumerated type defines the list of
+ *  remote partition operations.
+ */
+
+typedef enum {
+  PARTITION_MP_ANNOUNCE_CREATE        =  0,
+  PARTITION_MP_ANNOUNCE_DELETE        =  1,
+  PARTITION_MP_EXTRACT_PROXY          =  2,
+  PARTITION_MP_GET_BUFFER_REQUEST     =  3,
+  PARTITION_MP_GET_BUFFER_RESPONSE    =  4,
+  PARTITION_MP_RETURN_BUFFER_REQUEST  =  5,
+  PARTITION_MP_RETURN_BUFFER_RESPONSE =  6,
+}   Partition_MP_Remote_operations;
+
+/*
+ *  The following data structure defines the packet used to perform
+ *  remote partition operations.
+ */
+
+typedef struct {
+  rtems_packet_prefix                Prefix;
+  Partition_MP_Remote_operations  operation;
+  Objects_Name                    name;
+  void                           *buffer;
+  Objects_Id                      proxy_id;
+}   Partition_MP_Packet;
+
+/*
+ *  _Partition_MP_Send_process_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  process operation can be performed on another node.
+ */
+
+void _Partition_MP_Send_process_packet (
+  Partition_MP_Remote_operations operation,
+  Objects_Id                     partition_id,
+  Objects_Name                   name,
+  Objects_Id                     proxy_id
+);
+
+/*
+ *  _Partition_MP_Send_request_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  directive operation can be initiated on another node.
+ */
+
+rtems_status_code _Partition_MP_Send_request_packet (
+  Partition_MP_Remote_operations  operation,
+  Objects_Id                      partition_id,
+  void                           *buffer
+);
+
+/*
+ *  _Partition_MP_Send_response_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  directive can be performed on another node.
+ */
+
+void _Partition_MP_Send_response_packet (
+  Partition_MP_Remote_operations  operation,
+  Objects_Id                      partition_id,
+  Thread_Control                 *the_thread
+);
+
+/*
+ *
+ *  _Partition_MP_Process_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the actions specific to this package for
+ *  the request from another node.
+ */
+
+void _Partition_MP_Process_packet (
+  rtems_packet_prefix *the_packet_prefix
+);
+
+/*
+ *  _Partition_MP_Send_object_was_deleted
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked indirectly by the thread queue
+ *  when a proxy has been removed from the thread queue and
+ *  the remote node must be informed of this.
+ *
+ *  This routine is not needed by the Partition since a partition
+ *  cannot be deleted when buffers are in use.
+ */
+
+/*
+ *  _Partition_MP_Send_extract_proxy
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked when a task is deleted and it
+ *  has a proxy which must be removed from a thread queue and
+ *  the remote node must be informed of this.
+ */
+
+void _Partition_MP_Send_extract_proxy (
+  Thread_Control *the_thread
+);
+
+/*
+ *  _Partition_MP_Get_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This function is used to obtain a partition mp packet.
+ */
+
+Partition_MP_Packet *_Partition_MP_Get_packet ( void );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of file */

c/src/exec/rtems/headers/ratemon.h

@@ -0,0 +1,285 @@
+/*  ratemon.h
+ *
+ *  This include file contains all the constants, structures, and
+ *  prototypes associated with the Rate Monotonic Manager.  This manager
+ *  provides facilities to implement tasks which execute in a periodic fashion.
+ *
+ *  Directives provided are:
+ *
+ *     + create a rate monotonic timer
+ *     + cancel a period
+ *     + delete a rate monotonic timer
+ *     + conclude current and start the next period
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_RATE_MONOTONIC_h
+#define __RTEMS_RATE_MONOTONIC_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/object.h>
+#include <rtems/thread.h>
+#include <rtems/watchdog.h>
+
+/*
+ *  The following enumerated type defines the states in which a
+ *  period may be.
+ */
+
+typedef enum {
+  RATE_MONOTONIC_INACTIVE,  /* off chain, never initialized */
+  RATE_MONOTONIC_ACTIVE,    /* on chain, running continuously */
+  RATE_MONOTONIC_EXPIRED    /* off chain, will be reset by next rm_period */
+}   Rate_Monotonic_Period_states;
+
+/*
+ *  The following constant is the interval passed to the rate_monontonic_period
+ *  directive to obtain status information.
+ */
+
+#define RTEMS_PERIOD_STATUS       RTEMS_NO_TIMEOUT
+
+/*
+ *  The following structure defines the control block used to manage
+ *  each period.
+ */
+
+typedef struct {
+  Objects_Control               Object;
+  Watchdog_Control              Timer;
+  Rate_Monotonic_Period_states  state;
+  Thread_Control               *owner;
+}   Rate_monotonic_Control;
+
+EXTERN Objects_Information _Rate_monotonic_Information;
+
+/*
+ *  _Rate_monotonic_Manager_initialization
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the initialization necessary for this manager.
+ */
+
+void _Rate_monotonic_Manager_initialization(
+  unsigned32 maximum_periods
+);
+
+/*
+ *  rtems_rate_monotonic_create
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rate_monotonic_create directive.  The
+ *  period will have the name name.  It returns the id of the
+ *  created period in ID.
+ */
+
+rtems_status_code rtems_rate_monotonic_create(
+  Objects_Name  name,
+  Objects_Id   *id
+);
+
+/*
+ *  rtems_rate_monotonic_ident
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_rate_monotonic_ident directive.
+ *  This directive returns the period ID associated with name.
+ *  If more than one period is named name, then the period
+ *  to which the ID belongs is arbitrary.
+ */
+
+rtems_status_code rtems_rate_monotonic_ident(
+  Objects_Name  name,
+  Objects_Id   *id
+);
+
+/*
+ *  rtems_rate_monotonic_cancel
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_rate_monotonic_cancel directive.  This
+ *  directive stops the period associated with ID from continuing to
+ *  run.
+ */
+
+rtems_status_code rtems_rate_monotonic_cancel(
+  Objects_Id id
+);
+
+/*
+ *  rtems_rate_monotonic_delete
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_rate_monotonic_delete directive.  The
+ *  period indicated by ID is deleted.
+ */
+
+rtems_status_code rtems_rate_monotonic_delete(
+  Objects_Id id
+);
+
+/*
+ *  rtems_rate_monotonic_period
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_rate_monotonic_period directive.  When
+ *  length is non-zero, this directive initiates the period associated with
+ *  ID from continuing for a period of length.  If length is zero, then
+ *  result is set to indicate the current state of the period.
+ */
+
+rtems_status_code rtems_rate_monotonic_period(
+  Objects_Id        id,
+  rtems_interval length
+);
+
+/*
+ *  _Rate_monotonic_Allocate
+ *
+ *  DESCRIPTION:
+ *
+ *  This function allocates a period control block from
+ *  the inactive chain of free period control blocks.
+ */
+
+STATIC INLINE Rate_monotonic_Control *_Rate_monotonic_Allocate( void );
+
+/*
+ *  _Rate_monotonic_Free
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine allocates a period control block from
+ *  the inactive chain of free period control blocks.
+ */
+
+STATIC INLINE void _Rate_monotonic_Free (
+  Rate_monotonic_Control *the_period
+);
+
+/*
+ *  _Rate_monotonic_Get
+ *
+ *  DESCRIPTION:
+ *
+ *  This function maps period IDs to period control blocks.
+ *  If ID corresponds to a local period, then it returns
+ *  the_period control pointer which maps to ID and location
+ *  is set to OBJECTS_LOCAL.  Otherwise, location is set
+ *  to OBJECTS_ERROR and the_period is undefined.
+ */
+
+STATIC INLINE Rate_monotonic_Control *_Rate_monotonic_Get (
+  Objects_Id         id,
+  Objects_Locations *location
+);
+
+/*
+ *  _Rate_monotonic_Set_state
+ *
+ *  DESCRIPTION:
+ *
+ *  This function blocks the calling task so that it is waiting for
+ *  a period to expire.  It returns TRUE if the task was successfully
+ *  blocked, and FALSE otherwise.
+ */
+
+boolean _Rate_monotonic_Set_state(
+  Rate_monotonic_Control *the_period
+);
+
+/*
+ *  _Rate_monotonic_Timeout
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked when the period represented
+ *  by ID expires.  If the task which owns this period is blocked
+ *  waiting for the period to expire, then it is readied and the
+ *  period is restarted.  If the owning task is not waiting for the
+ *  period to expire, then the period is placed in the EXPIRED
+ *  state and not restarted.
+ */
+
+void _Rate_monotonic_Timeout (
+  Objects_Id  id,
+  void       *ignored
+);
+
+/*
+ *  _Rate_monotonic_Is_active
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_period is in the ACTIVE state,
+ *  and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Rate_monotonic_Is_active (
+  Rate_monotonic_Control *the_period
+);
+
+/*
+ *  _Rate_monotonic_Is_inactive
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_period is in the ACTIVE state,
+ *  and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Rate_monotonic_Is_inactive (
+  Rate_monotonic_Control *the_period
+);
+
+/*
+ *  _Rate_monotonic_Is_expired
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_period is in the EXPIRED state,
+ *  and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Rate_monotonic_Is_expired (
+  Rate_monotonic_Control *the_period
+);
+
+/*
+ *  _Rate_monotonic_Is_null
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_period is NULL and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Rate_monotonic_Is_null (
+  Rate_monotonic_Control *the_period
+);
+
+#include <rtems/ratemon.inl>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/headers/region.h

@@ -0,0 +1,311 @@
+/*  region.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the Region Manager.  This manager provides facilities to dynamically
+ *  allocate memory in variable sized units which are returned as segments.
+ *
+ *  Directives provided are:
+ *
+ *     + create a region
+ *     + get an ID of a region
+ *     + delete a region
+ *     + get a segment from a region
+ *     + return a segment to a region
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_REGION_h
+#define __RTEMS_REGION_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/object.h>
+#include <rtems/threadq.h>
+#include <rtems/heap.h>
+#include <rtems/debug.h>
+
+/*
+ *  The following records define the control block used to manage
+ *  each region.
+ */
+
+typedef struct {
+  Objects_Control       Object;
+  Thread_queue_Control  Wait_queue;            /* waiting threads        */
+  void                 *starting_address;      /* physical start addr    */
+  unsigned32            length;                /* physical length(bytes) */
+  unsigned32            page_size;             /* in bytes               */
+  unsigned32            maximum_segment_size;  /* in bytes               */
+  rtems_attribute       attribute_set;
+  unsigned32            number_of_used_blocks; /* blocks allocated       */
+  Heap_Control          Memory;
+}  Region_Control;
+
+/*
+ *  The following defines the information control block used to
+ *  manage this class of objects.
+ */
+
+EXTERN Objects_Information _Region_Information;
+
+/*
+ *  _Region_Manager_initialization
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the initialization necessary for this manager.
+ */
+
+void _Region_Manager_initialization(
+  unsigned32 maximum_regions
+);
+
+/*
+ *  rtems_region_create
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_region_create directive.  The
+ *  region will have the name name.  The memory area managed by
+ *  the region is of length bytes and starts at starting_address.
+ *  The memory area will be divided into as many allocatable units of
+ *  page_size bytes as possible.   The attribute_set determines which
+ *  thread queue discipline is used by the region.  It returns the
+ *  id of the created region in ID.
+ */
+
+rtems_status_code rtems_region_create(
+  Objects_Name        name,
+  void               *starting_address,
+  unsigned32          length,
+  unsigned32          page_size,
+  rtems_attribute  attribute_set,
+  Objects_Id         *id
+);
+
+/*
+ *  rtems_region_extend
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_region_extend directive.  The
+ *  region will have the name name.  The memory area managed by
+ *  the region will be attempted to be grown by length bytes using
+ *  the memory starting at starting_address.
+ */
+
+rtems_status_code rtems_region_extend(
+  Objects_Id          id,
+  void               *starting_address,
+  unsigned32          length
+);
+
+/*
+ *  rtems_region_ident
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_region_ident directive.
+ *  This directive returns the region ID associated with name.
+ *  If more than one region is named name, then the region
+ *  to which the ID belongs is arbitrary.
+ */
+
+rtems_status_code rtems_region_ident(
+  Objects_Name  name,
+  Objects_Id   *id
+);
+
+/*
+ *  rtems_region_delete
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_region_delete directive.  The
+ *  region indicated by ID is deleted.
+ */
+
+rtems_status_code rtems_region_delete(
+  Objects_Id id
+);
+
+/*
+ *  rtems_region_get_segment
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_region_get_segment directive.  It
+ *  attempts to allocate a segment from the region associated with ID.
+ *  If a segment of the requested size can be allocated, its address
+ *  is returned in segment.  If no segment is available, then the task
+ *  may return immediately or block waiting for a segment with an optional
+ *  timeout of timeout clock ticks.  Whether the task blocks or returns
+ *  immediately is based on the no_wait option in the option_set.
+ */
+
+rtems_status_code rtems_region_get_segment(
+  Objects_Id         id,
+  unsigned32         size,
+  rtems_option    option_set,
+  rtems_interval  timeout,
+  void              **segment
+);
+
+/*
+ *  rtems_region_get_segment_size
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_region_get_segment_size directive.  It
+ *  returns the size in bytes of the specified user memory area.
+ */
+
+rtems_status_code rtems_region_get_segment_size(
+  Objects_Id         id,
+  void              *segment,
+  unsigned32        *size
+);
+
+/*
+ *  rtems_region_return_segment
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_region_return_segment directive.  It
+ *  frees the segment to the region associated with ID.  The segment must
+ *  have been previously allocated from the same region.  If freeing the
+ *  segment results in enough memory being available to satisfy the
+ *  rtems_region_get_segment of the first blocked task, then that task and as
+ *  many subsequent tasks as possible will be unblocked with their requests
+ *  satisfied.
+ */
+
+rtems_status_code rtems_region_return_segment(
+  Objects_Id  id,
+  void       *segment
+);
+
+/*
+ *  _Region_Allocate
+ *
+ *  DESCRIPTION:
+ *
+ *  This function allocates a region control block from
+ *  the inactive chain of free region control blocks.
+ */
+
+STATIC INLINE Region_Control *_Region_Allocate( void );
+
+/*
+ *  _Region_Free
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine frees a region control block to the
+ *  inactive chain of free region control blocks.
+ */
+
+STATIC INLINE void _Region_Free (
+  Region_Control *the_region
+);
+
+/*
+ *  _Region_Get
+ *
+ *  DESCRIPTION:
+ *
+ *  This function maps region IDs to region control blocks.
+ *  If ID corresponds to a local region, then it returns
+ *  the_region control pointer which maps to ID and location
+ *  is set to OBJECTS_LOCAL.  Otherwise, location is set
+ *  to OBJECTS_ERROR and the_region is undefined.
+ */
+
+STATIC INLINE Region_Control *_Region_Get (
+  Objects_Id         id,
+  Objects_Locations *location
+);
+
+/*
+ *  _Region_Allocate_segment
+ *
+ *  DESCRIPTION:
+ *
+ *  This function attempts to allocate a segment from the_region.
+ *  If successful, it returns the address of the allocated segment.
+ *  Otherwise, it returns NULL.
+ */
+
+STATIC INLINE void *_Region_Allocate_segment (
+  Region_Control *the_region,
+  unsigned32      size
+);
+
+/*
+ *  _Region_Free_segment
+ *
+ *  DESCRIPTION:
+ *
+ *  This function frees the_segment to the_region.
+ */
+
+STATIC INLINE boolean _Region_Free_segment (
+  Region_Control *the_region,
+  void           *the_segment
+);
+
+/*
+ *  _Region_Is_null
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_region is NULL and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Region_Is_null (
+  Region_Control *the_region
+);
+
+#include <rtems/region.inl>
+#include <rtems/regionmp.h>
+
+/*
+ *  _Region_Debug_Walk
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked to verify the integrity of a heap associated
+ *  with the_region.
+ */
+
+#ifdef RTEMS_DEBUG
+
+#define _Region_Debug_Walk( _the_region, _source ) \
+  do { \
+    if ( _Debug_Is_enabled( RTEMS_DEBUG_REGION ) ) \
+      _Heap_Walk( &(_the_region)->Memory, _source, FALSE ); \
+  } while ( 0 )
+
+#else
+
+#define _Region_Debug_Walk( _the_region, _source )
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/headers/regionmp.h

@@ -0,0 +1,165 @@
+/*  regionmp.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the Multiprocessing Support in the Region Manager.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_REGION_MP_h
+#define __RTEMS_REGION_MP_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/mppkt.h>
+#include <rtems/object.h>
+#include <rtems/options.h>
+#include <rtems/region.h>
+#include <rtems/thread.h>
+
+/*
+ *  The following enumerated type defines the list of
+ *  remote region operations.
+ */
+
+typedef enum {
+  REGION_MP_ANNOUNCE_CREATE         =  0,
+  REGION_MP_ANNOUNCE_DELETE         =  1,
+  REGION_MP_EXTRACT_PROXY           =  2,
+  REGION_MP_GET_SEGMENT_REQUEST     =  3,
+  REGION_MP_GET_SEGMENT_RESPONSE    =  4,
+  REGION_MP_RETURN_SEGMENT_REQUEST  =  5,
+  REGION_MP_RETURN_SEGMENT_RESPONSE =  6,
+}   Region_MP_Remote_operations;
+
+/*
+ *  The following data structure defines the packet used to perform
+ *  remote region operations.
+ */
+
+typedef struct {
+  rtems_packet_prefix             Prefix;
+  Region_MP_Remote_operations  operation;
+  Objects_Name                 name;
+  rtems_option              option_set;
+  unsigned32                   size;
+  Objects_Id                   proxy_id;
+  void                        *segment;
+}   Region_MP_Packet;
+
+/*
+ *  _Region_MP_Send_process_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  process operation can be performed on another node.
+ */
+
+void _Region_MP_Send_process_packet (
+  Region_MP_Remote_operations operation,
+  Objects_Id                  region_id,
+  Objects_Name                name,
+  Objects_Id                  proxy_id
+);
+
+/*
+ *  _Region_MP_Send_request_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  directive operation can be initiated on another node.
+ */
+
+rtems_status_code _Region_MP_Send_request_packet (
+  Region_MP_Remote_operations  operation,
+  Objects_Id                   region_id,
+  void                        *segment,
+  unsigned32                   size,
+  rtems_option              option_set,
+  rtems_interval            timeout
+);
+
+/*
+ *  _Region_MP_Send_response_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  directive can be performed on another node.
+ */
+
+void _Region_MP_Send_response_packet (
+  Region_MP_Remote_operations  operation,
+  Objects_Id                   region_id,
+  Thread_Control              *the_thread
+);
+
+/*
+ *
+ *  _Region_MP_Process_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the actions specific to this package for
+ *  the request from another node.
+ */
+
+void _Region_MP_Process_packet (
+  rtems_packet_prefix *the_packet_prefix
+);
+
+/*
+ *  _Region_MP_Send_object_was_deleted
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked indirectly by the thread queue
+ *  when a proxy has been removed from the thread queue and
+ *  the remote node must be informed of this.
+ *
+ *  This routine is not needed by the Region since a region
+ *  cannot be deleted when segments are in use.
+ */
+
+/*
+ *  _Region_MP_Send_extract_proxy
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked when a task is deleted and it
+ *  has a proxy which must be removed from a thread queue and
+ *  the remote node must be informed of this.
+ */
+
+void _Region_MP_Send_extract_proxy (
+  Thread_Control *the_thread
+);
+
+/*
+ *  _Region_MP_Get_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This function is used to obtain a region mp packet.
+ */
+
+Region_MP_Packet *_Region_MP_Get_packet ( void );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of file */

c/src/exec/rtems/headers/rtems.h

@@ -0,0 +1,79 @@
+/*  rtems.h
+ *
+ *  This include file contains information about RTEMS executive that
+ *  is required by the application and is CPU independent.  It includes
+ *  two (2) CPU dependent files to tailor its data structures for a
+ *  particular processor.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_RTEMS_GENERIC_h
+#define __RTEMS_RTEMS_GENERIC_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/system.h>
+#include <rtems/init.h>
+#include <rtems/tasks.h>
+#include <rtems/intr.h>
+#include <rtems/clock.h>
+#include <rtems/extension.h>
+#include <rtems/timer.h>
+#include <rtems/sem.h>
+#include <rtems/message.h>
+#include <rtems/event.h>
+#include <rtems/signal.h>
+#include <rtems/event.h>
+#include <rtems/part.h>
+#include <rtems/region.h>
+#include <rtems/dpmem.h>
+#include <rtems/io.h>
+#include <rtems/fatal.h>
+#include <rtems/ratemon.h>
+#include <rtems/mp.h>
+
+/*
+ *  RTEMS basic type definitions
+ */
+
+typedef unsigned8       rtems_unsigned8;  /* unsigned 8-bit value  */
+typedef unsigned16      rtems_unsigned16; /* unsigned 16-bit value */
+typedef unsigned32      rtems_unsigned32; /* unsigned 32-bit value */
+typedef unsigned64      rtems_unsigned64; /* unsigned 64-bit value */
+
+typedef signed8         rtems_signed8;    /* signed 8-bit value  */
+typedef signed16        rtems_signed16;   /* signed 16-bit value */
+typedef signed32        rtems_signed32;   /* signed 32-bit value */
+typedef signed64        rtems_signed64;   /* signed 64-bit value */
+
+typedef single_precision rtems_single;    /* single precision float */
+typedef double_precision rtems_double;    /* double precision float */
+
+typedef boolean                    rtems_boolean;
+
+typedef Objects_Name               rtems_name;
+typedef Objects_Id                 rtems_id;
+
+typedef Context_Control            rtems_context;
+typedef Context_Control_fp         rtems_context_fp;
+typedef CPU_Interrupt_frame        rtems_interrupt_frame;
+
+#define RTEMS_HAS_HARDWARE_FP CPU_HARDWARE_FP
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/headers/sem.h

@@ -0,0 +1,238 @@
+/*  semaphore.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the Semaphore Manager.  This manager utilizes standard Dijkstra
+ *  counting semaphores to provide synchronization and mutual exclusion
+ *  capabilities.
+ *
+ *  Directives provided are:
+ *
+ *     + create a semaphore
+ *     + get an ID of a semaphore
+ *     + delete a semaphore
+ *     + acquire a semaphore
+ *     + release a semaphore
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_SEMAPHORE_h
+#define __RTEMS_SEMAPHORE_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/attr.h>
+#include <rtems/object.h>
+#include <rtems/threadq.h>
+
+/*
+ *  The following defines the control block used to manage each semaphore.
+ */
+
+typedef struct {
+  Objects_Control       Object;
+  Thread_queue_Control  Wait_queue;
+  rtems_attribute    attribute_set;
+  unsigned32            count;
+  unsigned32            nest_count;
+  Thread_Control       *holder;
+  Objects_Id            holder_id;
+}   Semaphore_Control;
+
+/*
+ *  The following defines the information control block used to manage
+ *  this class of objects.
+ */
+
+EXTERN Objects_Information  _Semaphore_Information;
+
+/*
+ *  _Semaphore_Manager_initialization
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the initialization necessary for this manager.
+ */
+
+void _Semaphore_Manager_initialization(
+  unsigned32 maximum_semaphores
+);
+
+/*
+ *  rtems_semaphore_create
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_semaphore_create directive.  The
+ *  semaphore will have the name name.  The starting count for
+ *  the semaphore is count.  The attribute_set determines if
+ *  the semaphore is global or local and the thread queue
+ *  discipline.  It returns the id of the created semaphore in ID.
+ */
+
+rtems_status_code rtems_semaphore_create(
+  Objects_Name        name,
+  unsigned32          count,
+  rtems_attribute  attribute_set,
+  Objects_Id         *id
+);
+
+/*
+ *  rtems_semaphore_ident
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_semaphore_ident directive.
+ *  This directive returns the semaphore ID associated with name.
+ *  If more than one semaphore is named name, then the semaphore
+ *  to which the ID belongs is arbitrary.  node indicates the
+ *  extent of the search for the ID of the semaphore named name.
+ *  The search can be limited to a particular node or allowed to
+ *  encompass all nodes.
+ */
+
+rtems_status_code rtems_semaphore_ident(
+  Objects_Name  name,
+  unsigned32    node,
+  Objects_Id   *id
+);
+
+/*
+ *  rtems_semaphore_delete
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_semaphore_delete directive.  The
+ *  semaphore indicated by ID is deleted.
+ */
+
+rtems_status_code rtems_semaphore_delete(
+  Objects_Id id
+);
+
+/*
+ *  rtems_semaphore_obtain
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_semaphore_obtain directive.  It
+ *  attempts to obtain a unit from the semaphore associated with ID.
+ *  If a unit can be allocated, the calling task will return immediately.
+ *  If no unit is available, then the task may return immediately or
+ *  block waiting for a unit with an optional timeout of timeout
+ *  clock ticks.  Whether the task blocks or returns immediately
+ *  is based on the RTEMS_NO_WAIT option in the option_set.
+ */
+
+rtems_status_code rtems_semaphore_obtain(
+  Objects_Id        id,
+  unsigned32        option_set,
+  rtems_interval timeout
+);
+
+/*
+ *  rtems_semaphore_release
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_semaphore_release directive.  It
+ *  frees a unit to the semaphore associated with ID.  If a task was
+ *  blocked waiting for a unit from this semaphore, then that task will
+ *  be readied and the unit given to that task.  Otherwise, the unit
+ *  will be returned to the semaphore.
+ */
+
+rtems_status_code rtems_semaphore_release(
+  Objects_Id id
+);
+
+/*
+ *  _Semaphore_Seize
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine attempts to receive a unit from the_semaphore.
+ *  If a unit is available or if the RTEMS_NO_WAIT option is enabled in
+ *  option_set, then the routine returns.  Otherwise, the calling task
+ *  is blocked until a unit becomes available.
+ */
+
+boolean _Semaphore_Seize(
+  Semaphore_Control *the_semaphore,
+  unsigned32         option_set
+);
+
+/*
+ *  _Semaphore_Allocate
+ *
+ *  DESCRIPTION:
+ *
+ *  This function allocates a semaphore control block from
+ *  the inactive chain of free semaphore control blocks.
+ */
+
+STATIC INLINE Semaphore_Control *_Semaphore_Allocate( void );
+
+/*
+ *  _Semaphore_Free
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine frees a semaphore control block to the
+ *  inactive chain of free semaphore control blocks.
+ */
+
+STATIC INLINE void _Semaphore_Free (
+  Semaphore_Control *the_semaphore
+);
+
+/*
+ *  _Semaphore_Get
+ *
+ *  DESCRIPTION:
+ *
+ *  This function maps semaphore IDs to semaphore control blocks.
+ *  If ID corresponds to a local semaphore, then it returns
+ *  the_semaphore control pointer which maps to ID and location
+ *  is set to OBJECTS_LOCAL.  if the semaphore ID is global and
+ *  resides on a remote node, then location is set to OBJECTS_REMOTE,
+ *  and the_semaphore is undefined.  Otherwise, location is set
+ *  to OBJECTS_ERROR and the_semaphore is undefined.
+ */
+
+STATIC INLINE Semaphore_Control *_Semaphore_Get (
+  Objects_Id         id,
+  Objects_Locations *location
+);
+
+/*
+ *  _Semaphore_Is_null
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_semaphore is NULL and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Semaphore_Is_null (
+  Semaphore_Control *the_semaphore
+);
+
+#include <rtems/sem.inl>
+#include <rtems/semmp.h>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/*  end of include file */

c/src/exec/rtems/headers/semmp.h

@@ -0,0 +1,163 @@
+/*  semmp.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the Multiprocessing Support in the Semaphore Manager.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_SEMAPHORE_MP_h
+#define __RTEMS_SEMAPHORE_MP_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/mppkt.h>
+#include <rtems/object.h>
+#include <rtems/options.h>
+#include <rtems/sem.h>
+#include <rtems/thread.h>
+#include <rtems/watchdog.h>
+
+/*
+ *  The following enumerated type defines the list of
+ *  remote semaphore operations.
+ */
+
+typedef enum {
+  SEMAPHORE_MP_ANNOUNCE_CREATE  =  0,
+  SEMAPHORE_MP_ANNOUNCE_DELETE  =  1,
+  SEMAPHORE_MP_EXTRACT_PROXY    =  2,
+  SEMAPHORE_MP_OBTAIN_REQUEST   =  3,
+  SEMAPHORE_MP_OBTAIN_RESPONSE  =  4,
+  SEMAPHORE_MP_RELEASE_REQUEST  =  5,
+  SEMAPHORE_MP_RELEASE_RESPONSE =  6,
+}   Semaphore_MP_Remote_operations;
+
+/*
+ *  The following data structure defines the packet used to perform
+ *  remote semaphore operations.
+ */
+
+typedef struct {
+  rtems_packet_prefix               Prefix;
+  Semaphore_MP_Remote_operations operation;
+  Objects_Name                   name;
+  rtems_option                option_set;
+  Objects_Id                     proxy_id;
+}   Semaphore_MP_Packet;
+
+/*
+ *  _Semaphore_MP_Send_process_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  process operation can be performed on another node.
+ */
+
+void _Semaphore_MP_Send_process_packet (
+  Semaphore_MP_Remote_operations operation,
+  Objects_Id                     semaphore_id,
+  Objects_Name                   name,
+  Objects_Id                     proxy_id
+);
+
+/*
+ *  _Semaphore_MP_Send_request_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  directive operation can be initiated on another node.
+ */
+
+rtems_status_code _Semaphore_MP_Send_request_packet (
+  Semaphore_MP_Remote_operations operation,
+  Objects_Id                     semaphore_id,
+  rtems_option                option_set,
+  rtems_interval              timeout
+);
+
+/*
+ *  _Semaphore_MP_Send_response_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  directive can be performed on another node.
+ */
+
+void _Semaphore_MP_Send_response_packet (
+  Semaphore_MP_Remote_operations  operation,
+  Objects_Id                      semaphore_id,
+  Thread_Control                 *the_thread
+);
+
+/*
+ *
+ *  _Semaphore_MP_Process_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the actions specific to this package for
+ *  the request from another node.
+ */
+
+void _Semaphore_MP_Process_packet (
+  rtems_packet_prefix *the_packet_prefix
+);
+
+/*
+ *  _Semaphore_MP_Send_object_was_deleted
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked indirectly by the thread queue
+ *  when a proxy has been removed from the thread queue and
+ *  the remote node must be informed of this.
+ */
+
+void _Semaphore_MP_Send_object_was_deleted (
+  Thread_Control *the_proxy
+);
+
+/*
+ *  _Semaphore_MP_Send_extract_proxy
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked when a task is deleted and it
+ *  has a proxy which must be removed from a thread queue and
+ *  the remote node must be informed of this.
+ */
+
+void _Semaphore_MP_Send_extract_proxy (
+  Thread_Control *the_thread
+);
+
+/*
+ *  _Semaphore_MP_Get_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This function is used to obtain a semaphore mp packet.
+ */
+
+Semaphore_MP_Packet *_Semaphore_MP_Get_packet ( void );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of file */

c/src/exec/rtems/headers/signal.h

@@ -0,0 +1,72 @@
+/*  signal.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the Signal Manager.   This manager provides capabilities required
+ *  for asynchronous communication between tasks via signal sets.
+ *
+ *  Directives provided are:
+ *
+ *     + establish an asynchronous signal routine
+ *     + send a signal set to a task
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_SIGNAL_h
+#define __RTEMS_SIGNAL_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/asr.h>
+#include <rtems/modes.h>
+#include <rtems/object.h>
+#include <rtems/status.h>
+
+/*
+ *  rtems_signal_catch
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_signal_catch directive.  This directive
+ *  is used to establish asr_handler as the Asynchronous Signal Routine
+ *  (RTEMS_ASR) for the calling task.  The asr_handler will execute with a
+ *  mode of mode_set.
+ */
+
+rtems_status_code rtems_signal_catch(
+  rtems_asr_entry   asr_handler,
+  rtems_mode mode_set
+);
+
+/*
+ *  rtems_signal_send
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_signal_send directive.  This directive
+ *  sends the signal_set to the task specified by ID.
+ */
+
+rtems_status_code rtems_signal_send(
+  Objects_Id             id,
+  rtems_signal_set signal_set
+);
+
+#include <rtems/signalmp.h>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/headers/signalmp.h

@@ -0,0 +1,147 @@
+/*  signalmp.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the Multiprocessing Support in the Signal Manager.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_SIGNAL_MP_h
+#define __RTEMS_SIGNAL_MP_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/asr.h>
+#include <rtems/mppkt.h>
+#include <rtems/object.h>
+#include <rtems/thread.h>
+#include <rtems/watchdog.h>
+
+/*
+ *  The following enumerated type defines the list of
+ *  remote signal operations.
+ */
+
+typedef enum {
+  SIGNAL_MP_SEND_REQUEST  = 0,
+  SIGNAL_MP_SEND_RESPONSE = 1,
+}   Signal_MP_Remote_operations;
+
+/*
+ *  The following data structure defines the packet used to perform
+ *  remote signal operations.
+ */
+
+typedef struct {
+  rtems_packet_prefix            Prefix;
+  Signal_MP_Remote_operations operation;
+  rtems_signal_set      signal_in;
+}   Signal_MP_Packet;
+
+/*
+ *  _Signal_MP_Send_process_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  process operation can be performed on another node.
+ *
+ *  This routine is not needed since there are no process
+ *  packets to be sent by this manager.
+ */
+
+/*
+ *  _Signal_MP_Send_request_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  directive operation can be initiated on another node.
+ */
+
+rtems_status_code _Signal_MP_Send_request_packet (
+  Signal_MP_Remote_operations operation,
+  Objects_Id                  task_id,
+  rtems_signal_set      signal_in
+);
+
+/*
+ *  _Signal_MP_Send_response_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  directive can be performed on another node.
+ */
+
+void _Signal_MP_Send_response_packet (
+  Signal_MP_Remote_operations  operation,
+  Thread_Control              *the_thread
+);
+
+/*
+ *
+ *  _Signal_MP_Process_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the actions specific to this package for
+ *  the request from another node.
+ */
+
+void _Signal_MP_Process_packet (
+  rtems_packet_prefix *the_packet_prefix
+);
+
+/*
+ *  _Signal_MP_Send_object_was_deleted
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked indirectly by the thread queue
+ *  when a proxy has been removed from the thread queue and
+ *  the remote node must be informed of this.
+ *
+ *  This routine is not needed since there are no objects
+ *  deleted by this manager.
+ */
+
+/*
+ *  _Signal_MP_Send_extract_proxy
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked when a task is deleted and it
+ *  has a proxy which must be removed from a thread queue and
+ *  the remote node must be informed of this.
+ *
+ *  This routine is not needed since there are no objects
+ *  deleted by this manager.
+ */
+
+/*
+ *  _Signal_MP_Get_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This function is used to obtain a signal mp packet.
+ */
+
+Signal_MP_Packet *_Signal_MP_Get_packet ( void );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of file */

c/src/exec/rtems/headers/status.h

@@ -0,0 +1,109 @@
+/*  status.h
+ *
+ *  This include file contains the status codes returned from the
+ *  executive directives.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_STATUS_h
+#define __RTEMS_STATUS_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* types */
+
+/* enumerated constants */
+
+typedef enum {
+  RTEMS_SUCCESSFUL               =  0, /* successful completion */
+  RTEMS_TASK_EXITTED             =  1, /* returned from a thread */
+  RTEMS_MP_NOT_CONFIGURED        =  2, /* multiprocessing not configured */
+  RTEMS_INVALID_NAME             =  3, /* invalid object name */
+  RTEMS_INVALID_ID               =  4, /* invalid object id */
+  RTEMS_TOO_MANY                 =  5, /* too many */
+  RTEMS_TIMEOUT                  =  6, /* timed out waiting */
+  RTEMS_OBJECT_WAS_DELETED       =  7, /* object deleted while waiting */
+  RTEMS_INVALID_SIZE             =  8, /* specified size was invalid */
+  RTEMS_INVALID_ADDRESS          =  9, /* address specified is invalid */
+  RTEMS_INVALID_NUMBER           = 10, /* number was invalid */
+  RTEMS_NOT_DEFINED              = 11, /* item has not been initialized */
+  RTEMS_RESOURCE_IN_USE          = 12, /* resources still outstanding */
+  RTEMS_UNSATISFIED              = 13, /* request not satisfied */
+  RTEMS_INCORRECT_STATE          = 14, /* thread is in wrong state */
+  RTEMS_ALREADY_SUSPENDED        = 15, /* thread already in state */
+  RTEMS_ILLEGAL_ON_SELF          = 16, /* illegal on calling thread */
+  RTEMS_ILLEGAL_ON_REMOTE_OBJECT = 17, /* illegal for remote object */
+  RTEMS_CALLED_FROM_ISR          = 18, /* called from wrong environment */
+  RTEMS_INVALID_PRIORITY         = 19, /* invalid thread priority */
+  RTEMS_INVALID_CLOCK            = 20, /* invalid date/time */
+  RTEMS_INVALID_NODE             = 21, /* invalid node id */
+  RTEMS_NOT_CONFIGURED           = 22, /* directive not configured */
+  RTEMS_NOT_OWNER_OF_RESOURCE    = 23, /* not owner of resource */
+  RTEMS_NOT_IMPLEMENTED          = 24, /* directive not implemented */
+  RTEMS_INTERNAL_ERROR           = 25, /* RTEMS inconsistency detected */
+  RTEMS_PROXY_BLOCKING           = 26, /* internal multiprocessing only */
+  RTEMS_NO_MEMORY                = 27  /* could not get enough memory */
+} rtems_status_code;
+
+#define RTEMS_STATUS_CODES_FIRST RTEMS_SUCCESSFUL
+#define RTEMS_STATUS_CODES_LAST  RTEMS_NO_MEMORY
+
+/*
+ *  rtems_is_status_successful
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the status code is equal to RTEMS_SUCCESSFUL,
+ *  and FALSE otherwise.
+ */
+
+STATIC INLINE boolean rtems_is_status_successful (
+  rtems_status_code code
+);
+
+/*
+ *  rtems_are_statuses_equal
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the status code1 is equal to code2,
+ *  and FALSE otherwise.
+ */
+
+STATIC INLINE boolean rtems_are_statuses_equal (
+  rtems_status_code code1,
+  rtems_status_code code2
+);
+
+/*
+ *  _Status_Is_proxy_blocking
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the status code is equal to the
+ *  status which indicates that a proxy is blocking, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Status_Is_proxy_blocking (
+  rtems_status_code code
+);
+
+#include <rtems/status.inl>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/headers/taskmp.h

@@ -0,0 +1,167 @@
+/*  taskmp.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the multiprocessing support in the task manager.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_RTEMS_TASKS_MP_h
+#define __RTEMS_RTEMS_TASKS_MP_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/mppkt.h>
+#include <rtems/object.h>
+#include <rtems/options.h>
+#include <rtems/priority.h>
+#include <rtems/tasks.h>
+#include <rtems/thread.h>
+
+/*
+ *  The following enumerated type defines the list of
+ *  remote task operations.
+ */
+
+typedef enum {
+  RTEMS_TASKS_MP_ANNOUNCE_CREATE       =  0,
+  RTEMS_TASKS_MP_ANNOUNCE_DELETE       =  1,
+  RTEMS_TASKS_MP_SUSPEND_REQUEST       =  2,
+  RTEMS_TASKS_MP_SUSPEND_RESPONSE      =  3,
+  RTEMS_TASKS_MP_RESUME_REQUEST        =  4,
+  RTEMS_TASKS_MP_RESUME_RESPONSE       =  5,
+  RTEMS_TASKS_MP_SET_PRIORITY_REQUEST  =  6,
+  RTEMS_TASKS_MP_SET_PRIORITY_RESPONSE =  7,
+  RTEMS_TASKS_MP_GET_NOTE_REQUEST      =  8,
+  RTEMS_TASKS_MP_GET_NOTE_RESPONSE     =  9,
+  RTEMS_TASKS_MP_SET_NOTE_REQUEST      = 10,
+  RTEMS_TASKS_MP_SET_NOTE_RESPONSE     = 11,
+}   RTEMS_tasks_MP_Remote_operations;
+
+/*
+ *  The following data structure defines the packet used to perform
+ *  remote task operations.
+ */
+
+typedef struct {
+  rtems_packet_prefix                 Prefix;
+  RTEMS_tasks_MP_Remote_operations operation;
+  Objects_Name                     name;
+  rtems_task_priority                 the_priority;
+  unsigned32                       notepad;
+  unsigned32                       note;
+}   RTEMS_tasks_MP_Packet;
+
+/*
+ *  _RTEMS_tasks_MP_Send_process_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  process operation can be performed on another node.
+ */
+
+void _RTEMS_tasks_MP_Send_process_packet (
+  RTEMS_tasks_MP_Remote_operations operation,
+  Objects_Id                       task_id,
+  Objects_Name                     name
+);
+
+/*
+ *  _RTEMS_tasks_MP_Send_request_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  directive operation can be initiated on another node.
+ */
+
+rtems_status_code _RTEMS_tasks_MP_Send_request_packet (
+  RTEMS_tasks_MP_Remote_operations operation,
+  Objects_Id                       task_id,
+  rtems_task_priority                 the_priority,
+  unsigned32                       notepad,
+  unsigned32                       note
+);
+
+/*
+ *  _RTEMS_tasks_MP_Send_response_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  directive can be performed on another node.
+ */
+
+void _RTEMS_tasks_MP_Send_response_packet (
+  RTEMS_tasks_MP_Remote_operations  operation,
+  Thread_Control                   *the_thread
+);
+
+/*
+ *
+ *  _RTEMS_tasks_MP_Process_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the actions specific to this package for
+ *  the request from another node.
+ */
+
+void _RTEMS_tasks_MP_Process_packet (
+  rtems_packet_prefix *the_packet_prefix
+);
+
+/*
+ *  _RTEMS_tasks_MP_Send_object_was_deleted
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked indirectly by the thread queue
+ *  when a proxy has been removed from the thread queue and
+ *  the remote node must be informed of this.
+ *
+ *  This routine is not needed by RTEMS_tasks since a task
+ *  cannot be deleted when segments are in use.
+ */
+
+/*
+ *  _RTEMS_tasks_MP_Send_extract_proxy
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked when a task is deleted and it
+ *  has a proxy which must be removed from a thread queue and
+ *  the remote node must be informed of this.
+ *
+ *  This routine is not needed since there are no objects
+ *  deleted by this manager.
+ *
+ */
+
+/*
+ *  _RTEMS_tasks_MP_Get_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This function is used to obtain a task mp packet.
+ */
+
+RTEMS_tasks_MP_Packet *_RTEMS_tasks_MP_Get_packet ( void );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of file */

c/src/exec/rtems/headers/tasks.h

@@ -0,0 +1,315 @@
+/*  tasks.h
+ *
+ *  This include file contains all constants and structures associated
+ *  with RTEMS tasks.  This manager provides a comprehensive set of directives
+ *  to create, delete, and administer tasks.
+ *
+ *  Directives provided are:
+ *
+ *     + create a task
+ *     + get an ID of a task
+ *     + start a task
+ *     + restart a task
+ *     + delete a task
+ *     + suspend a task
+ *     + resume a task
+ *     + set a task's priority
+ *     + change the current task's mode
+ *     + get a task notepad entry
+ *     + set a task notepad entry
+ *     + wake up after interval
+ *     + wake up when specified
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_RTEMS_TASKS_h
+#define __RTEMS_RTEMS_TASKS_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/message.h>
+#include <rtems/object.h>
+#include <rtems/part.h>
+#include <rtems/region.h>
+#include <rtems/sem.h>
+#include <rtems/states.h>
+#include <rtems/thread.h>
+#include <rtems/threadq.h>
+
+/*
+ *  Constant to be used as the ID of current task
+ */
+
+#define RTEMS_SELF                OBJECTS_ID_OF_SELF
+
+/*
+ *  This constant is passed to the rtems_task_wake_after directive as the
+ *  interval when a task wishes to yield the CPU.
+ */
+
+#define RTEMS_YIELD_PROCESSOR RTEMS_NO_TIMEOUT
+
+/*
+ *  rtems_task_create
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_task_create directive.  The task
+ *  will have the name name.  The attribute_set can be used to indicate
+ *  that the task will be globally accessible or utilize floating point.
+ *  The task's stack will be stack_size bytes.   The task will begin
+ *  execution with initial_priority and initial_modes.  It returns the
+ *  id of the created task in ID.
+ */
+
+rtems_status_code rtems_task_create(
+  Objects_Name        name,
+  rtems_task_priority    initial_priority,
+  unsigned32          stack_size,
+  rtems_mode       initial_modes,
+  rtems_attribute  attribute_set,
+  Objects_Id         *id
+);
+
+/*
+ *  rtems_task_ident
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_task_ident directive.
+ *  This directive returns the task ID associated with name.
+ *  If more than one task is named name, then the task to
+ *  which the ID belongs is arbitrary.  node indicates the
+ *  extent of the search for the ID of the task named name.
+ *  The search can be limited to a particular node or allowed to
+ *  encompass all nodes.
+ */
+
+rtems_status_code rtems_task_ident(
+  Objects_Name  name,
+  unsigned32    node,
+  Objects_Id   *id
+);
+
+/*
+ *  rtems_task_delete
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_task_delete directive.  The
+ *  task indicated by ID is deleted.
+ */
+
+rtems_status_code rtems_task_delete(
+  Objects_Id id
+);
+
+/*
+ *  rtems_task_get_note
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_task_get_note directive.  The
+ *  value of the indicated notepad for the task associated with ID
+ *  is returned in note.
+ */
+
+rtems_status_code rtems_task_get_note(
+  Objects_Id  id,
+  unsigned32  notepad,
+  unsigned32 *note
+);
+
+/*
+ *  rtems_task_set_note
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_task_set_note directive.  The
+ *  value of the indicated notepad for the task associated with ID
+ *  is returned in note.
+ */
+
+rtems_status_code rtems_task_set_note(
+  Objects_Id id,
+  unsigned32 notepad,
+  unsigned32 note
+);
+
+/*
+ *  rtems_task_mode
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_task_mode directive.  The current
+ *  values of the modes indicated by mask of the calling task are changed
+ *  to that indicated in mode_set.  The former mode of the task is
+ *  returned in mode_set.
+ */
+
+rtems_status_code rtems_task_mode(
+  rtems_mode  mode_set,
+  rtems_mode  mask,
+  rtems_mode *previous_mode_set
+);
+
+/*
+ *  rtems_task_restart
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_task_restart directive.  The
+ *  task associated with ID is restarted at its initial entry
+ *  point with the new argument.
+ */
+
+rtems_status_code rtems_task_restart(
+  Objects_Id id,
+  unsigned32 arg
+);
+
+/*
+ *  rtems_task_suspend
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_task_suspend directive.  The
+ *  SUSPENDED state is set for task associated with ID.
+ */
+
+rtems_status_code rtems_task_suspend(
+  Objects_Id id
+);
+
+/*
+ *  rtems_task_resume
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_task_resume Directive.  The
+ *  SUSPENDED state is cleared for task associated with ID.
+ */
+
+rtems_status_code rtems_task_resume(
+  Objects_Id id
+);
+
+/*
+ *  rtems_task_set_priority
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_task_set_priority directive.  The
+ *  current priority of the task associated with ID is set to
+ *  new_priority.  The former priority of that task is returned
+ *  in old_priority.
+ */
+
+rtems_status_code rtems_task_set_priority(
+  Objects_Id        id,
+  rtems_task_priority  new_priority,
+  rtems_task_priority *old_priority
+);
+
+/*
+ *  rtems_task_start
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_task_start directive.  The
+ *  starting execution point of the task associated with ID is
+ *  set to entry_point with the initial argument.
+ */
+
+rtems_status_code rtems_task_start(
+  Objects_Id   id,
+  rtems_task_entry entry_point,
+  unsigned32   argument
+);
+
+/*
+ *  rtems_task_wake_when
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_task_wake_when directive.  The
+ *  calling task is blocked until the current time of day is
+ *  equal to that indicated by time_buffer.
+ */
+
+rtems_status_code rtems_task_wake_when(
+  rtems_time_of_day *time_buffer
+);
+
+/*
+ *  rtems_task_wake_after
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_task_wake_after directive.  The
+ *  calling task is blocked until the indicated number of clock
+ *  ticks have occurred.
+ */
+
+rtems_status_code rtems_task_wake_after(
+  rtems_interval ticks
+);
+
+/*
+ *  _RTEMS_tasks_Allocate
+ *
+ *  DESCRIPTION:
+ *
+ *  This function allocates a task control block from
+ *  the inactive chain of free task control blocks.
+ */
+
+STATIC INLINE Thread_Control *_RTEMS_tasks_Allocate( void );
+
+/*
+ *  _RTEMS_tasks_Free
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine frees a task control block to the
+ *  inactive chain of free task control blocks.
+
+ */
+
+STATIC INLINE void _RTEMS_tasks_Free (
+  Thread_Control *the_task
+);
+
+/*
+ *  _RTEMS_tasks_Cancel_wait
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine unblocks the_thread and cancels any timers
+ *  which the_thread has active.
+ */
+
+STATIC INLINE void _RTEMS_tasks_Cancel_wait(
+  Thread_Control *the_thread
+);
+
+#include <rtems/tasks.inl>
+#include <rtems/taskmp.h>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/headers/timer.h

@@ -0,0 +1,292 @@
+/*  timer.h
+ *
+ *  This include file contains all the constants, structures, and
+ *  prototypes associated with the Timer Manager.  This manager provides
+ *  facilities to configure, initiate, cancel, and delete timers which will
+ *  fire at specified intervals of time.
+ *
+ *  Directives provided are:
+ *
+ *     + create a timer
+ *     + get an ID of a timer
+ *     + delete a timer
+ *     + set a timer to fire after a number of ticks have passed
+ *     + set a timer to fire when a specified date and time has been reached
+ *     + reset a timer
+ *     + cancel a time
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_TIMER_h
+#define __RTEMS_TIMER_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/object.h>
+#include <rtems/tod.h>
+#include <rtems/watchdog.h>
+
+/*
+ *  The following enumerated type details the classes to which a timer
+ *  may belong.
+ */
+
+typedef enum {
+  TIMER_INTERVAL,
+  TIMER_TIME_OF_DAY,
+  TIMER_DORMANT
+} Timer_Classes;
+
+/*
+ *  The following defines the type of a Timer Service Routine.
+ */
+
+typedef rtems_timer_service_routine_entry Timer_Service;
+
+/*
+ *  The following defines the information control block used to manage
+ *  this class of objects.
+ */
+
+EXTERN Objects_Information  _Timer_Information;
+
+/*
+ *  The following records define the control block used to manage
+ *  each timer.
+ */
+
+typedef struct {
+  Objects_Control  Object;
+  Watchdog_Control Ticker;
+  Timer_Classes    the_class;
+}   Timer_Control;
+
+/*
+ *  _Timer_Manager_initialization
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the initialization necessary for this manager.
+ */
+
+void _Timer_Manager_initialization(
+  unsigned32 maximum_timers
+);
+
+/*
+ *  rtems_timer_create
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_timer_create directive.  The
+ *  timer will have the name name.  It returns the id of the
+ *  created timer in ID.
+ */
+
+rtems_status_code rtems_timer_create(
+  Objects_Name  name,
+  Objects_Id   *id
+);
+
+/*
+ *  rtems_timer_ident
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_timer_ident directive.
+ *  This directive returns the timer ID associated with name.
+ *  If more than one timer is named name, then the timer
+ *  to which the ID belongs is arbitrary.
+ */
+
+rtems_status_code rtems_timer_ident(
+  Objects_Name  name,
+  Objects_Id   *id
+);
+
+/*
+ *  rtems_timer_cancel
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_timer_cancel directive.  It is used
+ *  to stop the timer associated with ID from firing.
+ */
+
+rtems_status_code rtems_timer_cancel(
+  Objects_Id id
+);
+
+/*
+ *  rtems_timer_delete
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_timer_delete directive.  The
+ *  timer indicated by ID is deleted.
+ */
+
+rtems_status_code rtems_timer_delete(
+  Objects_Id id
+);
+
+/*
+ *  rtems_timer_fire_after
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_timer_fire_after directive.  It
+ *  initiates the timer associated with ID to fire in ticks clock
+ *  ticks.  When the timer fires, the routine will be invoked.
+ */
+
+rtems_status_code rtems_timer_fire_after(
+  Objects_Id         id,
+  rtems_interval  ticks,
+  Timer_Service      routine,
+  void              *user_data
+);
+
+/*
+ *  rtems_timer_fire_when
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_timer_fire_when directive.  It
+ *  initiates the timer associated with ID to fire at wall_time
+ *  When the timer fires, the routine will be invoked.
+ */
+
+rtems_status_code rtems_timer_fire_when(
+  Objects_Id         id,
+  rtems_time_of_day       *wall_time,
+  Timer_Service      routine,
+  void              *user_data
+);
+
+/*
+ *  rtems_timer_reset
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_timer_reset directive.  It is used
+ *  to reinitialize the interval timer associated with ID just as if
+ *  rtems_timer_fire_after were re-invoked with the same arguments that
+ *  were used to initiate this timer.
+ */
+
+rtems_status_code rtems_timer_reset(
+  Objects_Id id
+);
+
+/*
+ *  _Timer_Allocate
+ *
+ *  DESCRIPTION:
+ *
+ *  This function allocates a timer control block from
+ *  the inactive chain of free timer control blocks.
+ */
+
+STATIC INLINE Timer_Control *_Timer_Allocate( void );
+
+/*
+ *  _Timer_Free
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine frees a timer control block to the
+ *  inactive chain of free timer control blocks.
+ */
+
+STATIC INLINE void _Timer_Free (
+  Timer_Control *the_timer
+);
+
+/*
+ *  _Timer_Get
+ *
+ *  DESCRIPTION:
+ *
+ *  This function maps timer IDs to timer control blocks.
+ *  If ID corresponds to a local timer, then it returns
+ *  the timer control pointer which maps to ID and location
+ *  is set to OBJECTS_LOCAL.  Otherwise, location is set
+ *  to OBJECTS_ERROR and the returned value is undefined.
+ */
+
+STATIC INLINE Timer_Control *_Timer_Get (
+  Objects_Id         id,
+  Objects_Locations *location
+);
+
+/*
+ *  _Timer_Is_interval_class
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the class is that of an INTERVAL
+ *  timer, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Timer_Is_interval_class (
+  Timer_Classes the_class
+);
+
+/*
+ *  _Timer_Is_time_of_day_class
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the class is that of an INTERVAL
+ *  timer, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Timer_Is_timer_of_day_class (
+  Timer_Classes the_class
+);
+
+/*
+ *  _Timer_Is_dormant_class
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the class is that of a DORMANT
+ *  timer, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Timer_Is_dormant_class (
+  Timer_Classes the_class
+);
+
+/*
+ *  _Timer_Is_null
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_timer is NULL and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Timer_Is_null (
+  Timer_Control *the_timer
+);
+
+#include <rtems/timer.inl>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/include/rtems.h

@@ -0,0 +1,79 @@
+/*  rtems.h
+ *
+ *  This include file contains information about RTEMS executive that
+ *  is required by the application and is CPU independent.  It includes
+ *  two (2) CPU dependent files to tailor its data structures for a
+ *  particular processor.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_RTEMS_GENERIC_h
+#define __RTEMS_RTEMS_GENERIC_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/system.h>
+#include <rtems/init.h>
+#include <rtems/tasks.h>
+#include <rtems/intr.h>
+#include <rtems/clock.h>
+#include <rtems/extension.h>
+#include <rtems/timer.h>
+#include <rtems/sem.h>
+#include <rtems/message.h>
+#include <rtems/event.h>
+#include <rtems/signal.h>
+#include <rtems/event.h>
+#include <rtems/part.h>
+#include <rtems/region.h>
+#include <rtems/dpmem.h>
+#include <rtems/io.h>
+#include <rtems/fatal.h>
+#include <rtems/ratemon.h>
+#include <rtems/mp.h>
+
+/*
+ *  RTEMS basic type definitions
+ */
+
+typedef unsigned8       rtems_unsigned8;  /* unsigned 8-bit value  */
+typedef unsigned16      rtems_unsigned16; /* unsigned 16-bit value */
+typedef unsigned32      rtems_unsigned32; /* unsigned 32-bit value */
+typedef unsigned64      rtems_unsigned64; /* unsigned 64-bit value */
+
+typedef signed8         rtems_signed8;    /* signed 8-bit value  */
+typedef signed16        rtems_signed16;   /* signed 16-bit value */
+typedef signed32        rtems_signed32;   /* signed 32-bit value */
+typedef signed64        rtems_signed64;   /* signed 64-bit value */
+
+typedef single_precision rtems_single;    /* single precision float */
+typedef double_precision rtems_double;    /* double precision float */
+
+typedef boolean                    rtems_boolean;
+
+typedef Objects_Name               rtems_name;
+typedef Objects_Id                 rtems_id;
+
+typedef Context_Control            rtems_context;
+typedef Context_Control_fp         rtems_context_fp;
+typedef CPU_Interrupt_frame        rtems_interrupt_frame;
+
+#define RTEMS_HAS_HARDWARE_FP CPU_HARDWARE_FP
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/include/rtems/rtems/asr.h

@@ -0,0 +1,177 @@
+/*  asr.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the Asynchronous Signal Handler.  This Handler provides the low-level
+ *  support required by the Signal Manager.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_ASR_h
+#define __RTEMS_ASR_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/modes.h>
+
+/*
+ *
+ *  The following type defines the control block used to manage
+ *  each signal set.
+ */
+
+typedef unsigned32 rtems_signal_set;
+
+/*
+ *  Return type for ASR Handler
+ */
+
+typedef void rtems_asr;
+
+/*
+ *  The following type corresponds to the applications asynchronous
+ *  signal processing routine.
+ */
+
+typedef rtems_asr ( *rtems_asr_entry )(
+                 rtems_signal_set
+             );
+
+/*
+ *
+ *  The following defines the control structure used to manage
+ *  signals.  Each thread has a copy of this record.
+ */
+
+typedef struct {
+  rtems_asr_entry            handler;          /* address of RTEMS_ASR */
+  rtems_mode          mode_set;         /* RTEMS_ASR mode */
+  rtems_signal_set signals_posted;   /* signal set */
+  rtems_signal_set signals_pending;  /* pending signal set */
+  unsigned32             nest_level;       /* nest level of RTEMS_ASR */
+}   ASR_Information;
+
+/*
+ *  The following constants define the individual signals which may
+ *  be used to compose a signal set.
+ */
+
+#define RTEMS_SIGNAL_0    0x00000001
+#define RTEMS_SIGNAL_1    0x00000002
+#define RTEMS_SIGNAL_2    0x00000004
+#define RTEMS_SIGNAL_3    0x00000008
+#define RTEMS_SIGNAL_4    0x00000010
+#define RTEMS_SIGNAL_5    0x00000020
+#define RTEMS_SIGNAL_6    0x00000040
+#define RTEMS_SIGNAL_7    0x00000080
+#define RTEMS_SIGNAL_8    0x00000100
+#define RTEMS_SIGNAL_9    0x00000200
+#define RTEMS_SIGNAL_10   0x00000400
+#define RTEMS_SIGNAL_11   0x00000800
+#define RTEMS_SIGNAL_12   0x00001000
+#define RTEMS_SIGNAL_13   0x00002000
+#define RTEMS_SIGNAL_14   0x00004000
+#define RTEMS_SIGNAL_15   0x00008000
+#define RTEMS_SIGNAL_16   0x00010000
+#define RTEMS_SIGNAL_17   0x00020000
+#define RTEMS_SIGNAL_18   0x00040000
+#define RTEMS_SIGNAL_19   0x00080000
+#define RTEMS_SIGNAL_20   0x00100000
+#define RTEMS_SIGNAL_21   0x00200000
+#define RTEMS_SIGNAL_22   0x00400000
+#define RTEMS_SIGNAL_23   0x00800000
+#define RTEMS_SIGNAL_24   0x01000000
+#define RTEMS_SIGNAL_25   0x02000000
+#define RTEMS_SIGNAL_26   0x04000000
+#define RTEMS_SIGNAL_27   0x08000000
+#define RTEMS_SIGNAL_28   0x10000000
+#define RTEMS_SIGNAL_29   0x20000000
+#define RTEMS_SIGNAL_30   0x40000000
+#define RTEMS_SIGNAL_31   0x80000000
+
+/*
+ *  _ASR_Initialize
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine initializes the given RTEMS_ASR information record.
+ */
+
+STATIC INLINE void _ASR_Initialize (
+  ASR_Information *information
+);
+
+/*
+ *  _ASR_Swap_signals
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine atomically swaps the pending and posted signal
+ *  sets.  This is done when the thread alters its mode in such a
+ *  way that the RTEMS_ASR disable/enable flag changes.
+ */
+
+STATIC INLINE void _ASR_Swap_signals (
+  ASR_Information *information
+);
+
+/*
+ *  _ASR_Is_null_handler
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the given asr_handler is NULL and
+ *  FALSE otherwise.
+ */
+
+STATIC INLINE boolean _ASR_Is_null_handler (
+  rtems_asr_entry asr_handler
+);
+
+/*
+ *  _ASR_Are_signals_pending
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if there are signals pending in the
+ *  given RTEMS_ASR information record and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _ASR_Are_signals_pending (
+  ASR_Information *information
+);
+
+/*
+ *  _ASR_Post_signals
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine posts the given signals into the signal_set
+ *  passed in.  The result is returned to the user in signal_set.
+ *
+ *  NOTE:  This must be implemented as a macro.
+ */
+
+STATIC INLINE void _ASR_Post_signals(
+  rtems_signal_set  signals,
+  rtems_signal_set *signal_set
+);
+
+#include <rtems/asr.inl>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/include/rtems/rtems/attr.h

@@ -0,0 +1,188 @@
+/*  attr.h
+ *
+ *  This include file contains all information about the Object Attributes
+ *  Handler.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_ATTRIBUTES_h
+#define __RTEMS_ATTRIBUTES_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* types */
+
+typedef unsigned32 rtems_attribute;
+
+/* constants */
+
+#define RTEMS_DEFAULT_ATTRIBUTES            0x00000000
+
+#define RTEMS_NO_FLOATING_POINT   0x00000000 /* don't use FP HW */
+#define RTEMS_FLOATING_POINT      0x00000001 /* utilize coprocessor */
+
+#define RTEMS_LOCAL               0x00000000 /* local resource */
+#define RTEMS_GLOBAL              0x00000002 /* global resource */
+
+#define RTEMS_FIFO                0x00000000 /* process RTEMS_FIFO */
+#define RTEMS_PRIORITY            0x00000004 /* process by priority */
+
+#define RTEMS_NO_LIMIT            0x00000000 /* unlimited Q entries */
+#define RTEMS_LIMIT               0x00000008 /* limit Q entries */
+
+#define RTEMS_COUNTING_SEMAPHORE  0x00000000
+#define RTEMS_BINARY_SEMAPHORE    0x00000010
+
+#define RTEMS_NO_INHERIT_PRIORITY 0x00000000
+#define RTEMS_INHERIT_PRIORITY    0x00000020
+
+#if ( CPU_HARDWARE_FP == TRUE )
+#define ATTRIBUTES_NOT_SUPPORTED       0
+#else
+#define ATTRIBUTES_NOT_SUPPORTED       RTEMS_FLOATING_POINT
+#endif
+
+#if ( CPU_ALL_TASKS_ARE_FP == TRUE )
+#define ATTRIBUTES_REQUIRED            RTEMS_FLOATING_POINT
+#else
+#define ATTRIBUTES_REQUIRED            0
+#endif
+
+/*
+ *  _Attributes_Handler_initialization
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs initialization for this handler.
+ *
+ *  NOTE: There is no initialization required in C.  Conditional compilation
+ *        takes care of this in C.
+ */
+
+#define _Attributes_Handler_initialization()
+
+/*
+ *  _Attributes_Set
+ *
+ *  DESCRIPTION:
+ *
+ *  This function sets the requested new_attributes in the attribute_set
+ *  passed in.  The result is returned to the user.
+ */
+
+STATIC INLINE rtems_attribute _Attributes_Set (
+   rtems_attribute new_attributes,
+   rtems_attribute attribute_set
+);
+
+/*
+ *  _Attributes_Clear
+ *
+ *  DESCRIPTION:
+ *
+ *  This function clears the requested new_attributes in the attribute_set
+ *  passed in.  The result is returned to the user.
+ */
+
+STATIC INLINE rtems_attribute _Attributes_Clear (
+   rtems_attribute attribute_set,
+   rtems_attribute mask
+);
+
+/*
+ *  _Attributes_Is_floating_point
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the floating point attribute is
+ *  enabled in the attribute_set and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Attributes_Is_floating_point(
+  rtems_attribute attribute_set
+);
+
+/*
+ *  _Attributes_Is_global
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the global object attribute is
+ *  enabled in the attribute_set and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Attributes_Is_global(
+  rtems_attribute attribute_set
+);
+
+/*
+ *  _Attributes_Is_priority
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the priority attribute is
+ *  enabled in the attribute_set and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Attributes_Is_priority(
+  rtems_attribute attribute_set
+);
+
+/*
+ *  _Attributes_Is_limit
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the limited attribute is
+ *  enabled in the attribute_set and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Attributes_Is_limit(
+  rtems_attribute attribute_set
+);
+
+/*
+ *  _Attributes_Is_binary_semaphore
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the binary semaphore attribute is
+ *  enabled in the attribute_set and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Attributes_Is_binary_semaphore(
+  rtems_attribute attribute_set
+);
+
+/*
+ *  _Attributes_Is_inherit_priority
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the priority inheritance attribute
+ *  is enabled in the attribute_set and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Attributes_Is_inherit_priority(
+  rtems_attribute attribute_set
+);
+
+#include <rtems/attr.inl>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/include/rtems/rtems/clock.h

@@ -0,0 +1,102 @@
+/*  clock.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the Clock Manager.  This manager provides facilities to set, obtain,
+ *  and continually update the current date and time.
+ *
+ *  This manager provides directives to:
+ *
+ *     + set the current date and time
+ *     + obtain the current date and time
+ *     + announce a clock tick
+ *
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_CLOCK_h
+#define __RTEMS_CLOCK_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/tod.h>
+
+/*
+ *  List of things which can be returned by the rtems_clock_get directive.
+ */
+
+typedef enum {
+  RTEMS_CLOCK_GET_TOD,
+  RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH,
+  RTEMS_CLOCK_GET_TICKS_SINCE_BOOT,
+  RTEMS_CLOCK_GET_TICKS_PER_SECOND,
+  RTEMS_CLOCK_GET_TIME_VALUE
+} rtems_clock_get_options;
+
+/*
+ *  Standard flavor style to return TOD in for a rtems_clock_get option.
+ */
+
+typedef struct {
+  unsigned32  seconds;
+  unsigned32  microseconds;
+} rtems_clock_time_value;
+
+/*
+ *  rtems_clock_get
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_clock_get directive.  It returns
+ *  one of the following:
+ *    + current time of day
+ *    + seconds since epoch
+ *    + ticks since boot
+ *    + ticks per second
+ */
+
+rtems_status_code rtems_clock_get(
+  rtems_clock_get_options  option,
+  void              *time_buffer
+);
+
+/*
+ *  rtems_clock_set
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_clock_set directive.  It sets
+ *  the current time of day to that in the time_buffer record.
+ */
+
+rtems_status_code rtems_clock_set(
+  rtems_time_of_day *time_buffer
+);
+
+/*
+ *  rtems_clock_tick
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_clock_tick directive.  It is invoked
+ *  to inform RTEMS of the occurrence of a clock tick.
+ */
+
+rtems_status_code rtems_clock_tick( void );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/include/rtems/rtems/dpmem.h

@@ -0,0 +1,210 @@
+/*  dpmem.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the Dual Ported Memory Manager. This manager provides a mechanism
+ *  for converting addresses between internal and external representations
+ *  for multiple dual-ported memory areas.
+ *
+ *  Directives provided are:
+ *
+ *     + create a port
+ *     + get ID of a port
+ *     + delete a port
+ *     + convert external to internal address
+ *     + convert internal to external address
+ *
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_DUAL_PORTED_MEMORY_h
+#define __RTEMS_DUAL_PORTED_MEMORY_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/object.h>
+
+/*
+ *  The following structure defines the port control block.  Each port
+ *  has a control block associated with it.  This control block contains
+ *  all information required to support the port related operations.
+ */
+
+typedef struct {
+  Objects_Control  Object;
+  void            *internal_base; /* base internal address */
+  void            *external_base; /* base external address */
+  unsigned32       length;        /* length of dual-ported area */
+}   Dual_ported_memory_Control;
+
+/*
+ *  The following define the internal Dual Ported Memory information.
+ */
+
+EXTERN Objects_Information  _Dual_ported_memory_Information;
+
+/*
+ *  _Dual_ported_memory_Manager_initialization
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the initialization necessary for this manager.
+ */
+
+void _Dual_ported_memory_Manager_initialization(
+  unsigned32 maximum_ports
+);
+
+/*
+ *  rtems_port_create
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_port_create directive.  The port
+ *  will have the name name.  The port maps onto an area of dual ported
+ *  memory of length bytes which has internal_start and external_start
+ *  as the internal and external starting addresses, respectively.
+ *  It returns the id of the created port in ID.
+ */
+
+rtems_status_code rtems_port_create(
+  Objects_Name  name,
+  void         *internal_start,
+  void         *external_start,
+  unsigned32    length,
+  Objects_Id   *id
+);
+
+/*
+ *  rtems_port_ident
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_port_ident directive.  This directive
+ *  returns the port ID associated with name.  If more than one port is
+ *  named name, then the port to which the ID belongs is arbitrary.
+ */
+
+rtems_status_code rtems_port_ident(
+  Objects_Name  name,
+  Objects_Id   *id
+);
+
+/*
+ *  rtems_port_delete
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_port_delete directive.  It deletes
+ *  the port associated with ID.
+ */
+
+rtems_status_code rtems_port_delete(
+  Objects_Id id
+);
+
+/*
+ *  rtems_port_external_to_internal
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_port_external_to_internal directive.
+ *  It returns the internal port address which maps to the provided
+ *  external port address for the specified port ID.
+ */
+
+rtems_status_code rtems_port_external_to_internal(
+  Objects_Id   id,
+  void        *external,
+  void       **internal
+);
+
+/*
+ *  rtems_port_internal_to_external
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the Port_internal_to_external directive.
+ *  It returns the external port address which maps to the provided
+ *  internal port address for the specified port ID.
+ */
+
+rtems_status_code rtems_port_internal_to_external(
+  Objects_Id   id,
+  void        *internal,
+  void       **external
+);
+
+/*
+ *  _Dual_ported_memory_Allocate
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine allocates a port control block from the inactive chain
+ *  of free port control blocks.
+ */
+
+STATIC INLINE Dual_ported_memory_Control
+  *_Dual_ported_memory_Allocate ( void );
+
+/*
+ *  _Dual_ported_memory_Free
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine frees a port control block to the inactive chain
+ *  of free port control blocks.
+ */
+
+STATIC INLINE void _Dual_ported_memory_Free (
+   Dual_ported_memory_Control *the_port
+);
+
+/*
+ *  _Dual_ported_memory_Get
+ *
+ *  DESCRIPTION:
+ *
+ *  This function maps port IDs to port control blocks.  If ID
+ *  corresponds to a local port, then it returns the_port control
+ *  pointer which maps to ID and location is set to OBJECTS_LOCAL.
+ *  Global ports are not supported, thus if ID  does not map to a
+ *  local port, location is set to OBJECTS_ERROR and the_port is
+ *  undefined.
+ */
+
+STATIC INLINE Dual_ported_memory_Control *_Dual_ported_memory_Get (
+  Objects_Id         id,
+  Objects_Locations *location
+);
+
+/*
+ *  _Dual_ported_memory_Is_null
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_port is NULL and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Dual_ported_memory_Is_null(
+  Dual_ported_memory_Control *the_port
+);
+
+#include <rtems/dpmem.inl>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/include/rtems/rtems/event.h

@@ -0,0 +1,158 @@
+/*  event.h
+ *
+ *  This include file contains the information pertaining to the Event
+ *  Manager.  This manager provides a high performance method of communication
+ *  and synchronization.
+ *
+ *  Directives provided are:
+ *
+ *     + send an event set to a task
+ *     + receive event condition
+ *
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_EVENT_h
+#define __RTEMS_EVENT_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/object.h>
+#include <rtems/options.h>
+#include <rtems/thread.h>
+#include <rtems/watchdog.h>
+#include <rtems/eventset.h>
+
+/*
+ *  This constant is passed as the event_in to the
+ *  rtems_event_receive directive to determine which events are pending.
+ */
+
+#define EVENT_CURRENT  0
+
+/*
+ *  _Event_Manager_initialization
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the initialization necessary for this manager.
+ */
+
+STATIC INLINE void _Event_Manager_initialization( void );
+
+/*
+ *  rtems_event_send
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_event_send directive.  It sends
+ *  event_in to the task specified by ID.  If the task is blocked
+ *  waiting to receive events and the posting of event_in satisfies
+ *  the task's event condition, then it is unblocked.
+ */
+
+rtems_status_code rtems_event_send (
+  Objects_Id         id,
+  rtems_event_set event_in
+);
+
+/*
+ *  rtems_event_receive
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_event_receive directive.  This
+ *  directive is invoked when the calling task wishes to receive
+ *  the event_in event condition.  One of the fields in the option_set
+ *  parameter determines whether the receive request is satisfied if
+ *  any or all of the events are pending.   If the event condition
+ *  is not satisfied immediately, then the task may block with an
+ *  optional timeout of TICKS clock ticks or return immediately.
+ *  This determination is based on another field in the option_set
+ *  parameter.  This directive returns the events received in the
+ *  event_out parameter.
+ */
+
+rtems_status_code rtems_event_receive (
+  rtems_event_set  event_in,
+  rtems_option     option_set,
+  rtems_interval   ticks,
+  rtems_event_set *event_out
+);
+
+/*
+ *  _Event_Seize
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine determines if the event condition event_in is
+ *  satisfied.  If so or if the no_wait option is enabled in option_set,
+ *  then the procedure returns immediately.  If neither of these
+ *  conditions is true, then the calling task is blocked with an
+ *  optional timeout of ticks clock ticks.
+ */
+
+void _Event_Seize (
+  rtems_event_set event_in,
+  rtems_option    option_set,
+  rtems_interval  ticks
+);
+
+/*
+ *  _Event_Surrender
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine determines if the event condition of the_thread
+ *  has been satisfied.  If so, it unblocks the_thread.
+ */
+
+void _Event_Surrender (
+  Thread_Control *the_thread
+);
+
+/*
+ *  _Event_Timeout
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked when a task's event receive request
+ *  has not been satisfied after the specified timeout interval.
+ *  The task represented by ID will be unblocked and its status
+ *  code will be set in it's control block to indicate that a timeout
+ *  has occurred.
+ */
+
+void _Event_Timeout (
+  Objects_Id  id,
+  void       *ignored
+);
+
+/*
+ *  The following defines the synchronization flag used by the
+ *  Event Manager to insure that signals sent to the currently
+ *  executing thread are received properly.
+ */
+
+EXTERN boolean _Event_Sync;    /* event manager sync flag */
+
+#include <rtems/event.inl>
+#include <rtems/eventmp.h>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/include/rtems/rtems/eventmp.h

@@ -0,0 +1,147 @@
+/*  eventmp.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the Multiprocessing Support in the Event Manager.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_EVENT_MP_h
+#define __RTEMS_EVENT_MP_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/event.h>
+#include <rtems/mppkt.h>
+#include <rtems/object.h>
+#include <rtems/thread.h>
+#include <rtems/watchdog.h>
+
+/*
+ *  The following enumerated type defines the list of
+ *  remote event operations.
+ */
+
+typedef enum {
+  EVENT_MP_SEND_REQUEST  =  0,
+  EVENT_MP_SEND_RESPONSE =  1,
+}   Event_MP_Remote_operations;
+
+/*
+ *  The following data structure defines the packet used to perform
+ *  remote event operations.
+ */
+
+typedef struct {
+  rtems_packet_prefix           Prefix;
+  Event_MP_Remote_operations operation;
+  rtems_event_set         event_in;
+}   Event_MP_Packet;
+
+/*
+ *  _Event_MP_Send_process_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  process operation can be performed on another node.
+ *
+ *  This routine is not needed since there are no process
+ *  packets to be sent by this manager.
+ */
+
+/*
+ *  _Event_MP_Send_request_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  directive operation can be initiated on another node.
+ */
+
+rtems_status_code _Event_MP_Send_request_packet (
+  Event_MP_Remote_operations operation,
+  Objects_Id                 event_id,
+  rtems_event_set         event_in
+);
+
+/*
+ *  _Event_MP_Send_response_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  directive can be performed on another node.
+ */
+
+void _Event_MP_Send_response_packet (
+  Event_MP_Remote_operations  operation,
+  Thread_Control             *the_thread
+);
+
+/*
+ *
+ *  _Event_MP_Process_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the actions specific to this package for
+ *  the request from another node.
+ */
+
+void _Event_MP_Process_packet (
+  rtems_packet_prefix *the_packet_prefix
+);
+
+/*
+ *  _Event_MP_Send_object_was_deleted
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked indirectly by the thread queue
+ *  when a proxy has been removed from the thread queue and
+ *  the remote node must be informed of this.
+ *
+ *  This routine is not needed since there are no objects
+ *  deleted by this manager.
+ */
+
+/*
+ *  _Event_MP_Send_extract_proxy
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked when a task is deleted and it
+ *  has a proxy which must be removed from a thread queue and
+ *  the remote node must be informed of this.
+ *
+ *  This routine is not needed since there are no objects
+ *  deleted by this manager.
+ */
+
+/*
+ *  _Event_MP_Get_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This function is used to obtain a event mp packet.
+ */
+
+Event_MP_Packet *_Event_MP_Get_packet ( void );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of file */

c/src/exec/rtems/include/rtems/rtems/eventset.h

@@ -0,0 +1,142 @@
+/*  eventset.h
+ *
+ *  This include file contains the information pertaining to the
+ *  Event Sets Handler.  This handler provides methods for the manipulation
+ *  of event sets which will be sent and received by tasks.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_EVENT_SET_h
+#define __RTEMS_EVENT_SET_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ *  The following defines the type used to control event sets.
+ */
+
+typedef unsigned32 rtems_event_set;
+
+/*
+ *  The following constants define the individual events which may
+ *  be used to compose an event set.
+ */
+
+#define RTEMS_PENDING_EVENTS      0           /* receive pending events   */
+#define RTEMS_ALL_EVENTS  0xFFFFFFFF
+
+#define RTEMS_EVENT_0     0x00000001
+#define RTEMS_EVENT_1     0x00000002
+#define RTEMS_EVENT_2     0x00000004
+#define RTEMS_EVENT_3     0x00000008
+#define RTEMS_EVENT_4     0x00000010
+#define RTEMS_EVENT_5     0x00000020
+#define RTEMS_EVENT_6     0x00000040
+#define RTEMS_EVENT_7     0x00000080
+#define RTEMS_EVENT_8     0x00000100
+#define RTEMS_EVENT_9     0x00000200
+#define RTEMS_EVENT_10    0x00000400
+#define RTEMS_EVENT_11    0x00000800
+#define RTEMS_EVENT_12    0x00001000
+#define RTEMS_EVENT_13    0x00002000
+#define RTEMS_EVENT_14    0x00004000
+#define RTEMS_EVENT_15    0x00008000
+#define RTEMS_EVENT_16    0x00010000
+#define RTEMS_EVENT_17    0x00020000
+#define RTEMS_EVENT_18    0x00040000
+#define RTEMS_EVENT_19    0x00080000
+#define RTEMS_EVENT_20    0x00100000
+#define RTEMS_EVENT_21    0x00200000
+#define RTEMS_EVENT_22    0x00400000
+#define RTEMS_EVENT_23    0x00800000
+#define RTEMS_EVENT_24    0x01000000
+#define RTEMS_EVENT_25    0x02000000
+#define RTEMS_EVENT_26    0x04000000
+#define RTEMS_EVENT_27    0x08000000
+#define RTEMS_EVENT_28    0x10000000
+#define RTEMS_EVENT_29    0x20000000
+#define RTEMS_EVENT_30    0x40000000
+#define RTEMS_EVENT_31    0x80000000
+
+
+/*
+ *  The following constant is the value of an event set which
+ *  has no events pending.
+ */
+
+#define EVENT_SETS_NONE_PENDING 0
+
+/*
+ *  _Event_sets_Is_empty
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if on events are posted in the event_set,
+ *  and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Event_sets_Is_empty(
+  rtems_event_set the_event_set
+);
+
+/*
+ *  _Event_sets_Post
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine posts the given new_events into the event_set
+ *  passed in.  The result is returned to the user in event_set.
+ */
+
+STATIC INLINE void _Event_sets_Post(
+  rtems_event_set  the_new_events,
+  rtems_event_set *the_event_set
+);
+
+/*
+ *  _Event_sets_Get
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns the events in event_condition which are
+ *  set in event_set.
+ */
+
+STATIC INLINE rtems_event_set _Event_sets_Get(
+  rtems_event_set the_event_set,
+  rtems_event_set the_event_condition
+);
+
+/*
+ *  _Event_sets_Clear
+ *
+ *  DESCRIPTION:
+ *
+ *  This function removes the events in mask from the event_set
+ *  passed in.  The result is returned to the user in event_set.
+ */
+
+STATIC INLINE rtems_event_set _Event_sets_Clear(
+ rtems_event_set the_event_set,
+ rtems_event_set the_mask
+);
+
+#include <rtems/eventset.inl>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/include/rtems/rtems/intr.h

@@ -0,0 +1,125 @@
+/*  intr.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the Interrupt Manager.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_INTERRUPT_h
+#define __RTEMS_INTERRUPT_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/isr.h>
+
+/*
+ *  Interrupt level type
+ */
+
+typedef ISR_Level rtems_interrupt_level;
+
+/*
+ *  _Interrupt_Manager_initialization
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine initializes the interrupt manager.
+ *
+ */
+
+void _Interrupt_Manager_initialization( void );
+
+/*
+ *  rtems_interrupt_catch
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_interrupt_catch directive.  This
+ *  directive installs new_isr_handler as the RTEMS interrupt service
+ *  routine for vector.  The previous RTEMS interrupt service
+ *  routine is returned in old_isr_handler.
+ */
+
+rtems_status_code rtems_interrupt_catch(
+  rtems_isr_entry    new_isr_handler,
+  rtems_vector_number  vector,
+  rtems_isr_entry   *old_isr_handler
+);
+
+/*
+ *  rtems_interrupt_disable
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine disables all maskable interrupts and returns the
+ *  previous level in _isr_cookie.
+ */
+
+#define rtems_interrupt_disable( _isr_cookie ) \
+    _ISR_Disable(_isr_cookie)
+        
+/*
+ *  rtems_interrupt_enable
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine enables maskable interrupts to the level indicated
+ *  _isr_cookie.
+ */
+
+#define rtems_interrupt_enable( _isr_cookie ) \
+    _ISR_Enable(_isr_cookie)
+        
+/*
+ *  rtems_interrupt_flash
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine temporarily enables maskable interrupts to the
+ *  level in _isr_cookie before redisabling them.
+ */
+
+#define rtems_interrupt_flash( _isr_cookie ) \
+    _ISR_Flash(_isr_cookie)
+
+/*
+ *  rtems_interrupt_cause
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine generates an interrupt.
+ *
+ *  NOTE:  No implementation.
+ */
+
+#define rtems_interrupt_cause( _interrupt_to_cause )
+
+/*
+ *  rtems_interrupt_cause
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine clears the specified interrupt.
+ *
+ *  NOTE:  No implementation.
+ */
+
+#define rtems_interrupt_clear( _interrupt_to_clear )
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/include/rtems/rtems/message.h

@@ -0,0 +1,461 @@
+/*  message.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the Message Queue Manager.  This manager provides a mechanism for
+ *  communication and synchronization between tasks using messages.
+ *
+ *  Directives provided are:
+ *
+ *     + create a queue
+ *     + get ID of a queue
+ *     + delete a queue
+ *     + put a message at the rear of a queue
+ *     + put a message at the front of a queue
+ *     + broadcast N messages to a queue
+ *     + receive message from a queue
+ *     + flush all messages on a queue
+ *
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_MESSAGE_QUEUE_h
+#define __RTEMS_MESSAGE_QUEUE_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/chain.h>
+#include <rtems/object.h>
+#include <rtems/threadq.h>
+
+/*
+ *  The following defines the data types needed to manipulate
+ *  the contents of message buffers.
+ */
+
+typedef struct {
+  unsigned32 field1;
+  unsigned32 field2;
+  unsigned32 field3;
+  unsigned32 field4;
+}  Message_queue_Buffer;
+
+/*
+ *  The following records define the organization of a message
+ *  buffer.
+ */
+
+typedef struct {
+  Chain_Node           Node;
+  Message_queue_Buffer Contents;
+}   Message_queue_Buffer_control;
+
+/*
+ *  The following records define the control block used to manage
+ *  each message queue.
+ */
+
+typedef struct {
+  Objects_Control      Object;
+  Thread_queue_Control Wait_queue;
+  rtems_attribute   attribute_set;
+  unsigned32           maximum_pending_messages;
+  unsigned32           number_of_pending_messages;
+  Chain_Control        Pending_messages;
+}   Message_queue_Control;
+
+/*
+ *  The following defines the information control block used to
+ *  manage this class of objects.
+ */
+
+EXTERN Objects_Information  _Message_queue_Information;
+
+/*
+ *  The following defines the data structures used to
+ *  manage the pool of inactive message buffers.
+ */
+
+EXTERN Chain_Control _Message_queue_Inactive_messages;
+
+/*
+ *  The following enumerated type details the modes in which a message
+ *  may be submitted to a message queue.  The message may be posted
+ *  in a send or urgent fashion.
+ */
+
+typedef enum {
+  MESSAGE_QUEUE_SEND_REQUEST   = 0,
+  MESSAGE_QUEUE_URGENT_REQUEST = 1
+}  Message_queue_Submit_types;
+
+/*
+ *  _Message_queue_Manager_initialization
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the initialization necessary for this manager.
+ */
+
+void _Message_queue_Manager_initialization(
+  unsigned32 maximum_message_queues,
+  unsigned32 maximum_messages
+);
+
+/*
+ *  rtems_message_queue_create
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_message_queue_create directive.  The
+ *  message queue will have the name name.  If the attribute_set indicates
+ *  that the message queue is to be limited in the number of messages
+ *  that can be outstanding, then count indicates the maximum number of
+ *  messages that will be held.  It returns the id of the created
+ *  message queue in ID.
+ */
+
+rtems_status_code rtems_message_queue_create(
+  Objects_Name        name,
+  unsigned32          count,
+  rtems_attribute  attribute_set,
+  Objects_Id         *id
+);
+
+/*
+ *  rtems_message_queue_ident
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_message_queue_ident directive.
+ *  This directive returns the message queue ID associated with NAME.
+ *  If more than one message queue is named name, then the message
+ *  queue to which the ID belongs is arbitrary.  node indicates the
+ *  extent of the search for the ID of the message queue named name.
+ *  The search can be limited to a particular node or allowed to
+ *  encompass all nodes.
+ */
+
+rtems_status_code rtems_message_queue_ident(
+  Objects_Name  name,
+  unsigned32    node,
+  Objects_Id   *id
+);
+
+/*
+ *  rtems_message_queue_delete
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_message_queue_delete directive.  The
+ *  message queue indicated by ID is deleted.
+ */
+
+rtems_status_code rtems_message_queue_delete(
+  Objects_Id id
+);
+
+/*
+ *  rtems_message_queue_send
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_message_queue_send directive.
+ *  This directive sends the message buffer to the message queue
+ *  indicated by ID.  If one or more tasks is blocked waiting
+ *  to receive a message from this message queue, then one will
+ *  receive the message.  The task selected to receive the
+ *  message is based on the task queue discipline algorithm in
+ *  use by this particular message queue.  If no tasks are waiting,
+ *  then the message buffer will be placed at the rear of the
+ *  chain of pending messages for this message queue.
+ */
+
+rtems_status_code rtems_message_queue_send(
+  Objects_Id            id,
+  void                 *buffer
+);
+
+/*
+ *  rtems_message_queue_urgent
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_message_queue_send directive.
+ *  This directive sends the message buffer to the message queue
+ *  indicated by ID.  If one or more tasks is blocked waiting
+ *  to receive a message from this message queue, then one will
+ *  receive the message.  The task selected to receive the
+ *  message is based on the task queue discipline algorithm in
+ *  use by this particular message queue.  If no tasks are waiting,
+ *  then the message buffer will be placed at the rear of the
+ *  chain of pending messages for this message queue.
+ */
+
+rtems_status_code rtems_message_queue_urgent(
+  Objects_Id            id,
+  void                 *buffer
+);
+
+/*
+ *  rtems_message_queue_broadcast
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_message_queue_send directive.
+ *  This directive sends the message buffer to the message queue
+ *  indicated by ID.  If one or more tasks is blocked waiting
+ *  to receive a message from this message queue, then one will
+ *  receive the message.  The task selected to receive the
+ *  message is based on the task queue discipline algorithm in
+ *  use by this particular message queue.  If no tasks are waiting,
+ *  then the message buffer will be placed at the rear of the
+ *  chain of pending messages for this message queue.
+ */
+
+rtems_status_code rtems_message_queue_broadcast(
+  Objects_Id            id,
+  void                 *buffer,
+  unsigned32           *count
+);
+
+/*
+ *  rtems_message_queue_receive
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_message_queue_receive directive.
+ *  This directive is invoked when the calling task wishes to receive
+ *  a message from the message queue indicated by ID.  The received
+ *  message is to be placed in buffer.  If no messages are outstanding
+ *  and the option_set indicates that the task is willing to block,
+ *  then the task will be blocked until a message arrives or until,
+ *  optionally, timeout clock ticks have passed.
+ */
+
+rtems_status_code rtems_message_queue_receive(
+  Objects_Id            id,
+  void                 *buffer,
+  unsigned32            option_set,
+  rtems_interval     timeout
+);
+
+/*
+ *  rtems_message_queue_flush
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_message_queue_flush directive.
+ *  This directive takes all outstanding messages for the message
+ *  queue indicated by ID and returns them to the inactive message
+ *  chain.  The number of messages flushed is returned in COUNT.
+ */
+
+rtems_status_code rtems_message_queue_flush(
+  Objects_Id  id,
+  unsigned32 *count
+);
+
+/*
+ *  _Message_queue_Copy_buffer
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine copies the contents of the source message buffer
+ *  to the destination message buffer.
+ */
+
+STATIC INLINE void _Message_queue_Copy_buffer (
+  Message_queue_Buffer *source,
+  Message_queue_Buffer *destination
+);
+
+/*
+ *  _Message_queue_Seize
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine attempts to receive a message from the_message_queue.
+ *  If a message is available or if the RTEMS_NO_WAIT option is enabled in
+ *  option_set, then the routine returns.  Otherwise, the calling task
+ *  is blocked until a message is available.  If a message is returned
+ *  to the task, then buffer will contain its contents.
+ */
+
+boolean _Message_queue_Seize(
+  Message_queue_Control *the_message_queue,
+  unsigned32             option_set,
+  Message_queue_Buffer  *buffer
+);
+
+/*
+ *  _Message_queue_Flush_support
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine flushes all outstanding messages and returns
+ *  them to the inactive message chain.
+ */
+
+unsigned32 _Message_queue_Flush_support(
+  Message_queue_Control *the_message_queue
+);
+
+/*
+ *  _Message_queue_Submit
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine provides the common foundation for the
+ *  rtems_message_queue_send and rtems_message_queue_urgent directives.
+ */
+
+rtems_status_code _Message_queue_Submit(
+  Objects_Id                  id,
+  Message_queue_Buffer       *buffer,
+  Message_queue_Submit_types  submit_type
+);
+
+/*
+ *  _Message_queue_Allocate_message_buffer
+ *
+ *  DESCRIPTION:
+ *
+ *  This function allocates a message buffer from the inactive
+ *  message buffer chain.
+ */
+
+STATIC INLINE Message_queue_Buffer_control *
+  _Message_queue_Allocate_message_buffer ( void );
+
+/*
+ *  _Message_queue_Free_message_buffer
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine frees a message buffer to the inactive
+ *  message buffer chain.
+ */
+
+STATIC INLINE void _Message_queue_Free_message_buffer (
+  Message_queue_Buffer_control *the_message
+);
+
+/*
+ *  _Message_queue_Get_pending_message
+ *
+ *  DESCRIPTION:
+ *
+ *  This function removes the first message from the_message_queue
+ *  and returns a pointer to it.
+ */
+
+STATIC INLINE
+  Message_queue_Buffer_control *_Message_queue_Get_pending_message (
+  Message_queue_Control *the_message_queue
+);
+
+/*
+ *  _Message_queue_Append
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine places the_message at the rear of the outstanding
+ *  messages on the_message_queue.
+ */
+
+STATIC INLINE void _Message_queue_Append (
+  Message_queue_Control        *the_message_queue,
+  Message_queue_Buffer_control *the_message
+);
+
+/*
+ *  _Message_queue_Prepend
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine places the_message at the rear of the outstanding
+ *  messages on the_message_queue.
+ */
+
+STATIC INLINE void _Message_queue_Prepend (
+  Message_queue_Control        *the_message_queue,
+  Message_queue_Buffer_control *the_message
+);
+
+/*
+ *  _Message_queue_Is_null
+ *
+ *  DESCRIPTION:
+ *
+ *  This function places the_message at the rear of the outstanding
+ *  messages on the_message_queue.
+ */
+
+STATIC INLINE boolean _Message_queue_Is_null (
+  Message_queue_Control *the_message_queue
+);
+
+/*
+ *  _Message_queue_Allocate
+ *
+ *  DESCRIPTION:
+ *
+ *  This function allocates a message queue control block from
+ *  the inactive chain of free message queue control blocks.
+ */
+
+STATIC INLINE Message_queue_Control *_Message_queue_Allocate ( void );
+
+/*
+ *  _Message_queue_Free
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine allocates a message queue control block from
+ *  the inactive chain of free message queue control blocks.
+ */
+
+STATIC INLINE void _Message_queue_Free (
+  Message_queue_Control *the_message_queue
+);
+
+/*
+ *  _Message_queue_Get
+ *
+ *  DESCRIPTION:
+ *
+ *  This function maps message queue IDs to message queue control
+ *  blocks.  If ID corresponds to a local message queue, then it
+ *  returns the_message_queue control pointer which maps to ID
+ *  and location is set to OBJECTS_LOCAL.  If the message queue ID is
+ *  global and resides on a remote node, then location is set
+ *  to OBJECTS_REMOTE, and the_message_queue is undefined.
+ *  Otherwise, location is set to OBJECTS_ERROR and
+ *  the_message_queue is undefined.
+ */
+
+STATIC INLINE Message_queue_Control *_Message_queue_Get (
+  Objects_Id         id,
+  Objects_Locations *location
+);
+
+#include <rtems/message.inl>
+#include <rtems/msgmp.h>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/include/rtems/rtems/modes.h

@@ -0,0 +1,183 @@
+/*  modes.h
+ *
+ *  This include file contains all constants and structures associated
+ *  with the RTEMS thread and RTEMS_ASR modes.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_MODES_h
+#define __RTEMS_MODES_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/isr.h>
+
+/*
+ *  The following type defines the control block used to manage
+ *  each a mode set.
+ */
+
+typedef unsigned32 rtems_mode;
+
+/*
+ *  The following constants define the individual modes and masks
+ *  which may be used to compose a mode set and to alter modes.
+ */
+
+#define RTEMS_ALL_MODE_MASKS     0x0000ffff
+
+#define RTEMS_DEFAULT_MODES     0x00000000
+#define RTEMS_CURRENT_MODE      0
+
+#define RTEMS_PREEMPT_MASK    0x00000100  /* preemption bit           */
+#define RTEMS_TIMESLICE_MASK  0x00000200  /* timeslice bit            */
+#define RTEMS_ASR_MASK        0x00000400  /* RTEMS_ASR enable bit           */
+#define RTEMS_INTERRUPT_MASK  CPU_MODES_INTERRUPT_MASK
+
+#define RTEMS_PREEMPT      0x00000000     /* enable preemption        */
+#define RTEMS_NO_PREEMPT   0x00000100     /* disable preemption       */
+
+#define RTEMS_NO_TIMESLICE 0x00000000     /* disable timeslicing      */
+#define RTEMS_TIMESLICE    0x00000200     /* enable timeslicing       */
+
+#define RTEMS_ASR          0x00000000     /* enable RTEMS_ASR               */
+#define RTEMS_NO_ASR       0x00000400     /* disable RTEMS_ASR              */
+
+/*
+ *  The number of bits for interrupt levels is CPU dependent.
+ *  RTEMS supports 0 to 256 levels in bits 0-7 of the mode.
+ */
+
+/*
+ *  RTEMS_INTERRUPT_LEVEL
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns the processor dependent interrupt
+ *  level which corresponds to the requested interrupt level.
+ *
+ * NOTE: RTEMS supports 256 interrupt levels using the least
+ *       significant eight bits of MODES.CONTROL.  On any
+ *       particular CPU, fewer than 256 levels may be supported.
+ */
+
+STATIC INLINE unsigned32 RTEMS_INTERRUPT_LEVEL (
+  rtems_mode mode_set
+);
+
+/*
+ *  _Modes_Mask_changed
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if any of the mode flags in mask
+ *  are set in mode_set, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Modes_Mask_changed (
+  rtems_mode mode_set,
+  rtems_mode masks
+);
+
+/*
+ *  _Modes_Is_asr_disabled
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if mode_set indicates that Asynchronous
+ *  Signal Processing is disabled, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Modes_Is_asr_disabled (
+  rtems_mode mode_set
+);
+
+/*
+ *  _Modes_Is_preempt
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if mode_set indicates that preemption
+ *  is enabled, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Modes_Is_preempt (
+  rtems_mode mode_set
+);
+
+/*
+ *  _Modes_Is_timeslice
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if mode_set indicates that timeslicing
+ *  is enabled, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Modes_Is_timeslice (
+  rtems_mode mode_set
+);
+
+/*
+ *  _Modes_Get_interrupt_level
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns the interrupt level portion of the mode_set.
+ */
+
+STATIC INLINE ISR_Level _Modes_Get_interrupt_level (
+  rtems_mode mode_set
+);
+
+/*
+ *  _Modes_Set_interrupt_level
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine sets the current interrupt level to that specified
+ *  in the mode_set.
+ */
+
+STATIC INLINE void _Modes_Set_interrupt_level (
+  rtems_mode mode_set
+);
+
+/*
+ *  _Modes_Change
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine changes the modes in old_mode_set indicated by
+ *  mask to the requested values in new_mode_set.  The resulting
+ *  mode set is returned in out_mode_set and the modes that changed
+ *  is returned in changed.
+ */
+
+STATIC INLINE void _Modes_Change (
+  rtems_mode  old_mode_set,
+  rtems_mode  new_mode_set,
+  rtems_mode  mask,
+  rtems_mode *out_mode_set,
+  rtems_mode *changed
+);
+
+#include <rtems/modes.inl>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/include/rtems/rtems/mp.h

@@ -0,0 +1,67 @@
+/*  mp.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the Multiprocessing Manager.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_MP_h
+#define __RTEMS_MP_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ *
+ *  _Multiprocessing_Manager_initialization
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the initialization necessary for this manager.
+ */
+
+void _Multiprocessing_Manager_initialization ( void );
+
+/*
+ *
+ *  rtems_multiprocessing_announce
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the MULTIPROCESSING_ANNOUNCE directive.
+ *  It is invoked by the MPCI layer to indicate that an MPCI packet
+ *  has been received.
+ */
+
+void rtems_multiprocessing_announce ( void );
+
+/*
+ *
+ *  _Multiprocessing_Receive_server
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is a server thread which processes remote requests
+ *  from other nodes.
+ */
+
+Thread _Multiprocessing_Receive_server (
+  Thread_Argument ignored
+);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/*  end of include file */

c/src/exec/rtems/include/rtems/rtems/msgmp.h

@@ -0,0 +1,175 @@
+/*  msgmp.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the Multiprocessing Support in the Message Manager.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_MESSAGE_QUEUE_MP_h
+#define __RTEMS_MESSAGE_QUEUE_MP_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/message.h>
+#include <rtems/mppkt.h>
+#include <rtems/object.h>
+#include <rtems/options.h>
+#include <rtems/thread.h>
+#include <rtems/watchdog.h>
+
+/*
+ *  The following enumerated type defines the list of
+ *  remote message queue operations.
+ */
+
+typedef enum {
+  MESSAGE_QUEUE_MP_ANNOUNCE_CREATE     =  0,
+  MESSAGE_QUEUE_MP_ANNOUNCE_DELETE     =  1,
+  MESSAGE_QUEUE_MP_EXTRACT_PROXY       =  2,
+  MESSAGE_QUEUE_MP_RECEIVE_REQUEST     =  3,
+  MESSAGE_QUEUE_MP_RECEIVE_RESPONSE    =  4,
+  MESSAGE_QUEUE_MP_SEND_REQUEST        =  5,
+  MESSAGE_QUEUE_MP_SEND_RESPONSE       =  6,
+  MESSAGE_QUEUE_MP_URGENT_REQUEST      =  7,
+  MESSAGE_QUEUE_MP_URGENT_RESPONSE     =  8,
+  MESSAGE_QUEUE_MP_BROADCAST_REQUEST   =  9,
+  MESSAGE_QUEUE_MP_BROADCAST_RESPONSE  = 10,
+  MESSAGE_QUEUE_MP_FLUSH_REQUEST       = 11,
+  MESSAGE_QUEUE_MP_FLUSH_RESPONSE      = 12
+}   Message_queue_MP_Remote_operations;
+
+/*
+ *  The following data structure defines the packet used to perform
+ *  remote message queue operations.
+ */
+
+typedef struct {
+  rtems_packet_prefix                   Prefix;
+  Message_queue_MP_Remote_operations operation;
+  Objects_Name                       name;
+  rtems_option                    option_set;
+  Objects_Id                         proxy_id;
+  unsigned32                         count;
+  unsigned32                         pad0;
+  unsigned32                         pad1;
+  unsigned32                         pad2;
+  Message_queue_Buffer               Buffer;
+}   Message_queue_MP_Packet;
+
+/*
+ *  _Message_queue_MP_Send_process_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  process operation can be performed on another node.
+ */
+
+void _Message_queue_MP_Send_process_packet (
+  Message_queue_MP_Remote_operations operation,
+  Objects_Id                         message_queue_id,
+  Objects_Name                       name,
+  Objects_Id                         proxy_id
+);
+
+/*
+ *  _Message_queue_MP_Send_request_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  directive operation can be initiated on another node.
+ */
+
+rtems_status_code _Message_queue_MP_Send_request_packet (
+  Message_queue_MP_Remote_operations  operation,
+  Objects_Id                          message_queue_id,
+  Message_queue_Buffer               *buffer,
+  rtems_option                     option_set,
+  rtems_interval                   timeout
+);
+
+/*
+ *  _Message_queue_MP_Send_response_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  directive can be performed on another node.
+ */
+
+void _Message_queue_MP_Send_response_packet (
+  Message_queue_MP_Remote_operations  operation,
+  Objects_Id                          message_queue_id,
+  Thread_Control                     *the_thread
+);
+
+/*
+ *
+ *  _Message_queue_MP_Process_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the actions specific to this package for
+ *  the request from another node.
+ */
+
+void _Message_queue_MP_Process_packet (
+  rtems_packet_prefix *the_packet_prefix
+);
+
+/*
+ *  _Message_queue_MP_Send_object_was_deleted
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked indirectly by the thread queue
+ *  when a proxy has been removed from the thread queue and
+ *  the remote node must be informed of this.
+ */
+
+void _Message_queue_MP_Send_object_was_deleted (
+  Thread_Control *the_proxy
+);
+
+/*
+ *  _Message_queue_MP_Send_extract_proxy
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked when a task is deleted and it
+ *  has a proxy which must be removed from a thread queue and
+ *  the remote node must be informed of this.
+ */
+
+void _Message_queue_MP_Send_extract_proxy (
+  Thread_Control *the_thread
+);
+
+/*
+ *  _Message_queue_MP_Get_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This function is used to obtain a message queue mp packet.
+ */
+
+Message_queue_MP_Packet *_Message_queue_MP_Get_packet ( void );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of file */

c/src/exec/rtems/include/rtems/rtems/options.h

@@ -0,0 +1,79 @@
+/*  options.h
+ *
+ *  This include file contains information which defines the
+ *  options available on many directives.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_OPTIONS_h
+#define __RTEMS_OPTIONS_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ *  The following type defines the control block used to manage
+ *  option sets.
+ */
+
+typedef unsigned32 rtems_option;
+
+/*
+ *  The following constants define the individual options which may
+ *  be used to compose an option set.
+ */
+
+#define RTEMS_DEFAULT_OPTIONS   0x00000000
+
+#define RTEMS_WAIT      0x00000000        /* wait on resource */
+#define RTEMS_NO_WAIT   0x00000001        /* do not wait on resource */
+
+#define RTEMS_EVENT_ALL 0x00000000        /* wait for all events */
+#define RTEMS_EVENT_ANY 0x00000002        /* wait on any event */
+
+/*
+ *  _Options_Is_no_wait
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the RTEMS_NO_WAIT option is enabled in
+ *  option_set, and FALSE otherwise.
+ *
+ */
+
+STATIC INLINE boolean _Options_Is_no_wait (
+  rtems_option option_set
+);
+
+/*
+ *  _Options_Is_any
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the RTEMS_EVENT_ANY option is enabled in
+ *  OPTION_SET, and FALSE otherwise.
+ *
+ */
+
+STATIC INLINE boolean _Options_Is_any (
+  rtems_option option_set
+);
+
+#include <rtems/options.inl>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/include/rtems/rtems/part.h

@@ -0,0 +1,290 @@
+/*  partition.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the Partition Manager.  This manager provides facilities to
+ *  dynamically allocate memory in fixed-sized units which are returned
+ *  as buffers.
+ *
+ *  Directives provided are:
+ *
+ *     + create a partition
+ *     + get an ID of a partition
+ *     + delete a partition
+ *     + get a buffer from a partition
+ *     + return a buffer to a partition
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_PARTITION_h
+#define __RTEMS_PARTITION_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/address.h>
+#include <rtems/attr.h>
+#include <rtems/object.h>
+
+/*
+ *  The following defines the control block used to manage each partition.
+ */
+
+typedef struct {
+  Objects_Control     Object;
+  void               *starting_address;      /* physical address */
+  unsigned32          length;                /* in bytes */
+  unsigned32          buffer_size;           /* in bytes */
+  rtems_attribute  attribute_set;         /* attributes */
+  unsigned32          number_of_used_blocks; /* or allocated buffers */
+  Chain_Control       Memory;                /* buffer chain */
+}   Partition_Control;
+
+/*
+ *  The following defines the information control block used to
+ *  manage this class of objects.
+ */
+
+EXTERN Objects_Information _Partition_Information;
+
+/*
+ *  _Partition_Manager_initialization
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the initialization necessary for this manager.
+ */
+
+void _Partition_Manager_initialization(
+  unsigned32 maximum_partitions
+);
+
+/*
+ *  rtems_partition_create
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_partition_create directive.  The
+ *  partition will have the name name.  The memory area managed by
+ *  the partition is of length bytes and starts at starting_address.
+ *  The memory area will be divided into as many buffers of
+ *  buffer_size bytes as possible.   The attribute_set determines if
+ *  the partition is global or local.  It returns the id of the
+ *  created partition in ID.
+ */
+
+rtems_status_code rtems_partition_create(
+  Objects_Name        name,
+  void               *starting_address,
+  unsigned32          length,
+  unsigned32          buffer_size,
+  rtems_attribute  attribute_set,
+  Objects_Id         *id
+);
+
+/*
+ *  rtems_partition_ident
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_partition_ident directive.
+ *  This directive returns the partition ID associated with name.
+ *  If more than one partition is named name, then the partition
+ *  to which the ID belongs is arbitrary.  node indicates the
+ *  extent of the search for the ID of the partition named name.
+ *  The search can be limited to a particular node or allowed to
+ *  encompass all nodes.
+ */
+
+rtems_status_code rtems_partition_ident(
+  Objects_Name  name,
+  unsigned32    node,
+  Objects_Id   *id
+);
+
+/*
+ *  rtems_partition_delete
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_partition_delete directive.  The
+ *  partition indicated by ID is deleted.
+ */
+
+rtems_status_code rtems_partition_delete(
+  Objects_Id id
+);
+
+/*
+ *  rtems_partition_get_buffer
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_partition_get_buffer directive.  It
+ *  attempts to allocate a buffer from the partition associated with ID.
+ *  If a buffer is allocated, its address is returned in buffer.
+ */
+
+rtems_status_code rtems_partition_get_buffer(
+  Objects_Id  id,
+  void       **buffer
+);
+
+/*
+ *  rtems_partition_return_buffer
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_partition_return_buffer directive.  It
+ *  frees the buffer to the partition associated with ID.  The buffer must
+ *  have been previously allocated from the same partition.
+ */
+
+rtems_status_code rtems_partition_return_buffer(
+  Objects_Id  id,
+  void       *buffer
+);
+
+/*
+ *  _Partition_Allocate_buffer
+ *
+ *  DESCRIPTION:
+ *
+ *  This function attempts to allocate a buffer from the_partition.
+ *  If successful, it returns the address of the allocated buffer.
+ *  Otherwise, it returns NULL.
+ */
+
+STATIC INLINE void *_Partition_Allocate_buffer (
+   Partition_Control *the_partition
+);
+
+/*
+ *  _Partition_Free_buffer
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine frees the_buffer to the_partition.
+ */
+
+STATIC INLINE void _Partition_Free_buffer (
+  Partition_Control *the_partition,
+  Chain_Node        *the_buffer
+);
+
+/*
+ *  _Partition_Is_buffer_on_boundary
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_buffer is on a valid buffer
+ *  boundary for the_partition, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Partition_Is_buffer_on_boundary (
+  void              *the_buffer,
+  Partition_Control *the_partition
+);
+
+/*
+ *  _Partition_Is_buffer_valid
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_buffer is a valid buffer from
+ *  the_partition, otherwise FALSE is returned.
+ */
+
+STATIC INLINE boolean _Partition_Is_buffer_valid (
+  Chain_Node        *the_buffer,
+  Partition_Control *the_partition
+);
+
+/*
+ *  _Partition_Is_buffer_size_aligned
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the use of the specified buffer_size
+ *  will result in the allocation of buffers whose first byte is
+ *  properly aligned, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Partition_Is_buffer_size_aligned (
+  unsigned32 buffer_size
+);
+
+/*
+ *  _Partition_Allocate
+ *
+ *  DESCRIPTION:
+ *
+ *  This function allocates a partition control block from
+ *  the inactive chain of free partition control blocks.
+ */
+
+STATIC INLINE Partition_Control *_Partition_Allocate ( void );
+
+/*
+ *  _Partition_Free
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine frees a partition control block to the
+ *  inactive chain of free partition control blocks.
+ */
+
+STATIC INLINE void _Partition_Free (
+  Partition_Control *the_partition
+);
+
+/*
+ *  _Partition_Get
+ *
+ *  DESCRIPTION:
+ *
+ *  This function maps partition IDs to partition control blocks.
+ *  If ID corresponds to a local partition, then it returns
+ *  the_partition control pointer which maps to ID and location
+ *  is set to OBJECTS_LOCAL.  If the partition ID is global and
+ *  resides on a remote node, then location is set to OBJECTS_REMOTE,
+ *  and the_partition is undefined.  Otherwise, location is set
+ *  to OBJECTS_ERROR and the_partition is undefined.
+ */
+
+STATIC INLINE Partition_Control *_Partition_Get (
+  Objects_Id         id,
+  Objects_Locations *location
+);
+
+/*
+ *  _Partition_Is_null
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_partition is NULL
+ *  and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Partition_Is_null (
+  Partition_Control *the_partition
+);
+
+#include <rtems/part.inl>
+#include <rtems/partmp.h>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/include/rtems/rtems/partmp.h

@@ -0,0 +1,160 @@
+/*  partmp.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the Multiprocessing Support in the Partition Manager.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_PARTITION_MP_h
+#define __RTEMS_PARTITION_MP_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/mppkt.h>
+#include <rtems/object.h>
+#include <rtems/options.h>
+#include <rtems/part.h>
+#include <rtems/thread.h>
+
+/*
+ *  The following enumerated type defines the list of
+ *  remote partition operations.
+ */
+
+typedef enum {
+  PARTITION_MP_ANNOUNCE_CREATE        =  0,
+  PARTITION_MP_ANNOUNCE_DELETE        =  1,
+  PARTITION_MP_EXTRACT_PROXY          =  2,
+  PARTITION_MP_GET_BUFFER_REQUEST     =  3,
+  PARTITION_MP_GET_BUFFER_RESPONSE    =  4,
+  PARTITION_MP_RETURN_BUFFER_REQUEST  =  5,
+  PARTITION_MP_RETURN_BUFFER_RESPONSE =  6,
+}   Partition_MP_Remote_operations;
+
+/*
+ *  The following data structure defines the packet used to perform
+ *  remote partition operations.
+ */
+
+typedef struct {
+  rtems_packet_prefix                Prefix;
+  Partition_MP_Remote_operations  operation;
+  Objects_Name                    name;
+  void                           *buffer;
+  Objects_Id                      proxy_id;
+}   Partition_MP_Packet;
+
+/*
+ *  _Partition_MP_Send_process_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  process operation can be performed on another node.
+ */
+
+void _Partition_MP_Send_process_packet (
+  Partition_MP_Remote_operations operation,
+  Objects_Id                     partition_id,
+  Objects_Name                   name,
+  Objects_Id                     proxy_id
+);
+
+/*
+ *  _Partition_MP_Send_request_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  directive operation can be initiated on another node.
+ */
+
+rtems_status_code _Partition_MP_Send_request_packet (
+  Partition_MP_Remote_operations  operation,
+  Objects_Id                      partition_id,
+  void                           *buffer
+);
+
+/*
+ *  _Partition_MP_Send_response_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  directive can be performed on another node.
+ */
+
+void _Partition_MP_Send_response_packet (
+  Partition_MP_Remote_operations  operation,
+  Objects_Id                      partition_id,
+  Thread_Control                 *the_thread
+);
+
+/*
+ *
+ *  _Partition_MP_Process_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the actions specific to this package for
+ *  the request from another node.
+ */
+
+void _Partition_MP_Process_packet (
+  rtems_packet_prefix *the_packet_prefix
+);
+
+/*
+ *  _Partition_MP_Send_object_was_deleted
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked indirectly by the thread queue
+ *  when a proxy has been removed from the thread queue and
+ *  the remote node must be informed of this.
+ *
+ *  This routine is not needed by the Partition since a partition
+ *  cannot be deleted when buffers are in use.
+ */
+
+/*
+ *  _Partition_MP_Send_extract_proxy
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked when a task is deleted and it
+ *  has a proxy which must be removed from a thread queue and
+ *  the remote node must be informed of this.
+ */
+
+void _Partition_MP_Send_extract_proxy (
+  Thread_Control *the_thread
+);
+
+/*
+ *  _Partition_MP_Get_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This function is used to obtain a partition mp packet.
+ */
+
+Partition_MP_Packet *_Partition_MP_Get_packet ( void );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of file */

c/src/exec/rtems/include/rtems/rtems/ratemon.h

@@ -0,0 +1,285 @@
+/*  ratemon.h
+ *
+ *  This include file contains all the constants, structures, and
+ *  prototypes associated with the Rate Monotonic Manager.  This manager
+ *  provides facilities to implement tasks which execute in a periodic fashion.
+ *
+ *  Directives provided are:
+ *
+ *     + create a rate monotonic timer
+ *     + cancel a period
+ *     + delete a rate monotonic timer
+ *     + conclude current and start the next period
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_RATE_MONOTONIC_h
+#define __RTEMS_RATE_MONOTONIC_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/object.h>
+#include <rtems/thread.h>
+#include <rtems/watchdog.h>
+
+/*
+ *  The following enumerated type defines the states in which a
+ *  period may be.
+ */
+
+typedef enum {
+  RATE_MONOTONIC_INACTIVE,  /* off chain, never initialized */
+  RATE_MONOTONIC_ACTIVE,    /* on chain, running continuously */
+  RATE_MONOTONIC_EXPIRED    /* off chain, will be reset by next rm_period */
+}   Rate_Monotonic_Period_states;
+
+/*
+ *  The following constant is the interval passed to the rate_monontonic_period
+ *  directive to obtain status information.
+ */
+
+#define RTEMS_PERIOD_STATUS       RTEMS_NO_TIMEOUT
+
+/*
+ *  The following structure defines the control block used to manage
+ *  each period.
+ */
+
+typedef struct {
+  Objects_Control               Object;
+  Watchdog_Control              Timer;
+  Rate_Monotonic_Period_states  state;
+  Thread_Control               *owner;
+}   Rate_monotonic_Control;
+
+EXTERN Objects_Information _Rate_monotonic_Information;
+
+/*
+ *  _Rate_monotonic_Manager_initialization
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the initialization necessary for this manager.
+ */
+
+void _Rate_monotonic_Manager_initialization(
+  unsigned32 maximum_periods
+);
+
+/*
+ *  rtems_rate_monotonic_create
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rate_monotonic_create directive.  The
+ *  period will have the name name.  It returns the id of the
+ *  created period in ID.
+ */
+
+rtems_status_code rtems_rate_monotonic_create(
+  Objects_Name  name,
+  Objects_Id   *id
+);
+
+/*
+ *  rtems_rate_monotonic_ident
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_rate_monotonic_ident directive.
+ *  This directive returns the period ID associated with name.
+ *  If more than one period is named name, then the period
+ *  to which the ID belongs is arbitrary.
+ */
+
+rtems_status_code rtems_rate_monotonic_ident(
+  Objects_Name  name,
+  Objects_Id   *id
+);
+
+/*
+ *  rtems_rate_monotonic_cancel
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_rate_monotonic_cancel directive.  This
+ *  directive stops the period associated with ID from continuing to
+ *  run.
+ */
+
+rtems_status_code rtems_rate_monotonic_cancel(
+  Objects_Id id
+);
+
+/*
+ *  rtems_rate_monotonic_delete
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_rate_monotonic_delete directive.  The
+ *  period indicated by ID is deleted.
+ */
+
+rtems_status_code rtems_rate_monotonic_delete(
+  Objects_Id id
+);
+
+/*
+ *  rtems_rate_monotonic_period
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_rate_monotonic_period directive.  When
+ *  length is non-zero, this directive initiates the period associated with
+ *  ID from continuing for a period of length.  If length is zero, then
+ *  result is set to indicate the current state of the period.
+ */
+
+rtems_status_code rtems_rate_monotonic_period(
+  Objects_Id        id,
+  rtems_interval length
+);
+
+/*
+ *  _Rate_monotonic_Allocate
+ *
+ *  DESCRIPTION:
+ *
+ *  This function allocates a period control block from
+ *  the inactive chain of free period control blocks.
+ */
+
+STATIC INLINE Rate_monotonic_Control *_Rate_monotonic_Allocate( void );
+
+/*
+ *  _Rate_monotonic_Free
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine allocates a period control block from
+ *  the inactive chain of free period control blocks.
+ */
+
+STATIC INLINE void _Rate_monotonic_Free (
+  Rate_monotonic_Control *the_period
+);
+
+/*
+ *  _Rate_monotonic_Get
+ *
+ *  DESCRIPTION:
+ *
+ *  This function maps period IDs to period control blocks.
+ *  If ID corresponds to a local period, then it returns
+ *  the_period control pointer which maps to ID and location
+ *  is set to OBJECTS_LOCAL.  Otherwise, location is set
+ *  to OBJECTS_ERROR and the_period is undefined.
+ */
+
+STATIC INLINE Rate_monotonic_Control *_Rate_monotonic_Get (
+  Objects_Id         id,
+  Objects_Locations *location
+);
+
+/*
+ *  _Rate_monotonic_Set_state
+ *
+ *  DESCRIPTION:
+ *
+ *  This function blocks the calling task so that it is waiting for
+ *  a period to expire.  It returns TRUE if the task was successfully
+ *  blocked, and FALSE otherwise.
+ */
+
+boolean _Rate_monotonic_Set_state(
+  Rate_monotonic_Control *the_period
+);
+
+/*
+ *  _Rate_monotonic_Timeout
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked when the period represented
+ *  by ID expires.  If the task which owns this period is blocked
+ *  waiting for the period to expire, then it is readied and the
+ *  period is restarted.  If the owning task is not waiting for the
+ *  period to expire, then the period is placed in the EXPIRED
+ *  state and not restarted.
+ */
+
+void _Rate_monotonic_Timeout (
+  Objects_Id  id,
+  void       *ignored
+);
+
+/*
+ *  _Rate_monotonic_Is_active
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_period is in the ACTIVE state,
+ *  and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Rate_monotonic_Is_active (
+  Rate_monotonic_Control *the_period
+);
+
+/*
+ *  _Rate_monotonic_Is_inactive
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_period is in the ACTIVE state,
+ *  and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Rate_monotonic_Is_inactive (
+  Rate_monotonic_Control *the_period
+);
+
+/*
+ *  _Rate_monotonic_Is_expired
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_period is in the EXPIRED state,
+ *  and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Rate_monotonic_Is_expired (
+  Rate_monotonic_Control *the_period
+);
+
+/*
+ *  _Rate_monotonic_Is_null
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_period is NULL and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Rate_monotonic_Is_null (
+  Rate_monotonic_Control *the_period
+);
+
+#include <rtems/ratemon.inl>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/include/rtems/rtems/region.h

@@ -0,0 +1,311 @@
+/*  region.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the Region Manager.  This manager provides facilities to dynamically
+ *  allocate memory in variable sized units which are returned as segments.
+ *
+ *  Directives provided are:
+ *
+ *     + create a region
+ *     + get an ID of a region
+ *     + delete a region
+ *     + get a segment from a region
+ *     + return a segment to a region
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_REGION_h
+#define __RTEMS_REGION_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/object.h>
+#include <rtems/threadq.h>
+#include <rtems/heap.h>
+#include <rtems/debug.h>
+
+/*
+ *  The following records define the control block used to manage
+ *  each region.
+ */
+
+typedef struct {
+  Objects_Control       Object;
+  Thread_queue_Control  Wait_queue;            /* waiting threads        */
+  void                 *starting_address;      /* physical start addr    */
+  unsigned32            length;                /* physical length(bytes) */
+  unsigned32            page_size;             /* in bytes               */
+  unsigned32            maximum_segment_size;  /* in bytes               */
+  rtems_attribute       attribute_set;
+  unsigned32            number_of_used_blocks; /* blocks allocated       */
+  Heap_Control          Memory;
+}  Region_Control;
+
+/*
+ *  The following defines the information control block used to
+ *  manage this class of objects.
+ */
+
+EXTERN Objects_Information _Region_Information;
+
+/*
+ *  _Region_Manager_initialization
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the initialization necessary for this manager.
+ */
+
+void _Region_Manager_initialization(
+  unsigned32 maximum_regions
+);
+
+/*
+ *  rtems_region_create
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_region_create directive.  The
+ *  region will have the name name.  The memory area managed by
+ *  the region is of length bytes and starts at starting_address.
+ *  The memory area will be divided into as many allocatable units of
+ *  page_size bytes as possible.   The attribute_set determines which
+ *  thread queue discipline is used by the region.  It returns the
+ *  id of the created region in ID.
+ */
+
+rtems_status_code rtems_region_create(
+  Objects_Name        name,
+  void               *starting_address,
+  unsigned32          length,
+  unsigned32          page_size,
+  rtems_attribute  attribute_set,
+  Objects_Id         *id
+);
+
+/*
+ *  rtems_region_extend
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_region_extend directive.  The
+ *  region will have the name name.  The memory area managed by
+ *  the region will be attempted to be grown by length bytes using
+ *  the memory starting at starting_address.
+ */
+
+rtems_status_code rtems_region_extend(
+  Objects_Id          id,
+  void               *starting_address,
+  unsigned32          length
+);
+
+/*
+ *  rtems_region_ident
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_region_ident directive.
+ *  This directive returns the region ID associated with name.
+ *  If more than one region is named name, then the region
+ *  to which the ID belongs is arbitrary.
+ */
+
+rtems_status_code rtems_region_ident(
+  Objects_Name  name,
+  Objects_Id   *id
+);
+
+/*
+ *  rtems_region_delete
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_region_delete directive.  The
+ *  region indicated by ID is deleted.
+ */
+
+rtems_status_code rtems_region_delete(
+  Objects_Id id
+);
+
+/*
+ *  rtems_region_get_segment
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_region_get_segment directive.  It
+ *  attempts to allocate a segment from the region associated with ID.
+ *  If a segment of the requested size can be allocated, its address
+ *  is returned in segment.  If no segment is available, then the task
+ *  may return immediately or block waiting for a segment with an optional
+ *  timeout of timeout clock ticks.  Whether the task blocks or returns
+ *  immediately is based on the no_wait option in the option_set.
+ */
+
+rtems_status_code rtems_region_get_segment(
+  Objects_Id         id,
+  unsigned32         size,
+  rtems_option    option_set,
+  rtems_interval  timeout,
+  void              **segment
+);
+
+/*
+ *  rtems_region_get_segment_size
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_region_get_segment_size directive.  It
+ *  returns the size in bytes of the specified user memory area.
+ */
+
+rtems_status_code rtems_region_get_segment_size(
+  Objects_Id         id,
+  void              *segment,
+  unsigned32        *size
+);
+
+/*
+ *  rtems_region_return_segment
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_region_return_segment directive.  It
+ *  frees the segment to the region associated with ID.  The segment must
+ *  have been previously allocated from the same region.  If freeing the
+ *  segment results in enough memory being available to satisfy the
+ *  rtems_region_get_segment of the first blocked task, then that task and as
+ *  many subsequent tasks as possible will be unblocked with their requests
+ *  satisfied.
+ */
+
+rtems_status_code rtems_region_return_segment(
+  Objects_Id  id,
+  void       *segment
+);
+
+/*
+ *  _Region_Allocate
+ *
+ *  DESCRIPTION:
+ *
+ *  This function allocates a region control block from
+ *  the inactive chain of free region control blocks.
+ */
+
+STATIC INLINE Region_Control *_Region_Allocate( void );
+
+/*
+ *  _Region_Free
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine frees a region control block to the
+ *  inactive chain of free region control blocks.
+ */
+
+STATIC INLINE void _Region_Free (
+  Region_Control *the_region
+);
+
+/*
+ *  _Region_Get
+ *
+ *  DESCRIPTION:
+ *
+ *  This function maps region IDs to region control blocks.
+ *  If ID corresponds to a local region, then it returns
+ *  the_region control pointer which maps to ID and location
+ *  is set to OBJECTS_LOCAL.  Otherwise, location is set
+ *  to OBJECTS_ERROR and the_region is undefined.
+ */
+
+STATIC INLINE Region_Control *_Region_Get (
+  Objects_Id         id,
+  Objects_Locations *location
+);
+
+/*
+ *  _Region_Allocate_segment
+ *
+ *  DESCRIPTION:
+ *
+ *  This function attempts to allocate a segment from the_region.
+ *  If successful, it returns the address of the allocated segment.
+ *  Otherwise, it returns NULL.
+ */
+
+STATIC INLINE void *_Region_Allocate_segment (
+  Region_Control *the_region,
+  unsigned32      size
+);
+
+/*
+ *  _Region_Free_segment
+ *
+ *  DESCRIPTION:
+ *
+ *  This function frees the_segment to the_region.
+ */
+
+STATIC INLINE boolean _Region_Free_segment (
+  Region_Control *the_region,
+  void           *the_segment
+);
+
+/*
+ *  _Region_Is_null
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_region is NULL and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Region_Is_null (
+  Region_Control *the_region
+);
+
+#include <rtems/region.inl>
+#include <rtems/regionmp.h>
+
+/*
+ *  _Region_Debug_Walk
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked to verify the integrity of a heap associated
+ *  with the_region.
+ */
+
+#ifdef RTEMS_DEBUG
+
+#define _Region_Debug_Walk( _the_region, _source ) \
+  do { \
+    if ( _Debug_Is_enabled( RTEMS_DEBUG_REGION ) ) \
+      _Heap_Walk( &(_the_region)->Memory, _source, FALSE ); \
+  } while ( 0 )
+
+#else
+
+#define _Region_Debug_Walk( _the_region, _source )
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/include/rtems/rtems/regionmp.h

@@ -0,0 +1,165 @@
+/*  regionmp.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the Multiprocessing Support in the Region Manager.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_REGION_MP_h
+#define __RTEMS_REGION_MP_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/mppkt.h>
+#include <rtems/object.h>
+#include <rtems/options.h>
+#include <rtems/region.h>
+#include <rtems/thread.h>
+
+/*
+ *  The following enumerated type defines the list of
+ *  remote region operations.
+ */
+
+typedef enum {
+  REGION_MP_ANNOUNCE_CREATE         =  0,
+  REGION_MP_ANNOUNCE_DELETE         =  1,
+  REGION_MP_EXTRACT_PROXY           =  2,
+  REGION_MP_GET_SEGMENT_REQUEST     =  3,
+  REGION_MP_GET_SEGMENT_RESPONSE    =  4,
+  REGION_MP_RETURN_SEGMENT_REQUEST  =  5,
+  REGION_MP_RETURN_SEGMENT_RESPONSE =  6,
+}   Region_MP_Remote_operations;
+
+/*
+ *  The following data structure defines the packet used to perform
+ *  remote region operations.
+ */
+
+typedef struct {
+  rtems_packet_prefix             Prefix;
+  Region_MP_Remote_operations  operation;
+  Objects_Name                 name;
+  rtems_option              option_set;
+  unsigned32                   size;
+  Objects_Id                   proxy_id;
+  void                        *segment;
+}   Region_MP_Packet;
+
+/*
+ *  _Region_MP_Send_process_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  process operation can be performed on another node.
+ */
+
+void _Region_MP_Send_process_packet (
+  Region_MP_Remote_operations operation,
+  Objects_Id                  region_id,
+  Objects_Name                name,
+  Objects_Id                  proxy_id
+);
+
+/*
+ *  _Region_MP_Send_request_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  directive operation can be initiated on another node.
+ */
+
+rtems_status_code _Region_MP_Send_request_packet (
+  Region_MP_Remote_operations  operation,
+  Objects_Id                   region_id,
+  void                        *segment,
+  unsigned32                   size,
+  rtems_option              option_set,
+  rtems_interval            timeout
+);
+
+/*
+ *  _Region_MP_Send_response_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  directive can be performed on another node.
+ */
+
+void _Region_MP_Send_response_packet (
+  Region_MP_Remote_operations  operation,
+  Objects_Id                   region_id,
+  Thread_Control              *the_thread
+);
+
+/*
+ *
+ *  _Region_MP_Process_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the actions specific to this package for
+ *  the request from another node.
+ */
+
+void _Region_MP_Process_packet (
+  rtems_packet_prefix *the_packet_prefix
+);
+
+/*
+ *  _Region_MP_Send_object_was_deleted
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked indirectly by the thread queue
+ *  when a proxy has been removed from the thread queue and
+ *  the remote node must be informed of this.
+ *
+ *  This routine is not needed by the Region since a region
+ *  cannot be deleted when segments are in use.
+ */
+
+/*
+ *  _Region_MP_Send_extract_proxy
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked when a task is deleted and it
+ *  has a proxy which must be removed from a thread queue and
+ *  the remote node must be informed of this.
+ */
+
+void _Region_MP_Send_extract_proxy (
+  Thread_Control *the_thread
+);
+
+/*
+ *  _Region_MP_Get_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This function is used to obtain a region mp packet.
+ */
+
+Region_MP_Packet *_Region_MP_Get_packet ( void );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of file */

c/src/exec/rtems/include/rtems/rtems/sem.h

@@ -0,0 +1,238 @@
+/*  semaphore.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the Semaphore Manager.  This manager utilizes standard Dijkstra
+ *  counting semaphores to provide synchronization and mutual exclusion
+ *  capabilities.
+ *
+ *  Directives provided are:
+ *
+ *     + create a semaphore
+ *     + get an ID of a semaphore
+ *     + delete a semaphore
+ *     + acquire a semaphore
+ *     + release a semaphore
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_SEMAPHORE_h
+#define __RTEMS_SEMAPHORE_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/attr.h>
+#include <rtems/object.h>
+#include <rtems/threadq.h>
+
+/*
+ *  The following defines the control block used to manage each semaphore.
+ */
+
+typedef struct {
+  Objects_Control       Object;
+  Thread_queue_Control  Wait_queue;
+  rtems_attribute    attribute_set;
+  unsigned32            count;
+  unsigned32            nest_count;
+  Thread_Control       *holder;
+  Objects_Id            holder_id;
+}   Semaphore_Control;
+
+/*
+ *  The following defines the information control block used to manage
+ *  this class of objects.
+ */
+
+EXTERN Objects_Information  _Semaphore_Information;
+
+/*
+ *  _Semaphore_Manager_initialization
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the initialization necessary for this manager.
+ */
+
+void _Semaphore_Manager_initialization(
+  unsigned32 maximum_semaphores
+);
+
+/*
+ *  rtems_semaphore_create
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_semaphore_create directive.  The
+ *  semaphore will have the name name.  The starting count for
+ *  the semaphore is count.  The attribute_set determines if
+ *  the semaphore is global or local and the thread queue
+ *  discipline.  It returns the id of the created semaphore in ID.
+ */
+
+rtems_status_code rtems_semaphore_create(
+  Objects_Name        name,
+  unsigned32          count,
+  rtems_attribute  attribute_set,
+  Objects_Id         *id
+);
+
+/*
+ *  rtems_semaphore_ident
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_semaphore_ident directive.
+ *  This directive returns the semaphore ID associated with name.
+ *  If more than one semaphore is named name, then the semaphore
+ *  to which the ID belongs is arbitrary.  node indicates the
+ *  extent of the search for the ID of the semaphore named name.
+ *  The search can be limited to a particular node or allowed to
+ *  encompass all nodes.
+ */
+
+rtems_status_code rtems_semaphore_ident(
+  Objects_Name  name,
+  unsigned32    node,
+  Objects_Id   *id
+);
+
+/*
+ *  rtems_semaphore_delete
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_semaphore_delete directive.  The
+ *  semaphore indicated by ID is deleted.
+ */
+
+rtems_status_code rtems_semaphore_delete(
+  Objects_Id id
+);
+
+/*
+ *  rtems_semaphore_obtain
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_semaphore_obtain directive.  It
+ *  attempts to obtain a unit from the semaphore associated with ID.
+ *  If a unit can be allocated, the calling task will return immediately.
+ *  If no unit is available, then the task may return immediately or
+ *  block waiting for a unit with an optional timeout of timeout
+ *  clock ticks.  Whether the task blocks or returns immediately
+ *  is based on the RTEMS_NO_WAIT option in the option_set.
+ */
+
+rtems_status_code rtems_semaphore_obtain(
+  Objects_Id        id,
+  unsigned32        option_set,
+  rtems_interval timeout
+);
+
+/*
+ *  rtems_semaphore_release
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_semaphore_release directive.  It
+ *  frees a unit to the semaphore associated with ID.  If a task was
+ *  blocked waiting for a unit from this semaphore, then that task will
+ *  be readied and the unit given to that task.  Otherwise, the unit
+ *  will be returned to the semaphore.
+ */
+
+rtems_status_code rtems_semaphore_release(
+  Objects_Id id
+);
+
+/*
+ *  _Semaphore_Seize
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine attempts to receive a unit from the_semaphore.
+ *  If a unit is available or if the RTEMS_NO_WAIT option is enabled in
+ *  option_set, then the routine returns.  Otherwise, the calling task
+ *  is blocked until a unit becomes available.
+ */
+
+boolean _Semaphore_Seize(
+  Semaphore_Control *the_semaphore,
+  unsigned32         option_set
+);
+
+/*
+ *  _Semaphore_Allocate
+ *
+ *  DESCRIPTION:
+ *
+ *  This function allocates a semaphore control block from
+ *  the inactive chain of free semaphore control blocks.
+ */
+
+STATIC INLINE Semaphore_Control *_Semaphore_Allocate( void );
+
+/*
+ *  _Semaphore_Free
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine frees a semaphore control block to the
+ *  inactive chain of free semaphore control blocks.
+ */
+
+STATIC INLINE void _Semaphore_Free (
+  Semaphore_Control *the_semaphore
+);
+
+/*
+ *  _Semaphore_Get
+ *
+ *  DESCRIPTION:
+ *
+ *  This function maps semaphore IDs to semaphore control blocks.
+ *  If ID corresponds to a local semaphore, then it returns
+ *  the_semaphore control pointer which maps to ID and location
+ *  is set to OBJECTS_LOCAL.  if the semaphore ID is global and
+ *  resides on a remote node, then location is set to OBJECTS_REMOTE,
+ *  and the_semaphore is undefined.  Otherwise, location is set
+ *  to OBJECTS_ERROR and the_semaphore is undefined.
+ */
+
+STATIC INLINE Semaphore_Control *_Semaphore_Get (
+  Objects_Id         id,
+  Objects_Locations *location
+);
+
+/*
+ *  _Semaphore_Is_null
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_semaphore is NULL and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Semaphore_Is_null (
+  Semaphore_Control *the_semaphore
+);
+
+#include <rtems/sem.inl>
+#include <rtems/semmp.h>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/*  end of include file */

c/src/exec/rtems/include/rtems/rtems/semmp.h

@@ -0,0 +1,163 @@
+/*  semmp.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the Multiprocessing Support in the Semaphore Manager.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_SEMAPHORE_MP_h
+#define __RTEMS_SEMAPHORE_MP_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/mppkt.h>
+#include <rtems/object.h>
+#include <rtems/options.h>
+#include <rtems/sem.h>
+#include <rtems/thread.h>
+#include <rtems/watchdog.h>
+
+/*
+ *  The following enumerated type defines the list of
+ *  remote semaphore operations.
+ */
+
+typedef enum {
+  SEMAPHORE_MP_ANNOUNCE_CREATE  =  0,
+  SEMAPHORE_MP_ANNOUNCE_DELETE  =  1,
+  SEMAPHORE_MP_EXTRACT_PROXY    =  2,
+  SEMAPHORE_MP_OBTAIN_REQUEST   =  3,
+  SEMAPHORE_MP_OBTAIN_RESPONSE  =  4,
+  SEMAPHORE_MP_RELEASE_REQUEST  =  5,
+  SEMAPHORE_MP_RELEASE_RESPONSE =  6,
+}   Semaphore_MP_Remote_operations;
+
+/*
+ *  The following data structure defines the packet used to perform
+ *  remote semaphore operations.
+ */
+
+typedef struct {
+  rtems_packet_prefix               Prefix;
+  Semaphore_MP_Remote_operations operation;
+  Objects_Name                   name;
+  rtems_option                option_set;
+  Objects_Id                     proxy_id;
+}   Semaphore_MP_Packet;
+
+/*
+ *  _Semaphore_MP_Send_process_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  process operation can be performed on another node.
+ */
+
+void _Semaphore_MP_Send_process_packet (
+  Semaphore_MP_Remote_operations operation,
+  Objects_Id                     semaphore_id,
+  Objects_Name                   name,
+  Objects_Id                     proxy_id
+);
+
+/*
+ *  _Semaphore_MP_Send_request_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  directive operation can be initiated on another node.
+ */
+
+rtems_status_code _Semaphore_MP_Send_request_packet (
+  Semaphore_MP_Remote_operations operation,
+  Objects_Id                     semaphore_id,
+  rtems_option                option_set,
+  rtems_interval              timeout
+);
+
+/*
+ *  _Semaphore_MP_Send_response_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  directive can be performed on another node.
+ */
+
+void _Semaphore_MP_Send_response_packet (
+  Semaphore_MP_Remote_operations  operation,
+  Objects_Id                      semaphore_id,
+  Thread_Control                 *the_thread
+);
+
+/*
+ *
+ *  _Semaphore_MP_Process_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the actions specific to this package for
+ *  the request from another node.
+ */
+
+void _Semaphore_MP_Process_packet (
+  rtems_packet_prefix *the_packet_prefix
+);
+
+/*
+ *  _Semaphore_MP_Send_object_was_deleted
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked indirectly by the thread queue
+ *  when a proxy has been removed from the thread queue and
+ *  the remote node must be informed of this.
+ */
+
+void _Semaphore_MP_Send_object_was_deleted (
+  Thread_Control *the_proxy
+);
+
+/*
+ *  _Semaphore_MP_Send_extract_proxy
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked when a task is deleted and it
+ *  has a proxy which must be removed from a thread queue and
+ *  the remote node must be informed of this.
+ */
+
+void _Semaphore_MP_Send_extract_proxy (
+  Thread_Control *the_thread
+);
+
+/*
+ *  _Semaphore_MP_Get_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This function is used to obtain a semaphore mp packet.
+ */
+
+Semaphore_MP_Packet *_Semaphore_MP_Get_packet ( void );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of file */

c/src/exec/rtems/include/rtems/rtems/signal.h

@@ -0,0 +1,72 @@
+/*  signal.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the Signal Manager.   This manager provides capabilities required
+ *  for asynchronous communication between tasks via signal sets.
+ *
+ *  Directives provided are:
+ *
+ *     + establish an asynchronous signal routine
+ *     + send a signal set to a task
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_SIGNAL_h
+#define __RTEMS_SIGNAL_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/asr.h>
+#include <rtems/modes.h>
+#include <rtems/object.h>
+#include <rtems/status.h>
+
+/*
+ *  rtems_signal_catch
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_signal_catch directive.  This directive
+ *  is used to establish asr_handler as the Asynchronous Signal Routine
+ *  (RTEMS_ASR) for the calling task.  The asr_handler will execute with a
+ *  mode of mode_set.
+ */
+
+rtems_status_code rtems_signal_catch(
+  rtems_asr_entry   asr_handler,
+  rtems_mode mode_set
+);
+
+/*
+ *  rtems_signal_send
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_signal_send directive.  This directive
+ *  sends the signal_set to the task specified by ID.
+ */
+
+rtems_status_code rtems_signal_send(
+  Objects_Id             id,
+  rtems_signal_set signal_set
+);
+
+#include <rtems/signalmp.h>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/include/rtems/rtems/signalmp.h

@@ -0,0 +1,147 @@
+/*  signalmp.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the Multiprocessing Support in the Signal Manager.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_SIGNAL_MP_h
+#define __RTEMS_SIGNAL_MP_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/asr.h>
+#include <rtems/mppkt.h>
+#include <rtems/object.h>
+#include <rtems/thread.h>
+#include <rtems/watchdog.h>
+
+/*
+ *  The following enumerated type defines the list of
+ *  remote signal operations.
+ */
+
+typedef enum {
+  SIGNAL_MP_SEND_REQUEST  = 0,
+  SIGNAL_MP_SEND_RESPONSE = 1,
+}   Signal_MP_Remote_operations;
+
+/*
+ *  The following data structure defines the packet used to perform
+ *  remote signal operations.
+ */
+
+typedef struct {
+  rtems_packet_prefix            Prefix;
+  Signal_MP_Remote_operations operation;
+  rtems_signal_set      signal_in;
+}   Signal_MP_Packet;
+
+/*
+ *  _Signal_MP_Send_process_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  process operation can be performed on another node.
+ *
+ *  This routine is not needed since there are no process
+ *  packets to be sent by this manager.
+ */
+
+/*
+ *  _Signal_MP_Send_request_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  directive operation can be initiated on another node.
+ */
+
+rtems_status_code _Signal_MP_Send_request_packet (
+  Signal_MP_Remote_operations operation,
+  Objects_Id                  task_id,
+  rtems_signal_set      signal_in
+);
+
+/*
+ *  _Signal_MP_Send_response_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  directive can be performed on another node.
+ */
+
+void _Signal_MP_Send_response_packet (
+  Signal_MP_Remote_operations  operation,
+  Thread_Control              *the_thread
+);
+
+/*
+ *
+ *  _Signal_MP_Process_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the actions specific to this package for
+ *  the request from another node.
+ */
+
+void _Signal_MP_Process_packet (
+  rtems_packet_prefix *the_packet_prefix
+);
+
+/*
+ *  _Signal_MP_Send_object_was_deleted
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked indirectly by the thread queue
+ *  when a proxy has been removed from the thread queue and
+ *  the remote node must be informed of this.
+ *
+ *  This routine is not needed since there are no objects
+ *  deleted by this manager.
+ */
+
+/*
+ *  _Signal_MP_Send_extract_proxy
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked when a task is deleted and it
+ *  has a proxy which must be removed from a thread queue and
+ *  the remote node must be informed of this.
+ *
+ *  This routine is not needed since there are no objects
+ *  deleted by this manager.
+ */
+
+/*
+ *  _Signal_MP_Get_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This function is used to obtain a signal mp packet.
+ */
+
+Signal_MP_Packet *_Signal_MP_Get_packet ( void );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of file */

c/src/exec/rtems/include/rtems/rtems/status.h

@@ -0,0 +1,109 @@
+/*  status.h
+ *
+ *  This include file contains the status codes returned from the
+ *  executive directives.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_STATUS_h
+#define __RTEMS_STATUS_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* types */
+
+/* enumerated constants */
+
+typedef enum {
+  RTEMS_SUCCESSFUL               =  0, /* successful completion */
+  RTEMS_TASK_EXITTED             =  1, /* returned from a thread */
+  RTEMS_MP_NOT_CONFIGURED        =  2, /* multiprocessing not configured */
+  RTEMS_INVALID_NAME             =  3, /* invalid object name */
+  RTEMS_INVALID_ID               =  4, /* invalid object id */
+  RTEMS_TOO_MANY                 =  5, /* too many */
+  RTEMS_TIMEOUT                  =  6, /* timed out waiting */
+  RTEMS_OBJECT_WAS_DELETED       =  7, /* object deleted while waiting */
+  RTEMS_INVALID_SIZE             =  8, /* specified size was invalid */
+  RTEMS_INVALID_ADDRESS          =  9, /* address specified is invalid */
+  RTEMS_INVALID_NUMBER           = 10, /* number was invalid */
+  RTEMS_NOT_DEFINED              = 11, /* item has not been initialized */
+  RTEMS_RESOURCE_IN_USE          = 12, /* resources still outstanding */
+  RTEMS_UNSATISFIED              = 13, /* request not satisfied */
+  RTEMS_INCORRECT_STATE          = 14, /* thread is in wrong state */
+  RTEMS_ALREADY_SUSPENDED        = 15, /* thread already in state */
+  RTEMS_ILLEGAL_ON_SELF          = 16, /* illegal on calling thread */
+  RTEMS_ILLEGAL_ON_REMOTE_OBJECT = 17, /* illegal for remote object */
+  RTEMS_CALLED_FROM_ISR          = 18, /* called from wrong environment */
+  RTEMS_INVALID_PRIORITY         = 19, /* invalid thread priority */
+  RTEMS_INVALID_CLOCK            = 20, /* invalid date/time */
+  RTEMS_INVALID_NODE             = 21, /* invalid node id */
+  RTEMS_NOT_CONFIGURED           = 22, /* directive not configured */
+  RTEMS_NOT_OWNER_OF_RESOURCE    = 23, /* not owner of resource */
+  RTEMS_NOT_IMPLEMENTED          = 24, /* directive not implemented */
+  RTEMS_INTERNAL_ERROR           = 25, /* RTEMS inconsistency detected */
+  RTEMS_PROXY_BLOCKING           = 26, /* internal multiprocessing only */
+  RTEMS_NO_MEMORY                = 27  /* could not get enough memory */
+} rtems_status_code;
+
+#define RTEMS_STATUS_CODES_FIRST RTEMS_SUCCESSFUL
+#define RTEMS_STATUS_CODES_LAST  RTEMS_NO_MEMORY
+
+/*
+ *  rtems_is_status_successful
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the status code is equal to RTEMS_SUCCESSFUL,
+ *  and FALSE otherwise.
+ */
+
+STATIC INLINE boolean rtems_is_status_successful (
+  rtems_status_code code
+);
+
+/*
+ *  rtems_are_statuses_equal
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the status code1 is equal to code2,
+ *  and FALSE otherwise.
+ */
+
+STATIC INLINE boolean rtems_are_statuses_equal (
+  rtems_status_code code1,
+  rtems_status_code code2
+);
+
+/*
+ *  _Status_Is_proxy_blocking
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the status code is equal to the
+ *  status which indicates that a proxy is blocking, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Status_Is_proxy_blocking (
+  rtems_status_code code
+);
+
+#include <rtems/status.inl>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/include/rtems/rtems/taskmp.h

@@ -0,0 +1,167 @@
+/*  taskmp.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the multiprocessing support in the task manager.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_RTEMS_TASKS_MP_h
+#define __RTEMS_RTEMS_TASKS_MP_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/mppkt.h>
+#include <rtems/object.h>
+#include <rtems/options.h>
+#include <rtems/priority.h>
+#include <rtems/tasks.h>
+#include <rtems/thread.h>
+
+/*
+ *  The following enumerated type defines the list of
+ *  remote task operations.
+ */
+
+typedef enum {
+  RTEMS_TASKS_MP_ANNOUNCE_CREATE       =  0,
+  RTEMS_TASKS_MP_ANNOUNCE_DELETE       =  1,
+  RTEMS_TASKS_MP_SUSPEND_REQUEST       =  2,
+  RTEMS_TASKS_MP_SUSPEND_RESPONSE      =  3,
+  RTEMS_TASKS_MP_RESUME_REQUEST        =  4,
+  RTEMS_TASKS_MP_RESUME_RESPONSE       =  5,
+  RTEMS_TASKS_MP_SET_PRIORITY_REQUEST  =  6,
+  RTEMS_TASKS_MP_SET_PRIORITY_RESPONSE =  7,
+  RTEMS_TASKS_MP_GET_NOTE_REQUEST      =  8,
+  RTEMS_TASKS_MP_GET_NOTE_RESPONSE     =  9,
+  RTEMS_TASKS_MP_SET_NOTE_REQUEST      = 10,
+  RTEMS_TASKS_MP_SET_NOTE_RESPONSE     = 11,
+}   RTEMS_tasks_MP_Remote_operations;
+
+/*
+ *  The following data structure defines the packet used to perform
+ *  remote task operations.
+ */
+
+typedef struct {
+  rtems_packet_prefix                 Prefix;
+  RTEMS_tasks_MP_Remote_operations operation;
+  Objects_Name                     name;
+  rtems_task_priority                 the_priority;
+  unsigned32                       notepad;
+  unsigned32                       note;
+}   RTEMS_tasks_MP_Packet;
+
+/*
+ *  _RTEMS_tasks_MP_Send_process_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  process operation can be performed on another node.
+ */
+
+void _RTEMS_tasks_MP_Send_process_packet (
+  RTEMS_tasks_MP_Remote_operations operation,
+  Objects_Id                       task_id,
+  Objects_Name                     name
+);
+
+/*
+ *  _RTEMS_tasks_MP_Send_request_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  directive operation can be initiated on another node.
+ */
+
+rtems_status_code _RTEMS_tasks_MP_Send_request_packet (
+  RTEMS_tasks_MP_Remote_operations operation,
+  Objects_Id                       task_id,
+  rtems_task_priority                 the_priority,
+  unsigned32                       notepad,
+  unsigned32                       note
+);
+
+/*
+ *  _RTEMS_tasks_MP_Send_response_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs a remote procedure call so that a
+ *  directive can be performed on another node.
+ */
+
+void _RTEMS_tasks_MP_Send_response_packet (
+  RTEMS_tasks_MP_Remote_operations  operation,
+  Thread_Control                   *the_thread
+);
+
+/*
+ *
+ *  _RTEMS_tasks_MP_Process_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the actions specific to this package for
+ *  the request from another node.
+ */
+
+void _RTEMS_tasks_MP_Process_packet (
+  rtems_packet_prefix *the_packet_prefix
+);
+
+/*
+ *  _RTEMS_tasks_MP_Send_object_was_deleted
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked indirectly by the thread queue
+ *  when a proxy has been removed from the thread queue and
+ *  the remote node must be informed of this.
+ *
+ *  This routine is not needed by RTEMS_tasks since a task
+ *  cannot be deleted when segments are in use.
+ */
+
+/*
+ *  _RTEMS_tasks_MP_Send_extract_proxy
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine is invoked when a task is deleted and it
+ *  has a proxy which must be removed from a thread queue and
+ *  the remote node must be informed of this.
+ *
+ *  This routine is not needed since there are no objects
+ *  deleted by this manager.
+ *
+ */
+
+/*
+ *  _RTEMS_tasks_MP_Get_packet
+ *
+ *  DESCRIPTION:
+ *
+ *  This function is used to obtain a task mp packet.
+ */
+
+RTEMS_tasks_MP_Packet *_RTEMS_tasks_MP_Get_packet ( void );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of file */

c/src/exec/rtems/include/rtems/rtems/tasks.h

@@ -0,0 +1,315 @@
+/*  tasks.h
+ *
+ *  This include file contains all constants and structures associated
+ *  with RTEMS tasks.  This manager provides a comprehensive set of directives
+ *  to create, delete, and administer tasks.
+ *
+ *  Directives provided are:
+ *
+ *     + create a task
+ *     + get an ID of a task
+ *     + start a task
+ *     + restart a task
+ *     + delete a task
+ *     + suspend a task
+ *     + resume a task
+ *     + set a task's priority
+ *     + change the current task's mode
+ *     + get a task notepad entry
+ *     + set a task notepad entry
+ *     + wake up after interval
+ *     + wake up when specified
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_RTEMS_TASKS_h
+#define __RTEMS_RTEMS_TASKS_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/message.h>
+#include <rtems/object.h>
+#include <rtems/part.h>
+#include <rtems/region.h>
+#include <rtems/sem.h>
+#include <rtems/states.h>
+#include <rtems/thread.h>
+#include <rtems/threadq.h>
+
+/*
+ *  Constant to be used as the ID of current task
+ */
+
+#define RTEMS_SELF                OBJECTS_ID_OF_SELF
+
+/*
+ *  This constant is passed to the rtems_task_wake_after directive as the
+ *  interval when a task wishes to yield the CPU.
+ */
+
+#define RTEMS_YIELD_PROCESSOR RTEMS_NO_TIMEOUT
+
+/*
+ *  rtems_task_create
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_task_create directive.  The task
+ *  will have the name name.  The attribute_set can be used to indicate
+ *  that the task will be globally accessible or utilize floating point.
+ *  The task's stack will be stack_size bytes.   The task will begin
+ *  execution with initial_priority and initial_modes.  It returns the
+ *  id of the created task in ID.
+ */
+
+rtems_status_code rtems_task_create(
+  Objects_Name        name,
+  rtems_task_priority    initial_priority,
+  unsigned32          stack_size,
+  rtems_mode       initial_modes,
+  rtems_attribute  attribute_set,
+  Objects_Id         *id
+);
+
+/*
+ *  rtems_task_ident
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_task_ident directive.
+ *  This directive returns the task ID associated with name.
+ *  If more than one task is named name, then the task to
+ *  which the ID belongs is arbitrary.  node indicates the
+ *  extent of the search for the ID of the task named name.
+ *  The search can be limited to a particular node or allowed to
+ *  encompass all nodes.
+ */
+
+rtems_status_code rtems_task_ident(
+  Objects_Name  name,
+  unsigned32    node,
+  Objects_Id   *id
+);
+
+/*
+ *  rtems_task_delete
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_task_delete directive.  The
+ *  task indicated by ID is deleted.
+ */
+
+rtems_status_code rtems_task_delete(
+  Objects_Id id
+);
+
+/*
+ *  rtems_task_get_note
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_task_get_note directive.  The
+ *  value of the indicated notepad for the task associated with ID
+ *  is returned in note.
+ */
+
+rtems_status_code rtems_task_get_note(
+  Objects_Id  id,
+  unsigned32  notepad,
+  unsigned32 *note
+);
+
+/*
+ *  rtems_task_set_note
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_task_set_note directive.  The
+ *  value of the indicated notepad for the task associated with ID
+ *  is returned in note.
+ */
+
+rtems_status_code rtems_task_set_note(
+  Objects_Id id,
+  unsigned32 notepad,
+  unsigned32 note
+);
+
+/*
+ *  rtems_task_mode
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_task_mode directive.  The current
+ *  values of the modes indicated by mask of the calling task are changed
+ *  to that indicated in mode_set.  The former mode of the task is
+ *  returned in mode_set.
+ */
+
+rtems_status_code rtems_task_mode(
+  rtems_mode  mode_set,
+  rtems_mode  mask,
+  rtems_mode *previous_mode_set
+);
+
+/*
+ *  rtems_task_restart
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_task_restart directive.  The
+ *  task associated with ID is restarted at its initial entry
+ *  point with the new argument.
+ */
+
+rtems_status_code rtems_task_restart(
+  Objects_Id id,
+  unsigned32 arg
+);
+
+/*
+ *  rtems_task_suspend
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_task_suspend directive.  The
+ *  SUSPENDED state is set for task associated with ID.
+ */
+
+rtems_status_code rtems_task_suspend(
+  Objects_Id id
+);
+
+/*
+ *  rtems_task_resume
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_task_resume Directive.  The
+ *  SUSPENDED state is cleared for task associated with ID.
+ */
+
+rtems_status_code rtems_task_resume(
+  Objects_Id id
+);
+
+/*
+ *  rtems_task_set_priority
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_task_set_priority directive.  The
+ *  current priority of the task associated with ID is set to
+ *  new_priority.  The former priority of that task is returned
+ *  in old_priority.
+ */
+
+rtems_status_code rtems_task_set_priority(
+  Objects_Id        id,
+  rtems_task_priority  new_priority,
+  rtems_task_priority *old_priority
+);
+
+/*
+ *  rtems_task_start
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_task_start directive.  The
+ *  starting execution point of the task associated with ID is
+ *  set to entry_point with the initial argument.
+ */
+
+rtems_status_code rtems_task_start(
+  Objects_Id   id,
+  rtems_task_entry entry_point,
+  unsigned32   argument
+);
+
+/*
+ *  rtems_task_wake_when
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_task_wake_when directive.  The
+ *  calling task is blocked until the current time of day is
+ *  equal to that indicated by time_buffer.
+ */
+
+rtems_status_code rtems_task_wake_when(
+  rtems_time_of_day *time_buffer
+);
+
+/*
+ *  rtems_task_wake_after
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_task_wake_after directive.  The
+ *  calling task is blocked until the indicated number of clock
+ *  ticks have occurred.
+ */
+
+rtems_status_code rtems_task_wake_after(
+  rtems_interval ticks
+);
+
+/*
+ *  _RTEMS_tasks_Allocate
+ *
+ *  DESCRIPTION:
+ *
+ *  This function allocates a task control block from
+ *  the inactive chain of free task control blocks.
+ */
+
+STATIC INLINE Thread_Control *_RTEMS_tasks_Allocate( void );
+
+/*
+ *  _RTEMS_tasks_Free
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine frees a task control block to the
+ *  inactive chain of free task control blocks.
+
+ */
+
+STATIC INLINE void _RTEMS_tasks_Free (
+  Thread_Control *the_task
+);
+
+/*
+ *  _RTEMS_tasks_Cancel_wait
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine unblocks the_thread and cancels any timers
+ *  which the_thread has active.
+ */
+
+STATIC INLINE void _RTEMS_tasks_Cancel_wait(
+  Thread_Control *the_thread
+);
+
+#include <rtems/tasks.inl>
+#include <rtems/taskmp.h>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/include/rtems/rtems/timer.h

@@ -0,0 +1,292 @@
+/*  timer.h
+ *
+ *  This include file contains all the constants, structures, and
+ *  prototypes associated with the Timer Manager.  This manager provides
+ *  facilities to configure, initiate, cancel, and delete timers which will
+ *  fire at specified intervals of time.
+ *
+ *  Directives provided are:
+ *
+ *     + create a timer
+ *     + get an ID of a timer
+ *     + delete a timer
+ *     + set a timer to fire after a number of ticks have passed
+ *     + set a timer to fire when a specified date and time has been reached
+ *     + reset a timer
+ *     + cancel a time
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RTEMS_TIMER_h
+#define __RTEMS_TIMER_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/object.h>
+#include <rtems/tod.h>
+#include <rtems/watchdog.h>
+
+/*
+ *  The following enumerated type details the classes to which a timer
+ *  may belong.
+ */
+
+typedef enum {
+  TIMER_INTERVAL,
+  TIMER_TIME_OF_DAY,
+  TIMER_DORMANT
+} Timer_Classes;
+
+/*
+ *  The following defines the type of a Timer Service Routine.
+ */
+
+typedef rtems_timer_service_routine_entry Timer_Service;
+
+/*
+ *  The following defines the information control block used to manage
+ *  this class of objects.
+ */
+
+EXTERN Objects_Information  _Timer_Information;
+
+/*
+ *  The following records define the control block used to manage
+ *  each timer.
+ */
+
+typedef struct {
+  Objects_Control  Object;
+  Watchdog_Control Ticker;
+  Timer_Classes    the_class;
+}   Timer_Control;
+
+/*
+ *  _Timer_Manager_initialization
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine performs the initialization necessary for this manager.
+ */
+
+void _Timer_Manager_initialization(
+  unsigned32 maximum_timers
+);
+
+/*
+ *  rtems_timer_create
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_timer_create directive.  The
+ *  timer will have the name name.  It returns the id of the
+ *  created timer in ID.
+ */
+
+rtems_status_code rtems_timer_create(
+  Objects_Name  name,
+  Objects_Id   *id
+);
+
+/*
+ *  rtems_timer_ident
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_timer_ident directive.
+ *  This directive returns the timer ID associated with name.
+ *  If more than one timer is named name, then the timer
+ *  to which the ID belongs is arbitrary.
+ */
+
+rtems_status_code rtems_timer_ident(
+  Objects_Name  name,
+  Objects_Id   *id
+);
+
+/*
+ *  rtems_timer_cancel
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_timer_cancel directive.  It is used
+ *  to stop the timer associated with ID from firing.
+ */
+
+rtems_status_code rtems_timer_cancel(
+  Objects_Id id
+);
+
+/*
+ *  rtems_timer_delete
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_timer_delete directive.  The
+ *  timer indicated by ID is deleted.
+ */
+
+rtems_status_code rtems_timer_delete(
+  Objects_Id id
+);
+
+/*
+ *  rtems_timer_fire_after
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_timer_fire_after directive.  It
+ *  initiates the timer associated with ID to fire in ticks clock
+ *  ticks.  When the timer fires, the routine will be invoked.
+ */
+
+rtems_status_code rtems_timer_fire_after(
+  Objects_Id         id,
+  rtems_interval  ticks,
+  Timer_Service      routine,
+  void              *user_data
+);
+
+/*
+ *  rtems_timer_fire_when
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_timer_fire_when directive.  It
+ *  initiates the timer associated with ID to fire at wall_time
+ *  When the timer fires, the routine will be invoked.
+ */
+
+rtems_status_code rtems_timer_fire_when(
+  Objects_Id         id,
+  rtems_time_of_day       *wall_time,
+  Timer_Service      routine,
+  void              *user_data
+);
+
+/*
+ *  rtems_timer_reset
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine implements the rtems_timer_reset directive.  It is used
+ *  to reinitialize the interval timer associated with ID just as if
+ *  rtems_timer_fire_after were re-invoked with the same arguments that
+ *  were used to initiate this timer.
+ */
+
+rtems_status_code rtems_timer_reset(
+  Objects_Id id
+);
+
+/*
+ *  _Timer_Allocate
+ *
+ *  DESCRIPTION:
+ *
+ *  This function allocates a timer control block from
+ *  the inactive chain of free timer control blocks.
+ */
+
+STATIC INLINE Timer_Control *_Timer_Allocate( void );
+
+/*
+ *  _Timer_Free
+ *
+ *  DESCRIPTION:
+ *
+ *  This routine frees a timer control block to the
+ *  inactive chain of free timer control blocks.
+ */
+
+STATIC INLINE void _Timer_Free (
+  Timer_Control *the_timer
+);
+
+/*
+ *  _Timer_Get
+ *
+ *  DESCRIPTION:
+ *
+ *  This function maps timer IDs to timer control blocks.
+ *  If ID corresponds to a local timer, then it returns
+ *  the timer control pointer which maps to ID and location
+ *  is set to OBJECTS_LOCAL.  Otherwise, location is set
+ *  to OBJECTS_ERROR and the returned value is undefined.
+ */
+
+STATIC INLINE Timer_Control *_Timer_Get (
+  Objects_Id         id,
+  Objects_Locations *location
+);
+
+/*
+ *  _Timer_Is_interval_class
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the class is that of an INTERVAL
+ *  timer, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Timer_Is_interval_class (
+  Timer_Classes the_class
+);
+
+/*
+ *  _Timer_Is_time_of_day_class
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the class is that of an INTERVAL
+ *  timer, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Timer_Is_timer_of_day_class (
+  Timer_Classes the_class
+);
+
+/*
+ *  _Timer_Is_dormant_class
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the class is that of a DORMANT
+ *  timer, and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Timer_Is_dormant_class (
+  Timer_Classes the_class
+);
+
+/*
+ *  _Timer_Is_null
+ *
+ *  DESCRIPTION:
+ *
+ *  This function returns TRUE if the_timer is NULL and FALSE otherwise.
+ */
+
+STATIC INLINE boolean _Timer_Is_null (
+  Timer_Control *the_timer
+);
+
+#include <rtems/timer.inl>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* end of include file */

c/src/exec/rtems/inline/asr.inl

@@ -0,0 +1,105 @@
+/*  inline/asr.inl
+ *
+ *  This include file contains the implemenation of all routines
+ *  associated with the asynchronous signal handler which are inlined.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __INLINE_ASR_inl
+#define __INLINE_ASR_inl
+
+#include <rtems/isr.h>
+
+/*PAGE
+ *
+ *  _ASR_Initialize
+ *
+ */
+
+STATIC INLINE void _ASR_Initialize (
+  ASR_Information *information
+)
+{
+  information->handler         = NULL;
+  information->mode_set        = RTEMS_DEFAULT_MODES;
+  information->signals_posted  = 0;
+  information->signals_pending = 0;
+  information->nest_level      = 0;
+}
+
+/*PAGE
+ *
+ *  _ASR_Swap_signals
+ *
+ */
+
+STATIC INLINE void _ASR_Swap_signals (
+  ASR_Information *information
+)
+{
+  rtems_signal_set _signals;
+  ISR_Level              _level;
+
+  _ISR_Disable( _level );
+    _signals                     = information->signals_pending;
+    information->signals_pending = information->signals_posted;
+    information->signals_posted  = _signals;
+  _ISR_Enable( _level );
+}
+
+/*PAGE
+ *
+ *  _ASR_Is_null_handler
+ *
+ */
+
+STATIC INLINE boolean _ASR_Is_null_handler (
+  rtems_asr_entry asr_handler
+)
+{
+  return asr_handler == NULL;
+}
+
+/*PAGE
+ *
+ *  _ASR_Are_signals_pending
+ *
+ */
+
+STATIC INLINE boolean _ASR_Are_signals_pending (
+  ASR_Information *information
+)
+{
+  return information->signals_posted != 0;
+}
+
+/*PAGE
+ *
+ *  _ASR_Post_signals
+ *
+ */
+
+STATIC INLINE void _ASR_Post_signals(
+  rtems_signal_set  signals,
+  rtems_signal_set *signal_set
+)
+{
+  ISR_Level              _level;
+
+  _ISR_Disable( _level );
+    *signal_set |= signals;
+  _ISR_Enable( _level );
+}
+
+
+#endif
+/* end of include file */

c/src/exec/rtems/inline/attr.inl

@@ -0,0 +1,125 @@
+/*  inline/attr.inl
+ *
+ *  This include file contains all of the inlined routines associated
+ *  with attributes.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __INLINE_ATTRIBUTES_inl
+#define __INLINE_ATTRIBUTES_inl
+
+/*PAGE
+ *
+ *  _Attributes_Set
+ */
+
+STATIC INLINE rtems_attribute _Attributes_Set (
+   rtems_attribute new_attributes,
+   rtems_attribute attribute_set
+)
+{
+  return attribute_set | new_attributes;
+}
+
+/*PAGE
+ *
+ *  _Attributes_Clear
+ */
+
+STATIC INLINE rtems_attribute _Attributes_Clear (
+   rtems_attribute attribute_set,
+   rtems_attribute mask
+)
+{
+  return attribute_set & ~mask;
+}
+
+/*PAGE
+ *
+ *  _Attributes_Is_floating_point
+ *
+ */
+
+STATIC INLINE boolean _Attributes_Is_floating_point(
+  rtems_attribute attribute_set
+)
+{
+   return ( attribute_set & RTEMS_FLOATING_POINT );
+}
+
+/*PAGE
+ *
+ *  _Attributes_Is_global
+ *
+ */
+
+STATIC INLINE boolean _Attributes_Is_global(
+  rtems_attribute attribute_set
+)
+{
+   return ( attribute_set & RTEMS_GLOBAL );
+}
+
+/*PAGE
+ *
+ *  _Attributes_Is_priority
+ *
+ */
+
+STATIC INLINE boolean _Attributes_Is_priority(
+  rtems_attribute attribute_set
+)
+{
+   return ( attribute_set & RTEMS_PRIORITY );
+}
+
+/*PAGE
+ *
+ *  _Attributes_Is_limit
+ *
+ */
+
+STATIC INLINE boolean _Attributes_Is_limit(
+  rtems_attribute attribute_set
+)
+{
+   return ( attribute_set & RTEMS_LIMIT );
+}
+
+/*PAGE
+ *
+ *  _Attributes_Is_binary_semaphore
+ *
+ */
+
+STATIC INLINE boolean _Attributes_Is_binary_semaphore(
+  rtems_attribute attribute_set
+)
+{
+  return ( attribute_set & RTEMS_BINARY_SEMAPHORE );
+}
+
+/*PAGE
+ *
+ *  _Attributes_Is_inherit_priority
+ *
+ */
+
+STATIC INLINE boolean _Attributes_Is_inherit_priority(
+  rtems_attribute attribute_set
+)
+{
+   return ( attribute_set & RTEMS_INHERIT_PRIORITY );
+}
+
+#endif
+/* end of include file */

c/src/exec/rtems/inline/dpmem.inl

@@ -0,0 +1,75 @@
+/*  inline/dpmem.inl
+ *
+ *  This include file contains the inline routine used in conjunction
+ *  with the Dual Ported Memory Manager
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __INLINE_DPMEM_inl
+#define __INLINE_DPMEM_inl
+
+
+/*PAGE
+ *
+ *  _Dual_ported_memory_Allocate
+ *
+ */
+
+STATIC INLINE Dual_ported_memory_Control
+   *_Dual_ported_memory_Allocate ( void )
+{
+  return (Dual_ported_memory_Control *)
+     _Objects_Allocate( &_Dual_ported_memory_Information );
+}
+
+/*PAGE
+ *
+ *  _Dual_ported_memory_Free
+ *
+ */
+
+STATIC INLINE void _Dual_ported_memory_Free (
+   Dual_ported_memory_Control *the_port
+)
+{
+  _Objects_Free( &_Dual_ported_memory_Information, &the_port->Object );
+}
+
+/*PAGE
+ *
+ *  _Dual_ported_memory_Get
+ *
+ */
+
+STATIC INLINE Dual_ported_memory_Control *_Dual_ported_memory_Get (
+  Objects_Id         id,
+  Objects_Locations *location
+)
+{
+  return (Dual_ported_memory_Control *)
+     _Objects_Get( &_Dual_ported_memory_Information, id, location );
+}
+
+/*PAGE
+ *
+ *  _Dual_ported_memory_Is_null
+ */
+
+STATIC INLINE boolean _Dual_ported_memory_Is_null(
+  Dual_ported_memory_Control *the_port
+)
+{
+  return ( the_port == NULL );
+}
+
+#endif
+/* end of include file */

c/src/exec/rtems/inline/event.inl

@@ -0,0 +1,30 @@
+/*  inline/event.inl
+ *
+ *  This include file contains the static inline implementation of
+ *  macros for the Event Manager.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __MACROS_EVENT_inl
+#define __MACROS_EVENT_inl
+
+/*
+ *  Event_Manager_initialization
+ */
+
+STATIC INLINE void _Event_Manager_initialization( void )
+{
+  _Event_Sync = FALSE;
+}
+
+#endif
+/* end of include file */

c/src/exec/rtems/inline/eventset.inl

@@ -0,0 +1,71 @@
+/*  inline/eventset.inl
+ *
+ *  This include file contains the information pertaining to event sets.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __INLINE_EVENT_SET_inl
+#define __INLINE_EVENT_SET_inl
+
+/*PAGE
+ *
+ *  _Event_sets_Is_empty
+ */
+
+STATIC INLINE boolean _Event_sets_Is_empty(
+  rtems_event_set the_event_set
+)
+{
+  return ( the_event_set == 0 );
+}
+
+/*PAGE
+ *
+ *  _Event_sets_Post
+ */
+
+STATIC INLINE void _Event_sets_Post(
+  rtems_event_set  the_new_events,
+  rtems_event_set *the_event_set
+)
+{
+   *the_event_set |= the_new_events;
+}
+
+/*PAGE
+ *
+ *  _Event_sets_Get
+ */
+
+STATIC INLINE rtems_event_set _Event_sets_Get(
+  rtems_event_set the_event_set,
+  rtems_event_set the_event_condition
+)
+{
+   return ( the_event_set & the_event_condition );
+}
+
+/*PAGE
+ *
+ *  _Event_sets_Clear
+ */
+
+STATIC INLINE rtems_event_set _Event_sets_Clear(
+ rtems_event_set the_event_set,
+ rtems_event_set the_mask
+)
+{
+   return ( the_event_set & ~(the_mask) );
+}
+
+#endif
+/* end of include file */

c/src/exec/rtems/inline/message.inl

@@ -0,0 +1,160 @@
+/*  message.inl
+ *
+ *  This include file contains the static inline implementation of all
+ *  inlined routines in the Message Manager.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __MESSAGE_QUEUE_inl
+#define __MESSAGE_QUEUE_inl
+
+/*PAGE
+ *
+ *  _Message_queue_Copy_buffer
+ *
+ */
+
+STATIC INLINE void _Message_queue_Copy_buffer (
+  Message_queue_Buffer *source,
+  Message_queue_Buffer *destination
+)
+{
+  *destination = *source;
+}
+
+/*PAGE
+ *
+ *  _Message_queue_Allocate_message_buffer
+ *
+ */
+
+STATIC INLINE Message_queue_Buffer_control *
+  _Message_queue_Allocate_message_buffer ( void )
+{
+   return (Message_queue_Buffer_control *)
+     _Chain_Get( &_Message_queue_Inactive_messages );
+}
+
+/*PAGE
+ *
+ *  _Message_queue_Free_message_buffer
+ *
+ */
+
+STATIC INLINE void _Message_queue_Free_message_buffer (
+  Message_queue_Buffer_control *the_message
+)
+{
+ _Chain_Append( &_Message_queue_Inactive_messages, &the_message->Node );
+}
+
+/*PAGE
+ *
+ *  _Message_queue_Get_pending_message
+ *
+ */
+
+STATIC INLINE
+  Message_queue_Buffer_control *_Message_queue_Get_pending_message (
+  Message_queue_Control *the_message_queue
+)
+{
+  return (Message_queue_Buffer_control *)
+    _Chain_Get_unprotected( &the_message_queue->Pending_messages );
+}
+
+/*PAGE
+ *
+ *  _Message_queue_Append
+ *
+ */
+
+STATIC INLINE void _Message_queue_Append (
+  Message_queue_Control        *the_message_queue,
+  Message_queue_Buffer_control *the_message
+)
+{
+  _Chain_Append( &the_message_queue->Pending_messages, &the_message->Node );
+}
+
+/*PAGE
+ *
+ *  _Message_queue_Prepend
+ *
+ */
+
+STATIC INLINE void _Message_queue_Prepend (
+  Message_queue_Control        *the_message_queue,
+  Message_queue_Buffer_control *the_message
+)
+{
+  _Chain_Prepend(
+    &the_message_queue->Pending_messages,
+    &the_message->Node
+  );
+}
+
+/*PAGE
+ *
+ *  _Message_queue_Is_null
+ *
+ */
+
+STATIC INLINE boolean _Message_queue_Is_null (
+  Message_queue_Control *the_message_queue
+)
+{
+  return ( the_message_queue == NULL  );
+}
+
+/*PAGE
+ *
+ *  _Message_queue_Allocate
+ *
+ */
+
+STATIC INLINE Message_queue_Control *_Message_queue_Allocate ( void )
+{
+  return (Message_queue_Control *)
+     _Objects_Allocate( &_Message_queue_Information );
+}
+
+/*PAGE
+ *
+ *  _Message_queue_Free
+ *
+ */
+
+STATIC INLINE void _Message_queue_Free (
+  Message_queue_Control *the_message_queue
+)
+{
+  _Objects_Free( &_Message_queue_Information, &the_message_queue->Object );
+}
+
+/*PAGE
+ *
+ *  _Message_queue_Get
+ *
+ */
+
+STATIC INLINE Message_queue_Control *_Message_queue_Get (
+  Objects_Id         id,
+  Objects_Locations *location
+)
+{
+  return (Message_queue_Control *)
+     _Objects_Get( &_Message_queue_Information, id, location );
+}
+
+#endif
+/* end of include file */

c/src/exec/rtems/inline/modes.inl

@@ -0,0 +1,136 @@
+/*  modes.inl
+ *
+ *  This include file contains the static inline implementation of the
+ *  inlined routines in the Mode Handler
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __MODES_inl
+#define __MODES_inl
+
+/*PAGE
+ *
+ *  RTEMS_INTERRUPT_LEVEL
+ */
+
+STATIC INLINE unsigned32 RTEMS_INTERRUPT_LEVEL (
+  rtems_mode mode_set
+)
+{
+  return mode_set & RTEMS_INTERRUPT_MASK;
+}
+
+/*PAGE
+ *
+ *  _Modes_Mask_changed
+ *
+ */
+
+STATIC INLINE boolean _Modes_Mask_changed (
+  rtems_mode mode_set,
+  rtems_mode masks
+)
+{
+   return ( mode_set & masks );
+}
+
+/*PAGE
+ *
+ *  _Modes_Is_asr_disabled
+ *
+ */
+
+STATIC INLINE boolean _Modes_Is_asr_disabled (
+  rtems_mode mode_set
+)
+{
+   return ( mode_set & RTEMS_ASR_MASK );
+}
+
+/*PAGE
+ *
+ *  _Modes_Is_preempt
+ *
+ */
+
+STATIC INLINE boolean _Modes_Is_preempt (
+  rtems_mode mode_set
+)
+{
+   return ( ( mode_set & RTEMS_PREEMPT_MASK ) == RTEMS_PREEMPT );
+}
+
+/*PAGE
+ *
+ *  _Modes_Is_timeslice
+ *
+ */
+
+STATIC INLINE boolean _Modes_Is_timeslice (
+  rtems_mode mode_set
+)
+{
+  return ((mode_set & (RTEMS_TIMESLICE_MASK|RTEMS_PREEMPT_MASK)) ==
+                  (RTEMS_TIMESLICE|RTEMS_PREEMPT) );
+}
+
+/*PAGE
+ *
+ *  _Modes_Get_interrupt_level
+ *
+ */
+
+STATIC INLINE ISR_Level _Modes_Get_interrupt_level (
+  rtems_mode mode_set
+)
+{
+  return ( mode_set & RTEMS_INTERRUPT_MASK );
+}
+
+/*PAGE
+ *
+ *  _Modes_Set_interrupt_level
+ *
+ */
+
+STATIC INLINE void _Modes_Set_interrupt_level (
+  rtems_mode mode_set
+)
+{
+  _ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) );
+}
+
+/*PAGE
+ *
+ *  _Modes_Change
+ *
+ */
+
+STATIC INLINE void _Modes_Change (
+  rtems_mode  old_mode_set,
+  rtems_mode  new_mode_set,
+  rtems_mode  mask,
+  rtems_mode *out_mode_set,
+  rtems_mode *changed
+)
+{
+  rtems_mode _out_mode;
+
+  _out_mode      =  old_mode_set;
+  _out_mode     &= ~mask;
+  _out_mode     |= new_mode_set & mask;
+  *changed       = _out_mode ^ old_mode_set;
+  *out_mode_set  = _out_mode;
+}
+
+#endif
+/* end of include file */

c/src/exec/rtems/inline/options.inl

@@ -0,0 +1,47 @@
+/*  options.inl
+ *
+ *  This file contains the static inline implementation of the inlined
+ *  routines from the Options Handler.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __OPTIONS_inl
+#define __OPTIONS_inl
+
+/*PAGE
+ *
+ *  _Options_Is_no_wait
+ *
+ */
+
+STATIC INLINE boolean _Options_Is_no_wait (
+  rtems_option option_set
+)
+{
+   return (option_set & RTEMS_NO_WAIT);
+}
+
+/*PAGE
+ *
+ *  _Options_Is_any
+ *
+ */
+
+STATIC INLINE boolean _Options_Is_any (
+  rtems_option option_set
+)
+{
+   return (option_set & RTEMS_EVENT_ANY);
+}
+
+#endif
+/* end of include file */

c/src/exec/rtems/inline/part.inl

@@ -0,0 +1,157 @@
+/*  part.inl
+ *
+ *  This file contains the macro implementation of all inlined routines
+ *  in the Partition Manager.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __PARTITION_inl
+#define __PARTITION_inl
+
+/*PAGE
+ *
+ *  _Partition_Allocate_buffer
+ *
+ */
+
+STATIC INLINE void *_Partition_Allocate_buffer (
+   Partition_Control *the_partition
+)
+{
+  return _Chain_Get( &the_partition->Memory );
+}
+
+/*PAGE
+ *
+ *  _Partition_Free_buffer
+ *
+ */
+
+STATIC INLINE void _Partition_Free_buffer (
+  Partition_Control *the_partition,
+  Chain_Node        *the_buffer
+)
+{
+  _Chain_Append( &the_partition->Memory, the_buffer );
+}
+
+/*PAGE
+ *
+ *  _Partition_Is_buffer_on_boundary
+ *
+ */
+
+STATIC INLINE boolean _Partition_Is_buffer_on_boundary (
+  void              *the_buffer,
+  Partition_Control *the_partition
+)
+{
+  unsigned32   offset;
+
+  offset = (unsigned32) _Addresses_Subtract(
+    the_buffer,
+    the_partition->starting_address
+  );
+
+  return ((offset % the_partition->buffer_size) == 0);
+}
+
+/*PAGE
+ *
+ *  _Partition_Is_buffer_valid
+ *
+ */
+
+STATIC INLINE boolean _Partition_Is_buffer_valid (
+   Chain_Node        *the_buffer,
+   Partition_Control *the_partition
+)
+{
+  void *starting;
+  void *ending;
+
+  starting = the_partition->starting_address;
+  ending   = _Addresses_Add_offset( starting, the_partition->length );
+
+  return (
+    _Addresses_Is_in_range( the_buffer, starting, ending ) &&
+    _Partition_Is_buffer_on_boundary( the_buffer, the_partition )
+  );
+}
+
+/*PAGE
+ *
+ *  _Partition_Is_buffer_size_aligned
+ *
+ */
+
+STATIC INLINE boolean _Partition_Is_buffer_size_aligned (
+   unsigned32 buffer_size
+)
+{
+  return ((buffer_size % CPU_PARTITION_ALIGNMENT) == 0);
+}
+
+/*PAGE
+ *
+ *  _Partition_Allocate
+ *
+ */
+
+STATIC INLINE Partition_Control *_Partition_Allocate ( void )
+{
+  return (Partition_Control *) _Objects_Allocate( &_Partition_Information );
+}
+
+/*PAGE
+ *
+ *  _Partition_Free
+ *
+ */
+
+STATIC INLINE void _Partition_Free (
+   Partition_Control *the_partition
+)
+{
+  _Objects_Free( &_Partition_Information, &the_partition->Object );
+}
+
+/*PAGE
+ *
+ *  _Partition_Get
+ *
+ */
+
+STATIC INLINE Partition_Control *_Partition_Get (
+  Objects_Id         id,
+  Objects_Locations *location
+)
+{
+  return (Partition_Control *)
+    _Objects_Get( &_Partition_Information, id, location );
+}
+
+/*PAGE
+ *
+ *  _Partition_Is_null
+ *
+ */
+
+STATIC INLINE boolean _Partition_Is_null (
+   Partition_Control *the_partition
+)
+{
+   return ( the_partition == NULL  );
+}
+
+#endif
+/* end of include file */

c/src/exec/rtems/inline/ratemon.inl

@@ -0,0 +1,113 @@
+/*  ratemon.inl
+ *
+ *  This file contains the static inline  implementation of the inlined
+ *  routines in the Rate Monotonic Manager.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __RATE_MONOTONIC_inl
+#define __RATE_MONOTONIC_inl
+
+/*PAGE
+ *
+ *  _Rate_monotonic_Allocate
+ *
+ */
+
+STATIC INLINE Rate_monotonic_Control *_Rate_monotonic_Allocate( void )
+{
+  return (Rate_monotonic_Control *)
+    _Objects_Allocate( &_Rate_monotonic_Information );
+}
+
+/*PAGE
+ *
+ *  _Rate_monotonic_Free
+ *
+ */
+
+STATIC INLINE void _Rate_monotonic_Free (
+  Rate_monotonic_Control *the_period
+)
+{
+  _Objects_Free( &_Rate_monotonic_Information, &the_period->Object );
+}
+
+/*PAGE
+ *
+ *  _Rate_monotonic_Get
+ *
+ */
+
+STATIC INLINE Rate_monotonic_Control *_Rate_monotonic_Get (
+  Objects_Id         id,
+  Objects_Locations *location
+)
+{
+  return (Rate_monotonic_Control *)
+    _Objects_Get( &_Rate_monotonic_Information, id, location );
+}
+
+/*PAGE
+ *
+ *  _Rate_monotonic_Is_active
+ *
+ */
+
+STATIC INLINE boolean _Rate_monotonic_Is_active (
+  Rate_monotonic_Control *the_period
+)
+{
+  return (the_period->state == RATE_MONOTONIC_ACTIVE);
+}
+
+/*PAGE
+ *
+ *  _Rate_monotonic_Is_inactive
+ *
+ */
+
+STATIC INLINE boolean _Rate_monotonic_Is_inactive (
+  Rate_monotonic_Control *the_period
+)
+{
+  return (the_period->state == RATE_MONOTONIC_INACTIVE);
+}
+
+/*PAGE
+ *
+ *  _Rate_monotonic_Is_expired
+ *
+ */
+
+STATIC INLINE boolean _Rate_monotonic_Is_expired (
+  Rate_monotonic_Control *the_period
+)
+{
+  return (the_period->state == RATE_MONOTONIC_EXPIRED);
+}
+
+/*PAGE
+ *
+ *  _Rate_monotonic_Is_null
+ *
+ */
+
+STATIC INLINE boolean _Rate_monotonic_Is_null (
+  Rate_monotonic_Control *the_period
+)
+{
+  return (the_period == NULL);
+}
+
+#endif
+/* end of include file */

c/src/exec/rtems/inline/region.inl

@@ -0,0 +1,101 @@
+/*  region.inl
+ *
+ *  This file contains the macro implementation of the inlined
+ *  routines from the Region Manager.
+ *
+ *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
+ *  On-Line Applications Research Corporation (OAR).
+ *  All rights assigned to U.S. Government, 1994.
+ *
+ *  This material may be reproduced by or for the U.S. Government pursuant
+ *  to the copyright license under the clause at DFARS 252.227-7013.  This
+ *  notice must appear in all copies of this file and its derivatives.
+ *
+ *  $Id$
+ */
+
+#ifndef __REGION_inl
+#define __REGION_inl
+
+/*PAGE
+ *
+ *  _Region_Allocate
+ *
+ */
+
+STATIC INLINE Region_Control *_Region_Allocate( void )
+{
+  return (Region_Control *) _Objects_Allocate( &_Region_Information );
+}
+
+/*PAGE
+ *
+ *  _Region_Free
+ *
+ */
+
+STATIC INLINE void _Region_Free (
+  Region_Control *the_region
+)
+{
+  _Objects_Free( &_Region_Information, &the_region->Object );
+}
+
+/*PAGE
+ *
+ *  _Region_Get
+ *
+ */
+
+STATIC INLINE Region_Control *_Region_Get (
+  Objects_Id         id,
+  Objects_Locations *location
+)
+{
+  return (Region_Control *)
+    _Objects_Get( &_Region_Information, id, location );
+}
+
+/*PAGE
+ *
+ *  _Region_Allocate_segment
+ *
+ */
+
+STATIC INLINE void *_Region_Allocate_segment (
+  Region_Control *the_region,
+  unsigned32      size
+)
+{
+   return _Heap_Allocate( &the_region->Memory, size );
+}
+
+/*PAGE
+ *
+ *  _Region_Free_segment
+ *
+ */
+
+STATIC INLINE boolean _Region_Free_segment (
+  Region_Control *the_region,
+  void           *the_segment
+)
+{
+  return _Heap_Free( &the_region->Memory, the_segment );
+}
+
+/*PAGE
+ *
+ *  _Region_Is_null
+ *
+ */
+
+STATIC INLINE boolean _Region_Is_null (
+  Region_Control *the_region
+)
+{
+  return ( the_region == NULL  );
+}
+
+#endif
+/* end of include file */