Update to use stdint/stdbool.h

git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@2386 42af7a65-404d-4744-a932-0658087f49c3

5 files changed, 836 insertions, 830 deletions

diff --git a/misc/pascal/plink/plink.c b/misc/pascal/plink/plink.c
index 22b5af45d..d304c49ad 100644
--- a/misc/pascal/plink/plink.c
+++ b/misc/pascal/plink/plink.c
@@ -1,549 +1,551 @@
-/**********************************************************************

- * plink.c

- * P-Code Linker

- *

- *   Copyright (C) 2008 Gregory Nutt. All rights reserved.

- *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>

- *

- * 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 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.

- * 3. Neither the name NuttX nor the names of its contributors may be

- *    used to endorse or promote products derived from this software

- *    without specific prior written permission.

- *

- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS

- * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE

- * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,

- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,

- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS

- * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

- * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

- * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

- * POSSIBILITY OF SUCH DAMAGE.

- *

- **********************************************************************/

-

-/**********************************************************************

- * Included Files

- **********************************************************************/

-

-#include <stdio.h>

-#include <stdlib.h>

-#include <string.h>

-#include <errno.h>

-

-#include "keywords.h"

-#include "pdefs.h"

-#include "podefs.h"

-#include "pedefs.h"

-

-#include "paslib.h"

-#include "perr.h"

-#include "plsym.h"

-#include "plreloc.h"

-#include "pinsn.h"

-#include "plink.h"

-

-/**********************************************************************

- * Definitions

- **********************************************************************/

-

-#define MAX_POFF_FILES          8

-

-/**********************************************************************

- * Private Type Definitions

- **********************************************************************/

-

-/**********************************************************************

- * Private Constant Data

- **********************************************************************/

-

-/**********************************************************************

- * Private Data

- **********************************************************************/

-

-static const char      *outFileName;

-static const char      *inFileName[MAX_POFF_FILES];

-static int              nPoffFiles      = 0;

-

-/**********************************************************************

- * Private Function Prototypes

- **********************************************************************/

-

-static void   showUsage        (const char *progname);

-static void   parseArgs        (int argc, char **argv);

-static void   loadInputFiles   (poffHandle_t outHandle);

-static void   checkFileHeader  (poffHandle_t inHandle, poffHandle_t outHandle,

-				uint32 pcOffset,boolean *progFound);

-static uint32 mergeRoData      (poffHandle_t inHandle, poffHandle_t outHandle);

-static uint32 mergeProgramData (poffHandle_t inHandle, poffHandle_t outHandle,

-				uint32 pcOffset, uint32 roOffset);

-static uint32 mergeFileNames   (poffHandle_t inHandle, poffHandle_t outHandle);

-static uint32 mergeLineNumbers (poffHandle_t inHandle, poffHandle_t outHandle,

-				uint32 pcOffset, uint32 fnOffset);

-static void   writeOutputFile  (poffHandle_t outHandle);

-

-/**********************************************************************

- * Global Variables

- **********************************************************************/

-

-/**********************************************************************

- * Private Variables

- **********************************************************************/

-

-/**********************************************************************

- * Public Functions

- **********************************************************************/

-

-int main(int argc, char *argv[], char *envp[])

-{

-  poffHandle_t outHandle;

-

-  /* Parse the command line arguments */

-

-  parseArgs(argc, argv);

-

-  /* Create a handle to hold the output file data */

-

-  outHandle = poffCreateHandle();

-  if (outHandle == NULL) fatal(eNOMEMORY);

-

-  /* Load the POFF files specified on the command line */

-

-  loadInputFiles(outHandle);

-

-  /* Verify that all symbols were processed correctly */

-

-  verifySymbols();

-

-  /* Apply the relocation data to the program data */

-

-  applyRelocations(outHandle);

-

-  /* Write the symbol table information to the output file */

-

-  writeSymbols(outHandle);

-

-  /* Write the output file */

-

-  writeOutputFile(outHandle);

-

-  /* Release bufferred symbol/relocation informtion */

-

-  releaseSymbols();

-  releaseRelocations();

-

-  /* Release the input file data */

-

-  poffDestroyHandle(outHandle);

-

-  return 0;

-

-} /* end main */

-

-/**********************************************************************

- * Private Functions

- **********************************************************************/

-

-static void showUsage(const char *progname)

-{

-  fprintf(stderr, "Usage:\n");

-  fprintf(stderr, "  %s <in-file-name> {<in-file-name>} <out-file-name>\n",

-	  progname);

-}

-

-/***********************************************************************/

-

-static void parseArgs(int argc, char **argv)

-{

-  int i;

-

-  /* Check for existence of filename argument */

-

-  if (argc < 3)

-    {

-      fprintf(stderr,

-	      "ERROR: <in-file-name> and one <out-file-name> required\n");

-      showUsage(argv[0]);

-    } /* end if */

-

-  /* Get the name of the p-code file(s) from the last argument(s) */

-

-  for (i = 1; i < argc-1; i++)

-    {

-      inFileName[nPoffFiles] = argv[i];

-      nPoffFiles++;

-    }

-

-  /* The last thing on the command line is the output file name */

-

-  outFileName = argv[argc-1];

-}

-

-/***********************************************************************/

-/* This function loads each POFF file specified on the command line,

- * merges the input POFF data, and generates intermediate structures

- * to be used in the final link.

- */

-

-static void loadInputFiles(poffHandle_t outHandle)

-{

-  poffHandle_t inHandle;

-  FILE        *instream;

-  char         fileName[FNAME_SIZE+1];  /* Object file name */

-  uint32       pcOffset = 0;

-  uint32       fnOffset = 0;

-  uint32       symOffset = 0;

-  uint32       roOffset = 0;

-  uint32       pcEnd = 0;

-  uint32       fnEnd = 0;

-  uint32       symEnd = 0;

-  uint16       errCode;

-  boolean      progFound = FALSE;

-  int          i;

-

-  /* Load the POFF files specified on the command line */

-

-  for (i = 0; i < nPoffFiles; i++)

-    {

-      /* Create a handle to hold the input file data */

-

-      inHandle = poffCreateHandle();

-      if (inHandle == NULL) fatal(eNOMEMORY);

-

-      /* Use .o or command line extension, if supplied, to get the

-       * input file name.

-       */

-

-      (void)extension(inFileName[i], "o", fileName, 0);

-

-      /* Open the input file */

-

-      instream = fopen(fileName, "rb");

-      if (instream == NULL)

-	{

-	  fprintf(stderr, "ERROR: Could not open %s: %s\n",

-		  fileName, strerror(errno));

-	  exit(1);

-	}

-

-      /* Load the POFF file */

-

-      errCode = poffReadFile(inHandle, instream);

-      if (errCode != eNOERROR)

-	{

-	  fprintf(stderr, "ERROR: Could not read %s (%d)\n",

-		  fileName, errCode);

-	  exit(1);

-	}

-

-      /* Check file header for critical settings */

-

-      checkFileHeader(inHandle, outHandle, pcOffset, &progFound);

-

-      /* Merge the read-only data sections */

-

-      roOffset = mergeRoData(inHandle, outHandle);

-

-      /* Merge program section data from the new input file into the

-       * output file container.

-       */

-

-      pcEnd = mergeProgramData(inHandle, outHandle, pcOffset, roOffset);

-

-      /* Merge the file name data from the new input file into the

-       * output file container.

-       */

-

-      fnEnd = mergeFileNames(inHandle, outHandle);

-

-      /* Merge the line number data from the new input file into the

-       * output file container.

-       */

-

-      (void)mergeLineNumbers(inHandle, outHandle, pcOffset, fnOffset);

-

-      /* On this pass, we just want to collect all symbol table in a

-       * local list where we can resolve all undefined symbols (later)

-       */

-

-      symEnd = mergeSymbols(inHandle, pcOffset, symOffset);

-

-      /* On this pass, we will also want to buffer all relocation data,

-       * adjusting only the program section offset and sym table

-       * offsets.

-       */

-

-      mergeRelocations(inHandle, pcOffset, symOffset);

-

-      /* Release the input file data */

-

-      insn_ResetOpCodeRead(inHandle);

-      poffDestroyHandle(inHandle);

-

-      /* Close the input file */

-

-      fclose(instream);

-

-      /* Set the offsest to be used for the next file equal

-       * to the end values found from processing this file

-       */

-

-      pcOffset  = pcEnd;

-      fnOffset  = fnEnd;

-      symOffset = symEnd;

-    }

-

-  /* Did we find exactly one program file? */

-

-  if (!progFound)

-    {

-      /* No! We have to have a program file to generate an executable */

-

-      fprintf(stderr, "ERROR: No program file found in input files\n");

-      exit(1);

-    }

-

-} /* end loadInputFiles */

-

-/***********************************************************************/

-

-static void checkFileHeader(poffHandle_t inHandle, poffHandle_t outHandle,

-			    uint32 pcOffset, boolean *progFound)

-{

-  ubyte fileType;

-

-  /* What kind of file are we processing? */

-

-  fileType = poffGetFileType(inHandle);

-  if (fileType == FHT_PROGRAM)

-    {

-      /* We can handle only one pascal program file */

-

-      if (*progFound)

-	{

-	  fprintf(stderr,

-		  "ERROR: Only one compiled pascal program file "

-		  "may appear in input file list\n");

-	  exit(1);

-	}

-      else

-	{

-	  /* Get the entry point from the pascal file, apply any

-	   * necessary offsets, and store the entry point in the

-	   * linked output file's file header.

-	   */

-

-	  poffSetEntryPoint(outHandle,

-			    poffGetEntryPoint(inHandle) + pcOffset);

-

-	  /* Copy the program name from the pascal file to the linked

-	   * output file's file header and mark the output file as

-	   * a pascal executable.

-	   */

-

-	  poffSetFileType(outHandle, FHT_EXEC, 0,

-			  poffGetFileHdrName(inHandle));

-

-	  /* Indicate that we have found the program file */

-

-	  *progFound = TRUE;

-	}

-    }

-  else if (fileType != FHT_UNIT)

-    {

-      /* It is something other than a compiled pascal program or unit

-       * file.

-       */

-

-      fprintf(stderr,

-	      "ERROR: Only compiled pascal program and unit files "

-	      "may appear in input file list\n");

-      exit(1);

-    }

-}

-

-/***********************************************************************/

-

-static uint32 mergeRoData(poffHandle_t inHandle, poffHandle_t outHandle)

-{

-  ubyte *newRoData;

-  uint32 oldRoDataSize;

-  uint32 newRoDataSize;

-

-  /* Get the size of the read-only data section before we add the

-   * new data.  This is the offset that must be applied to any

-   * references to the new data.

-   */

-

-  oldRoDataSize = poffGetRoDataSize(outHandle);

-

-  /* Remove the read-only data from new input file */

-

-  newRoDataSize = poffExtractRoData(inHandle, &newRoData);

-

-  /* And append the new read-only data to output file */

-

-  poffAppendRoData(outHandle, newRoData, newRoDataSize);

-

-  return oldRoDataSize;

-}

-      

-/***********************************************************************/

-/* This function merges the program data section of a new file into the

- * program data section of the output file, relocating simple program

- * section references as they are encountered.

- */

-

-static uint32 mergeProgramData(poffHandle_t inHandle,

-			       poffHandle_t outHandle,

-			       uint32 pcOffset, uint32 roOffset)

-{

-  OPTYPE op;

-  uint32 pc;

-  uint32 opSize;

-  int endOp;

-

-  /* Read each opcode from the input file, add pcOffset to each program

-   * section address, and add each opcode to the output file.

-   */

-

-  pc = pcOffset;

-  do

-    {

-      /* Read the next opcode (with its size) */

-

-      opSize = insn_GetOpCode(inHandle, &op);

-

-      /* Perform any necessary relocations */

-

-      endOp = insn_Relocate(&op, pcOffset, roOffset);

-

-      /* Save the potentially modified opcode in the temporary

-       * program data container.

-       */

-

-      insn_AddOpCode(outHandle, &op);

-      pc += opSize;

-    }

-  while (endOp == 0);

-

-  return pc;

-}

-

-/***********************************************************************/

-/* This function merges the file name section of a new file into the

- * file name section of the output file, relocating simple program

- * section references as they are encountered.

- */

-

-static uint32 mergeFileNames(poffHandle_t inHandle,

-			     poffHandle_t outHandle)

-{

-  sint32 inOffset;

-  uint32 outOffset;

-  const char *fname;

-

-  do

-    {

-      /* Read each file name from the input File */

-

-      inOffset = poffGetFileName(inHandle, &fname);

-      if (inOffset >= 0)

-	{

-	  /* And write it to the output file */

-

-	  outOffset = poffAddFileName(outHandle, fname);

-	}

-    }

-  while (inOffset >= 0);

-

-  /* Return the offset to the last file name written to the

-   * output file

-   */

-

-  return outOffset;

-}

-

-/***********************************************************************/

-/* This function merges the line number section of a new file into the

- * line number section of the output file, relocating simple program

- * section references as they are encountered.

- */

-

-static uint32 mergeLineNumbers(poffHandle_t inHandle,

-			       poffHandle_t outHandle,

-			       uint32 pcOffset,

-			       uint32 fnOffset)

-{

-  poffLineNumber_t lineno;

-  sint32 inOffset;

-  uint32 outOffset;

-

-  do

-    {

-      /* Read each line number from the input File */

-

-      inOffset = poffGetRawLineNumber(inHandle, &lineno);

-      if (inOffset >= 0)

-	{

-	  /* And write it to the output file */

-

-	  outOffset = poffAddLineNumber(outHandle, lineno.ln_lineno,

-					lineno.ln_fileno + fnOffset,

-					lineno.ln_poffset + pcOffset);

-	}

-    }

-  while (inOffset >= 0);

-

-  /* Return the offset to the last line number written to the

-   * output file

-   */

-

-  return outOffset;

-}

-

-/***********************************************************************/

-

-static void writeOutputFile(poffHandle_t outHandle)

-{

-  FILE *outstream;

-  char  fileName[FNAME_SIZE+1];  /* Output file name */

-

-  /* Use .pex or command line extension, if supplied, to get the

-   * input file name.

-   */

-

-  (void)extension(outFileName, "pex", fileName, 0);

-

-  /* Open the output file */

-

-  outstream = fopen(fileName, "wb");

-  if (outstream == NULL)

-    {

-      fprintf(stderr, "ERROR: Could not open %s: %s\n",

-	      fileName, strerror(errno));

-      exit(1);

-    }

-

-  /* Write the POFF file */

-

-  (void)poffWriteFile(outHandle, outstream);

-

-  /* Close the output file */

-

-  fclose(outstream);

-}

-

-/***********************************************************************/

+/**********************************************************************
+ * plink.c
+ * P-Code Linker
+ *
+ *   Copyright (C) 2008-2009 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * 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 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.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ **********************************************************************/
+
+/**********************************************************************
+ * Included Files
+ **********************************************************************/
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#include "keywords.h"
+#include "pdefs.h"
+#include "podefs.h"
+#include "pedefs.h"
+
+#include "paslib.h"
+#include "perr.h"
+#include "plsym.h"
+#include "plreloc.h"
+#include "pinsn.h"
+#include "plink.h"
+
+/**********************************************************************
+ * Definitions
+ **********************************************************************/
+
+#define MAX_POFF_FILES  8
+
+/**********************************************************************
+ * Private Type Definitions
+ **********************************************************************/
+
+/**********************************************************************
+ * Private Constant Data
+ **********************************************************************/
+
+/**********************************************************************
+ * Private Data
+ **********************************************************************/
+
+static const char *outFileName;
+static const char *inFileName[MAX_POFF_FILES];
+static int         nPoffFiles      = 0;
+
+/**********************************************************************
+ * Private Function Prototypes
+ **********************************************************************/
+
+static void     showUsage        (const char *progname);
+static void     parseArgs        (int argc, char **argv);
+static void     loadInputFiles   (poffHandle_t outHandle);
+static void     checkFileHeader  (poffHandle_t inHandle, poffHandle_t outHandle,
+				  uint32_t pcOffset, bool *progFound);
+static uint32_t mergeRoData      (poffHandle_t inHandle, poffHandle_t outHandle);
+static uint32_t mergeProgramData (poffHandle_t inHandle, poffHandle_t outHandle,
+				  uint32_t pcOffset, uint32_t roOffset);
+static uint32_t mergeFileNames   (poffHandle_t inHandle, poffHandle_t outHandle);
+static uint32_t mergeLineNumbers (poffHandle_t inHandle, poffHandle_t outHandle,
+				  uint32_t pcOffset, uint32_t fnOffset);
+static void     writeOutputFile  (poffHandle_t outHandle);
+
+/**********************************************************************
+ * Global Variables
+ **********************************************************************/
+
+/**********************************************************************
+ * Private Variables
+ **********************************************************************/
+
+/**********************************************************************
+ * Public Functions
+ **********************************************************************/
+
+int main(int argc, char *argv[], char *envp[])
+{
+  poffHandle_t outHandle;
+
+  /* Parse the command line arguments */
+
+  parseArgs(argc, argv);
+
+  /* Create a handle to hold the output file data */
+
+  outHandle = poffCreateHandle();
+  if (outHandle == NULL) fatal(eNOMEMORY);
+
+  /* Load the POFF files specified on the command line */
+
+  loadInputFiles(outHandle);
+
+  /* Verify that all symbols were processed correctly */
+
+  verifySymbols();
+
+  /* Apply the relocation data to the program data */
+
+  applyRelocations(outHandle);
+
+  /* Write the symbol table information to the output file */
+
+  writeSymbols(outHandle);
+
+  /* Write the output file */
+
+  writeOutputFile(outHandle);
+
+  /* Release bufferred symbol/relocation informtion */
+
+  releaseSymbols();
+  releaseRelocations();
+
+  /* Release the input file data */
+
+  poffDestroyHandle(outHandle);
+
+  return 0;
+
+} /* end main */
+
+/**********************************************************************
+ * Private Functions
+ **********************************************************************/
+
+static void showUsage(const char *progname)
+{
+  fprintf(stderr, "Usage:\n");
+  fprintf(stderr, "  %s <in-file-name> {<in-file-name>} <out-file-name>\n",
+	  progname);
+}
+
+/***********************************************************************/
+
+static void parseArgs(int argc, char **argv)
+{
+  int i;
+
+  /* Check for existence of filename argument */
+
+  if (argc < 3)
+    {
+      fprintf(stderr,
+	      "ERROR: <in-file-name> and one <out-file-name> required\n");
+      showUsage(argv[0]);
+    } /* end if */
+
+  /* Get the name of the p-code file(s) from the last argument(s) */
+
+  for (i = 1; i < argc-1; i++)
+    {
+      inFileName[nPoffFiles] = argv[i];
+      nPoffFiles++;
+    }
+
+  /* The last thing on the command line is the output file name */
+
+  outFileName = argv[argc-1];
+}
+
+/***********************************************************************/
+/* This function loads each POFF file specified on the command line,
+ * merges the input POFF data, and generates intermediate structures
+ * to be used in the final link.
+ */
+
+static void loadInputFiles(poffHandle_t outHandle)
+{
+  poffHandle_t inHandle;
+  FILE        *instream;
+  char         fileName[FNAME_SIZE+1];  /* Object file name */
+  uint32_t     pcOffset = 0;
+  uint32_t     fnOffset = 0;
+  uint32_t     symOffset = 0;
+  uint32_t     roOffset = 0;
+  uint32_t     pcEnd = 0;
+  uint32_t     fnEnd = 0;
+  uint32_t     symEnd = 0;
+  uint16_t     errCode;
+  bool         progFound = false;
+  int          i;
+
+  /* Load the POFF files specified on the command line */
+
+  for (i = 0; i < nPoffFiles; i++)
+    {
+      /* Create a handle to hold the input file data */
+
+      inHandle = poffCreateHandle();
+      if (inHandle == NULL) fatal(eNOMEMORY);
+
+      /* Use .o or command line extension, if supplied, to get the
+       * input file name.
+       */
+
+      (void)extension(inFileName[i], "o", fileName, 0);
+
+      /* Open the input file */
+
+      instream = fopen(fileName, "rb");
+      if (instream == NULL)
+	{
+	  fprintf(stderr, "ERROR: Could not open %s: %s\n",
+		  fileName, strerror(errno));
+	  exit(1);
+	}
+
+      /* Load the POFF file */
+
+      errCode = poffReadFile(inHandle, instream);
+      if (errCode != eNOERROR)
+	{
+	  fprintf(stderr, "ERROR: Could not read %s (%d)\n",
+		  fileName, errCode);
+	  exit(1);
+	}
+
+      /* Check file header for critical settings */
+
+      checkFileHeader(inHandle, outHandle, pcOffset, &progFound);
+
+      /* Merge the read-only data sections */
+
+      roOffset = mergeRoData(inHandle, outHandle);
+
+      /* Merge program section data from the new input file into the
+       * output file container.
+       */
+
+      pcEnd = mergeProgramData(inHandle, outHandle, pcOffset, roOffset);
+
+      /* Merge the file name data from the new input file into the
+       * output file container.
+       */
+
+      fnEnd = mergeFileNames(inHandle, outHandle);
+
+      /* Merge the line number data from the new input file into the
+       * output file container.
+       */
+
+      (void)mergeLineNumbers(inHandle, outHandle, pcOffset, fnOffset);
+
+      /* On this pass, we just want to collect all symbol table in a
+       * local list where we can resolve all undefined symbols (later)
+       */
+
+      symEnd = mergeSymbols(inHandle, pcOffset, symOffset);
+
+      /* On this pass, we will also want to buffer all relocation data,
+       * adjusting only the program section offset and sym table
+       * offsets.
+       */
+
+      mergeRelocations(inHandle, pcOffset, symOffset);
+
+      /* Release the input file data */
+
+      insn_ResetOpCodeRead(inHandle);
+      poffDestroyHandle(inHandle);
+
+      /* Close the input file */
+
+      fclose(instream);
+
+      /* Set the offsest to be used for the next file equal
+       * to the end values found from processing this file
+       */
+
+      pcOffset  = pcEnd;
+      fnOffset  = fnEnd;
+      symOffset = symEnd;
+    }
+
+  /* Did we find exactly one program file? */
+
+  if (!progFound)
+    {
+      /* No! We have to have a program file to generate an executable */
+
+      fprintf(stderr, "ERROR: No program file found in input files\n");
+      exit(1);
+    }
+
+} /* end loadInputFiles */
+
+/***********************************************************************/
+
+static void checkFileHeader(poffHandle_t inHandle, poffHandle_t outHandle,
+			    uint32_t pcOffset, bool *progFound)
+{
+  uint8_t fileType;
+
+  /* What kind of file are we processing? */
+
+  fileType = poffGetFileType(inHandle);
+  if (fileType == FHT_PROGRAM)
+    {
+      /* We can handle only one pascal program file */
+
+      if (*progFound)
+	{
+	  fprintf(stderr,
+		  "ERROR: Only one compiled pascal program file "
+		  "may appear in input file list\n");
+	  exit(1);
+	}
+      else
+	{
+	  /* Get the entry point from the pascal file, apply any
+	   * necessary offsets, and store the entry point in the
+	   * linked output file's file header.
+	   */
+
+	  poffSetEntryPoint(outHandle,
+			    poffGetEntryPoint(inHandle) + pcOffset);
+
+	  /* Copy the program name from the pascal file to the linked
+	   * output file's file header and mark the output file as
+	   * a pascal executable.
+	   */
+
+	  poffSetFileType(outHandle, FHT_EXEC, 0,
+			  poffGetFileHdrName(inHandle));
+
+	  /* Indicate that we have found the program file */
+
+	  *progFound = true;
+	}
+    }
+  else if (fileType != FHT_UNIT)
+    {
+      /* It is something other than a compiled pascal program or unit
+       * file.
+       */
+
+      fprintf(stderr,
+	      "ERROR: Only compiled pascal program and unit files "
+	      "may appear in input file list\n");
+      exit(1);
+    }
+}
+
+/***********************************************************************/
+
+static uint32_t mergeRoData(poffHandle_t inHandle, poffHandle_t outHandle)
+{
+  uint8_t *newRoData;
+  uint32_t oldRoDataSize;
+  uint32_t newRoDataSize;
+
+  /* Get the size of the read-only data section before we add the
+   * new data.  This is the offset that must be applied to any
+   * references to the new data.
+   */
+
+  oldRoDataSize = poffGetRoDataSize(outHandle);
+
+  /* Remove the read-only data from new input file */
+
+  newRoDataSize = poffExtractRoData(inHandle, &newRoData);
+
+  /* And append the new read-only data to output file */
+
+  poffAppendRoData(outHandle, newRoData, newRoDataSize);
+
+  return oldRoDataSize;
+}
+      
+/***********************************************************************/
+/* This function merges the program data section of a new file into the
+ * program data section of the output file, relocating simple program
+ * section references as they are encountered.
+ */
+
+static uint32_t mergeProgramData(poffHandle_t inHandle,
+			       poffHandle_t outHandle,
+			       uint32_t pcOffset, uint32_t roOffset)
+{
+  OPTYPE op;
+  uint32_t pc;
+  uint32_t opSize;
+  int endOp;
+
+  /* Read each opcode from the input file, add pcOffset to each program
+   * section address, and add each opcode to the output file.
+   */
+
+  pc = pcOffset;
+  do
+    {
+      /* Read the next opcode (with its size) */
+
+      opSize = insn_GetOpCode(inHandle, &op);
+
+      /* Perform any necessary relocations */
+
+      endOp = insn_Relocate(&op, pcOffset, roOffset);
+
+      /* Save the potentially modified opcode in the temporary
+       * program data container.
+       */
+
+      insn_AddOpCode(outHandle, &op);
+      pc += opSize;
+    }
+  while (endOp == 0);
+
+  return pc;
+}
+
+/***********************************************************************/
+/* This function merges the file name section of a new file into the
+ * file name section of the output file, relocating simple program
+ * section references as they are encountered.
+ */
+
+static uint32_t mergeFileNames(poffHandle_t inHandle,
+			     poffHandle_t outHandle)
+{
+  int32_t inOffset;
+  uint32_t outOffset;
+  const char *fname;
+
+  do
+    {
+      /* Read each file name from the input File */
+
+      inOffset = poffGetFileName(inHandle, &fname);
+      if (inOffset >= 0)
+	{
+	  /* And write it to the output file */
+
+	  outOffset = poffAddFileName(outHandle, fname);
+	}
+    }
+  while (inOffset >= 0);
+
+  /* Return the offset to the last file name written to the
+   * output file
+   */
+
+  return outOffset;
+}
+
+/***********************************************************************/
+/* This function merges the line number section of a new file into the
+ * line number section of the output file, relocating simple program
+ * section references as they are encountered.
+ */
+
+static uint32_t mergeLineNumbers(poffHandle_t inHandle,
+			       poffHandle_t outHandle,
+			       uint32_t pcOffset,
+			       uint32_t fnOffset)
+{
+  poffLineNumber_t lineno;
+  int32_t inOffset;
+  uint32_t outOffset;
+
+  do
+    {
+      /* Read each line number from the input File */
+
+      inOffset = poffGetRawLineNumber(inHandle, &lineno);
+      if (inOffset >= 0)
+	{
+	  /* And write it to the output file */
+
+	  outOffset = poffAddLineNumber(outHandle, lineno.ln_lineno,
+					lineno.ln_fileno + fnOffset,
+					lineno.ln_poffset + pcOffset);
+	}
+    }
+  while (inOffset >= 0);
+
+  /* Return the offset to the last line number written to the
+   * output file
+   */
+
+  return outOffset;
+}
+
+/***********************************************************************/
+
+static void writeOutputFile(poffHandle_t outHandle)
+{
+  FILE *outstream;
+  char  fileName[FNAME_SIZE+1];  /* Output file name */
+
+  /* Use .pex or command line extension, if supplied, to get the
+   * input file name.
+   */
+
+  (void)extension(outFileName, "pex", fileName, 0);
+
+  /* Open the output file */
+
+  outstream = fopen(fileName, "wb");
+  if (outstream == NULL)
+    {
+      fprintf(stderr, "ERROR: Could not open %s: %s\n",
+	      fileName, strerror(errno));
+      exit(1);
+    }
+
+  /* Write the POFF file */
+
+  (void)poffWriteFile(outHandle, outstream);
+
+  /* Close the output file */
+
+  fclose(outstream);
+}
+
+/***********************************************************************/
diff --git a/misc/pascal/plink/plreloc.c b/misc/pascal/plink/plreloc.c
index 32911570c..0faf0715c 100644
--- a/misc/pascal/plink/plreloc.c
+++ b/misc/pascal/plink/plreloc.c
@@ -2,7 +2,7 @@
  * plreloc.c
  * Relocation management for the P-Code Linker
  *
- *   Copyright (C) 2008 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2008-2009 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -38,6 +38,7 @@
  * Included Files
  **********************************************************************/
 
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -56,7 +57,7 @@
 #include "plreloc.h"
 
 /**********************************************************************
- * Definitions
+ * Pre-processor Definitions
  **********************************************************************/
 
 #define INITIAL_RELOC_LIST_SIZE (1024*sizeof(poffRelocation_t*))
@@ -71,8 +72,8 @@
  **********************************************************************/
 
 static poffRelocation_t *relocList      = NULL;
-static uint32            relocListAlloc = 0;
-static uint32            nRelocs        = 0;
+static uint32_t          relocListAlloc = 0;
+static uint32_t          nRelocs        = 0;
 
 /**********************************************************************
  * Private Function Prototypes
@@ -80,7 +81,7 @@ static uint32            nRelocs        = 0;
  **********************************************************************/
 
 static void offsetRelocation(poffRelocation_t *reloc,
-			     uint32 pcOffset, uint32 symOffset);
+                             uint32_t pcOffset, uint32_t symOffset);
 static void addRelocToList(poffRelocation_t *reloc);
 
 /**********************************************************************
@@ -88,10 +89,10 @@ static void addRelocToList(poffRelocation_t *reloc);
  **********************************************************************/
 
 void mergeRelocations(poffHandle_t inHandle,
-		      uint32 pcOffset, uint32 symOffset)
+                      uint32_t pcOffset, uint32_t symOffset)
 {
   poffRelocation_t reloc;
-  sint32 index;
+  int32_t index;
 
   do
     {
@@ -99,18 +100,18 @@ void mergeRelocations(poffHandle_t inHandle,
 
       index = poffGetRawRelocation(inHandle, &reloc);
       if (index >= 0)
-	{
-	  /* If the rellocation carries a "payload" that is a program
-	   * section offset, then apply the pcOffset value to
-	   * that "payload"
-	   */
+        {
+          /* If the rellocation carries a "payload" that is a program
+           * section offset, then apply the pcOffset value to
+           * that "payload"
+           */
 
-	  offsetRelocation(&reloc, pcOffset, symOffset);
+          offsetRelocation(&reloc, pcOffset, symOffset);
 
-	  /* Add the relocation to the in-memory relocation list */
+          /* Add the relocation to the in-memory relocation list */
 
-	  addRelocToList(&reloc);
-	}
+          addRelocToList(&reloc);
+        }
     }
   while (index >= 0);
 }
@@ -119,8 +120,8 @@ void mergeRelocations(poffHandle_t inHandle,
 
 void applyRelocations(poffHandle_t outHandle)
 {
-  ubyte *progData;
-  uint32 progSize;
+  uint8_t *progData;
+  uint32_t progSize;
   int    i;
 
   /* Take ownership of the program data image for a little while */
@@ -132,39 +133,39 @@ void applyRelocations(poffHandle_t outHandle)
   for (i = 0; i < nRelocs; i++)
     {
       poffRelocation_t *reloc = &relocList[i];
-      uint32            symIndex = RLI_SYM(reloc->rl_info);
-      uint32            relType  = RLI_TYPE(reloc->rl_info);
+      uint32_t          symIndex = RLI_SYM(reloc->rl_info);
+      uint32_t          relType  = RLI_TYPE(reloc->rl_info);
       poffLibSymbol_t  *sym;
-      uint32            progIndex;
+      uint32_t          progIndex;
 
       switch (relType)
-	{
-	case RLT_PCAL:
-	  /* Get the symbol referenced by the relocation.  At this
-	   * point, we assume that the system has already verified
-	   * that there are no undefined symbols.
-	   */
+        {
+        case RLT_PCAL:
+          /* Get the symbol referenced by the relocation.  At this
+           * point, we assume that the system has already verified
+           * that there are no undefined symbols.
+           */
 
-	  sym = getSymbolByIndex(symIndex);
+          sym = getSymbolByIndex(symIndex);
 
-	  /* Get the index to the oPCAL instruction */
+          /* Get the index to the oPCAL instruction */
 
-	  progIndex = reloc->rl_offset;
+          progIndex = reloc->rl_offset;
 
-	  /* Sanity checking */
+          /* Sanity checking */
 
-	  if (((sym->flags & STF_UNDEFINED) != 0) ||
-	      (progIndex > progSize-4))
-	    fatal(ePOFFCONFUSION);
+          if (((sym->flags & STF_UNDEFINED) != 0) ||
+              (progIndex > progSize-4))
+            fatal(ePOFFCONFUSION);
 
-	  /* Perform the relocation */
+          /* Perform the relocation */
 
-	  insn_FixupProcedureCall(&progData[progIndex], sym->value);
-	  break;
+          insn_FixupProcedureCall(&progData[progIndex], sym->value);
+          break;
 
-	default:
-	  break;
-	}
+        default:
+          break;
+        }
     }
 
 
@@ -186,10 +187,10 @@ void releaseRelocations(void)
  **********************************************************************/
 
 static void offsetRelocation(poffRelocation_t *reloc,
-			     uint32 pcOffset, uint32 symOffset)
+                             uint32_t pcOffset, uint32_t symOffset)
 {
-  uint32 symIndex = RLI_SYM(reloc->rl_info);
-  uint32 relType  = RLI_TYPE(reloc->rl_info);
+  uint32_t symIndex = RLI_SYM(reloc->rl_info);
+  uint32_t relType  = RLI_TYPE(reloc->rl_info);
 
   switch (relType)
     {
@@ -217,9 +218,9 @@ static void addRelocToList(poffRelocation_t *reloc)
 
       relocList = (poffRelocation_t*)malloc(INITIAL_RELOC_LIST_SIZE);
       if (!relocList)
-	{
-	  fatal(eNOMEMORY);
-	}
+        {
+          fatal(eNOMEMORY);
+        }
       relocListAlloc = INITIAL_RELOC_LIST_SIZE;
     }
 
@@ -227,16 +228,16 @@ static void addRelocToList(poffRelocation_t *reloc)
 
   if ((nRelocs + 1) * sizeof(poffRelocation_t) > relocListAlloc)
     {
-      uint32 newAlloc = relocListAlloc + RELOC_LIST_INCREMENT;
+      uint32_t newAlloc = relocListAlloc + RELOC_LIST_INCREMENT;
       poffRelocation_t *tmp;
 
       /* Reallocate the file name buffer */
 
       tmp = (poffRelocation_t*)realloc(relocList, newAlloc);
       if (!tmp)
-	{
-	  fatal(eNOMEMORY);
-	}
+        {
+          fatal(eNOMEMORY);
+        }
 
       /* And set the new size */
 
diff --git a/misc/pascal/plink/plreloc.h b/misc/pascal/plink/plreloc.h
index 1998361b9..d8dd89476 100644
--- a/misc/pascal/plink/plreloc.h
+++ b/misc/pascal/plink/plreloc.h
@@ -1,59 +1,60 @@
-/***************************************************************************

- * plreloc.h

- * External Declarations associated with plreloc.c

- *

- *   Copyright (C) 2008 Gregory Nutt. All rights reserved.

- *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>

- *

- * 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 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.

- * 3. Neither the name NuttX nor the names of its contributors may be

- *    used to endorse or promote products derived from this software

- *    without specific prior written permission.

- *

- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS

- * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE

- * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,

- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,

- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS

- * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

- * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

- * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

- * POSSIBILITY OF SUCH DAMAGE.

- *

- ***************************************************************************/

-

-#ifndef __PLRELOC_H

-#define __PLRELOC_H

-

-/***************************************************************************

- * Included Files

- ***************************************************************************/

-

-#include "pofflib.h"

-

-/***************************************************************************

- * Global Variables

- ***************************************************************************/

-

-/***************************************************************************

- * Global Function Prototypes

- ***************************************************************************/

-

-extern void mergeRelocations(poffHandle_t inHandle,

-			     uint32 pcOffset, uint32 symOffset);

-extern void applyRelocations(poffHandle_t outHandle);

-extern void releaseRelocations(void);

-

-#endif /* __PLRELOC_H */

+/***************************************************************************
+ * plreloc.h
+ * External Declarations associated with plreloc.c
+ *
+ *   Copyright (C) 2008-2009 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * 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 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.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ***************************************************************************/
+
+#ifndef __PLRELOC_H
+#define __PLRELOC_H
+
+/***************************************************************************
+ * Included Files
+ ***************************************************************************/
+
+#include <stdint.h>
+#include "pofflib.h"
+
+/***************************************************************************
+ * Global Variables
+ ***************************************************************************/
+
+/***************************************************************************
+ * Global Function Prototypes
+ ***************************************************************************/
+
+extern void mergeRelocations(poffHandle_t inHandle,
+                             uint32_t pcOffset, uint32_t symOffset);
+extern void applyRelocations(poffHandle_t outHandle);
+extern void releaseRelocations(void);
+
+#endif /* __PLRELOC_H */
diff --git a/misc/pascal/plink/plsym.c b/misc/pascal/plink/plsym.c
index 1ef40461a..ceeb0c4f7 100644
--- a/misc/pascal/plink/plsym.c
+++ b/misc/pascal/plink/plsym.c
@@ -2,7 +2,7 @@
  * plsym.c
  * Symbol management for the P-Code Linker
  *
- *   Copyright (C) 2008 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2008-2009 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -38,6 +38,7 @@
  * Included Files
  **********************************************************************/
 
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -54,7 +55,7 @@
 #include "plsym.h"
 
 /**********************************************************************
- * Definitions
+ * Pre-processor Definitions
  **********************************************************************/
 
 #define INITIAL_SYMBOL_LIST_SIZE (1024*sizeof(symContainer_t*))
@@ -81,7 +82,7 @@ typedef struct symContainer_s symContainer_t;
 static symContainer_t  *symHead          = NULL;
 static symContainer_t  *symTail          = NULL;
 static symContainer_t **symList          = NULL;
-static uint32           symListAlloc     = 0;
+static uint32_t         symListAlloc     = 0;
 
 static int              nUndefined       = 0;
 static int              nMultiplyDefined = 0;
@@ -92,21 +93,21 @@ static int              nMultiplyDefined = 0;
  **********************************************************************/
 
 static void            offsetSymbolValue(poffLibSymbol_t *sym,
-					 uint32 pcOffset);
+                                         uint32_t pcOffset);
 static symContainer_t *insertSymbol(poffLibSymbol_t *sym);
 static void            addSymbolToList(symContainer_t *symbol,
-				       uint32 index);
+                                       uint32_t index);
 
 /**********************************************************************
  * Public Functions
  **********************************************************************/
 
-uint32 mergeSymbols(poffHandle_t inHandle, uint32 pcOffset, uint32 symOffset)
+uint32_t mergeSymbols(poffHandle_t inHandle, uint32_t pcOffset, uint32_t symOffset)
 {
   poffLibSymbol_t symbol;
   symContainer_t *container;
-  sint32 inIndex;
-  uint32 outIndex;
+  int32_t inIndex;
+  uint32_t outIndex;
 
   do
     {
@@ -114,23 +115,23 @@ uint32 mergeSymbols(poffHandle_t inHandle, uint32 pcOffset, uint32 symOffset)
 
       inIndex = poffGetSymbol(inHandle, &symbol);
       if (inIndex >= 0)
-	{
-	  /* If the symbol carries a "payload" that is a program
-	   * section offset, then apply the pcOffset value to
-	   * that "payload"
-	   */
+        {
+          /* If the symbol carries a "payload" that is a program
+           * section offset, then apply the pcOffset value to
+           * that "payload"
+           */
 
-	  offsetSymbolValue(&symbol, pcOffset);
+          offsetSymbolValue(&symbol, pcOffset);
 
-	  /* Create a container for the symbol information */
+          /* Create a container for the symbol information */
 
-	  container = insertSymbol(&symbol);
+          container = insertSymbol(&symbol);
 
-	  /* Add the symbol to the linearly indexed list */
+          /* Add the symbol to the linearly indexed list */
 
-	  outIndex = inIndex + symOffset;
-	  addSymbolToList(container, outIndex);
-	}
+          outIndex = inIndex + symOffset;
+          addSymbolToList(container, outIndex);
+        }
     }
   while (inIndex >= 0);
 
@@ -154,11 +155,11 @@ void verifySymbols(void)
   for (sym = symHead; (sym); sym = sym->next)
     {
       if ((sym->s.flags & STF_UNDEFINED) != 0)
-	{
-	  fprintf(stderr, "ERROR: Undefined symbol '%s'\n",
-		  sym->s.name);
-	  nUndefined++;
-	}
+        {
+          fprintf(stderr, "ERROR: Undefined symbol '%s'\n",
+                  sym->s.name);
+          nUndefined++;
+        }
     }
 
   if (nUndefined) fatal(eUNDEFINEDSYMBOL);
@@ -181,7 +182,7 @@ void writeSymbols(poffHandle_t outHandle)
 
 /***********************************************************************/
 
-poffLibSymbol_t *getSymbolByIndex(uint32 symIndex)
+poffLibSymbol_t *getSymbolByIndex(uint32_t symIndex)
 {
   if (symIndex * sizeof(symContainer_t*) >= symListAlloc)
     fatal(ePOFFCONFUSION);
@@ -223,7 +224,7 @@ void releaseSymbols(void)
 
 /**********************************************************************/
 
-static void offsetSymbolValue(poffLibSymbol_t *sym, uint32 pcOffset)
+static void offsetSymbolValue(poffLibSymbol_t *sym, uint32_t pcOffset)
 {
   /* Don't do anything with undefined symbols.  By definition, these
    * cannot cannot any meaning values.
@@ -232,15 +233,15 @@ static void offsetSymbolValue(poffLibSymbol_t *sym, uint32 pcOffset)
   if ((sym->flags & STF_UNDEFINED) == 0)
     {
       switch (sym->type)
-	{
-	case STT_PROC:
-	case STT_FUNC:
-	  sym->value += pcOffset;
-	  break;
-
-	default:
-	  break;
-	}
+        {
+        case STT_PROC:
+        case STT_FUNC:
+          sym->value += pcOffset;
+          break;
+
+        default:
+          break;
+        }
     }
 }
 
@@ -297,30 +298,30 @@ static symContainer_t *insertSymbol(poffLibSymbol_t *sym)
        */
 
       if (compare > 0)
-	{
-	  /* Break out... curr refers to a symbol AFTER the position
-	   * where we want to put the new symbol.
-	   */
+        {
+          /* Break out... curr refers to a symbol AFTER the position
+           * where we want to put the new symbol.
+           */
 
-	  break;
-	}
+          break;
+        }
       else if (compare == 0)
-	{
-	  /* The symbols are the same.  break out only if the types
-	   * are the same or this is where we need to insert the new
-	   * symbol (same name different type)
-	   */
-
-	  if (curr->s.type > sym->type)
-	    {
-	      compare = 1;
-	      break;
-	    }
-	  else if (curr->s.type == sym->type)
-	    {
-	      break;
-	    }
-	}
+        {
+          /* The symbols are the same.  break out only if the types
+           * are the same or this is where we need to insert the new
+           * symbol (same name different type)
+           */
+
+          if (curr->s.type > sym->type)
+            {
+              compare = 1;
+              break;
+            }
+          else if (curr->s.type == sym->type)
+            {
+              break;
+            }
+        }
     }
 
   /* We get here if:
@@ -343,9 +344,9 @@ static symContainer_t *insertSymbol(poffLibSymbol_t *sym)
       symTail      = newsym;
 
       if (prev)
-	prev->next = newsym;
+        prev->next = newsym;
       else
-	symHead    = newsym;
+        symHead    = newsym;
     }
   else if (compare == 0)
     {
@@ -355,48 +356,48 @@ static symContainer_t *insertSymbol(poffLibSymbol_t *sym)
        */
 
       if ((curr->s.flags & STF_UNDEFINED) != 0)
-	{
-	  /* The symbol in the table is undefined */
-
-	  if ((sym->flags & STF_UNDEFINED) != 0)
-	    {
-	      /* Both symbols are undefined. Just ignore the new one */
-	    }
-	  else
-	    {
-	      /* The symbol in the table is undefined, but the new
-	       * one is defined. Replace the one in the table (retaining
-	       * the allocated symbol name).
-	       */
-	      const char *save   = curr->s.name;
-	      curr->s            = *sym;
-	      curr->s.name       = save;
-	    }
-	}
+        {
+          /* The symbol in the table is undefined */
+
+          if ((sym->flags & STF_UNDEFINED) != 0)
+            {
+              /* Both symbols are undefined. Just ignore the new one */
+            }
+          else
+            {
+              /* The symbol in the table is undefined, but the new
+               * one is defined. Replace the one in the table (retaining
+               * the allocated symbol name).
+               */
+              const char *save   = curr->s.name;
+              curr->s            = *sym;
+              curr->s.name       = save;
+            }
+        }
       else
-	{
-	  /* The symbol in the table is defined */
-
-	  if ((sym->flags & STF_UNDEFINED) != 0)
-	    {
-	      /* But the new symbol is undefined.  Just ignore the
-	       * new symbol
-	       */
-	    }
-	  else
-	    {
-	      /* OOPS! both symbols are defined */
-
-	      fprintf(stderr,
-		      "ERROR: Multiply defined symbol: '%s'\n",
-		      sym->name);
-	      nMultiplyDefined++;
-	    }
-
-	  /* In any case, return the pointer to the old container */
-
-	  newsym = curr;
-	}
+        {
+          /* The symbol in the table is defined */
+
+          if ((sym->flags & STF_UNDEFINED) != 0)
+            {
+              /* But the new symbol is undefined.  Just ignore the
+               * new symbol
+               */
+            }
+          else
+            {
+              /* OOPS! both symbols are defined */
+
+              fprintf(stderr,
+                      "ERROR: Multiply defined symbol: '%s'\n",
+                      sym->name);
+              nMultiplyDefined++;
+            }
+
+          /* In any case, return the pointer to the old container */
+
+          newsym = curr;
+        }
     }
   else
     {
@@ -407,9 +408,9 @@ static symContainer_t *insertSymbol(poffLibSymbol_t *sym)
       newsym->prev = prev;
       
       if (prev)
-	prev->next = newsym;
+        prev->next = newsym;
       else
-	symHead    = newsym;
+        symHead    = newsym;
     }
 
   return newsym;
@@ -422,7 +423,7 @@ static symContainer_t *insertSymbol(poffLibSymbol_t *sym)
  * deterimed by insertSymbol().
  */
 
-static void addSymbolToList(symContainer_t *symbol, uint32 index)
+static void addSymbolToList(symContainer_t *symbol, uint32_t index)
 {
   /* Check if we have allocated a symbol table buffer yet */
 
@@ -432,9 +433,9 @@ static void addSymbolToList(symContainer_t *symbol, uint32 index)
 
       symList = (symContainer_t**)malloc(INITIAL_SYMBOL_LIST_SIZE);
       if (!symList)
-	{
-	  fatal(eNOMEMORY);
-	}
+        {
+          fatal(eNOMEMORY);
+        }
       symListAlloc = INITIAL_SYMBOL_LIST_SIZE;
     }
 
@@ -442,16 +443,16 @@ static void addSymbolToList(symContainer_t *symbol, uint32 index)
 
   if ((index + 1) * sizeof(symContainer_t*) > symListAlloc)
     {
-      uint32 newAlloc = symListAlloc + SYMBOL_LIST_INCREMENT;
+      uint32_t newAlloc = symListAlloc + SYMBOL_LIST_INCREMENT;
       symContainer_t **tmp;
 
       /* Reallocate the file name buffer */
 
       tmp = (symContainer_t**)realloc(symList, newAlloc);
       if (!tmp)
-	{
-	  fatal(eNOMEMORY);
-	}
+        {
+          fatal(eNOMEMORY);
+        }
 
       /* And set the new size */
 
diff --git a/misc/pascal/plink/plsym.h b/misc/pascal/plink/plsym.h
index 96f520148..69218830f 100644
--- a/misc/pascal/plink/plsym.h
+++ b/misc/pascal/plink/plsym.h
@@ -1,61 +1,62 @@
-/***************************************************************************

- * plsym.h

- * External Declarations associated with plsym.c

- *

- *   Copyright (C) 2008 Gregory Nutt. All rights reserved.

- *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>

- *

- * 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 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.

- * 3. Neither the name NuttX nor the names of its contributors may be

- *    used to endorse or promote products derived from this software

- *    without specific prior written permission.

- *

- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS

- * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE

- * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,

- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,

- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS

- * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

- * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

- * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

- * POSSIBILITY OF SUCH DAMAGE.

- *

- ***************************************************************************/

-

-#ifndef __PLSYM_H

-#define __PLSYM_H

-

-/***************************************************************************

- * Included Files

- ***************************************************************************/

-

-#include "pofflib.h"

-

-/***************************************************************************

- * Global Variables

- ***************************************************************************/

-

-/***************************************************************************

- * Global Function Prototypes

- ***************************************************************************/

-

-extern uint32           mergeSymbols(poffHandle_t inHandle,

-				     uint32 pcOffset, uint32 symOffset);

-extern void             verifySymbols(void);

-extern void             writeSymbols(poffHandle_t outHandle);

-extern poffLibSymbol_t *getSymbolByIndex(uint32 symIndex);

-extern void             releaseSymbols(void);

-

-#endif /* __PLSYM_H */

+/***************************************************************************
+ * plsym.h
+ * External Declarations associated with plsym.c
+ *
+ *   Copyright (C) 2008-2009 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * 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 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.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ***************************************************************************/
+
+#ifndef __PLSYM_H
+#define __PLSYM_H
+
+/***************************************************************************
+ * Included Files
+ ***************************************************************************/
+
+#include <stdint.h>
+#include "pofflib.h"
+
+/***************************************************************************
+ * Global Variables
+ ***************************************************************************/
+
+/***************************************************************************
+ * Global Function Prototypes
+ ***************************************************************************/
+
+extern uint32_t         mergeSymbols(poffHandle_t inHandle,
+                                     uint32_t pcOffset, uint32_t symOffset);
+extern void             verifySymbols(void);
+extern void             writeSymbols(poffHandle_t outHandle);
+extern poffLibSymbol_t *getSymbolByIndex(uint32_t symIndex);
+extern void             releaseSymbols(void);
+
+#endif /* __PLSYM_H */