Update to use stdint/stdbool.h

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

1 files changed, 569 insertions, 562 deletions

diff --git a/misc/pascal/insn16/libinsn/pdasm.c b/misc/pascal/insn16/libinsn/pdasm.c
index 9ee8f4b63..b6c1ecb31 100644
--- a/misc/pascal/insn16/libinsn/pdasm.c
+++ b/misc/pascal/insn16/libinsn/pdasm.c
@@ -1,562 +1,569 @@
-/**********************************************************************

- * pdasm.c

- * P-Code Disassembler

- *

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

- *

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

-

-#include <stdio.h>

-

-#include "keywords.h"

-#include "podefs.h"

-#include "pinsn16.h"

-#include "pfdefs.h"

-#include "pxdefs.h"

-#include "paslib.h"

-

-#include "pinsn.h"

-

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

-

-/* These are all the format codes that apply to opcodes the an arg16 */

-

-#define NOARG16     0

-#define HEX         1

-#define DECIMAL     2

-#define UDECIMAL    3

-#define LABEL_DEC   4

-#define xOP         5

-#define lbOP        6

-#define fpOP        7

-#define COMMENT     8

-

-/* The following table defines everything that is needed to disassemble

- * a P-Code.  NOTE:  The order of definition in this table must exactly

- * match the declaration sequence in pinsn.h. */

-

-static const char invOp[] = "Invalid Opcode";

-static const struct

-{

-  const char *opName;       /* Opcode mnemonics */

-  ubyte   format;           /* arg16 format */

-} opTable[256] =

-{

-

-/******************* OPCODES WITH NO ARGUMENTS ************************/

-/* Program control (No stack arguments) */

-

-/* 0x00 */ { "NOP  ", NOARG16 },

-

-/* Arithmetic & logical & and integer conversions (One stack argument) */

-

-/* 0x01 */ { "NEG  ", NOARG16 },

-/* 0x02 */ { "ABS  ", NOARG16 },

-/* 0x03 */ { "INC  ", NOARG16 },

-/* 0x04 */ { "DEC  ", NOARG16 },

-/* 0x05 */ { "NOT  ", NOARG16 },

-

-/* Arithmetic & logical (Two stack arguments) */

-

-/* 0x06 */ { "ADD  ", NOARG16 },

-/* 0x07 */ { "SUB  ", NOARG16 },

-/* 0x08 */ { "MUL  ", NOARG16 },

-/* 0x09 */ { "DIV  ", NOARG16 },

-/* 0x0a */ { "MOD  ", NOARG16 },

-/* 0x0b */ { "SLL  ", NOARG16 },

-/* 0x0c */ { "SRL  ", NOARG16 },

-/* 0x0d */ { "SRA  ", NOARG16 },

-/* 0x0e */ { "OR   ", NOARG16 },

-/* 0x0f */ { "AND  ", NOARG16 },

-

-/* Comparisons (One stack argument) */

-

-/* 0x10 */ { "EQUZ ", NOARG16 },

-/* 0x11 */ { "NEQZ ", NOARG16 },

-/* 0x12 */ { "LTZ  ", NOARG16 },

-/* 0x13 */ { "GTEZ ", NOARG16 },

-/* 0x14 */ { "GTZ  ", NOARG16 },

-/* 0x15 */ { "LTEZ ", NOARG16 },

-/* 0x16 */ { invOp,   NOARG16 },

-/* 0x17 */ { invOp,   NOARG16 },

-

-/* Comparisons (Two stack arguments) */

-

-/* 0x18 */ { "EQU  ", NOARG16 },

-/* 0x19 */ { "NEQ  ", NOARG16 },

-/* 0x1a */ { "LT   ", NOARG16 },

-/* 0x1b */ { "GTE  ", NOARG16 },

-/* 0x1c */ { "GT   ", NOARG16 },

-/* 0x1d */ { "LTE  ", NOARG16 },

-/* 0x1e */ { invOp,   NOARG16 },

-/* 0x1f */ { "BIT  ", NOARG16 },

-

-/* Load (One) or Store (Two stack argument) */

-

-/* 0x20 */ { "LDI ", NOARG16 },

-/* 0x21 */ { "LDIH", NOARG16 },

-/* 0x22 */ { "LDIB", NOARG16 },

-/* 0x23 */ { "LDIM", NOARG16 },

-/* 0x24 */ { "STI ", NOARG16 },

-/* 0x25 */ { "STIH", NOARG16 },

-/* 0x26 */ { "STIB", NOARG16 },

-/* 0x27 */ { "STIM", NOARG16 },

-

-/* Data stack operations */

-

-/* 0x29 */ { "DUP  ", NOARG16 },

-/* 0x29 */ { "DUPH ", NOARG16 },

-/* 0x2a */ { "PUSHS", NOARG16 },

-/* 0x2b */ { "POPS",  NOARG16 },

-/* 0x2c */ { invOp,   NOARG16 },

-/* 0x2d */ { invOp,   NOARG16 },

-/* 0x2e */ { invOp,   NOARG16 },

-/* 0x2f */ { "RET  ", NOARG16 },

-

-/* 0x30 */ { invOp,   NOARG16 },

-/* 0x31 */ { invOp,   NOARG16 },

-/* 0x32 */ { invOp,   NOARG16 },

-/* 0x33 */ { invOp,   NOARG16 },

-/* 0x34 */ { invOp,   NOARG16 },

-/* 0x35 */ { invOp,   NOARG16 },

-/* 0x36 */ { invOp,   NOARG16 },

-/* 0x37 */ { invOp,   NOARG16 },

-/* 0x38 */ { invOp,   NOARG16 },

-

-/* System Functions (No stack arguments) */

-

-/* 0x39 */ { invOp,   NOARG16 },

-/* 0x3a */ { invOp,   NOARG16 },

-/* 0x3b */ { invOp,   NOARG16 },

-/* 0x3c */ { invOp,   NOARG16 },

-/* 0x3d */ { invOp,   NOARG16 },

-/* 0x3e */ { invOp,   NOARG16 },

-/* 0x3f */ { "EXIT ", NOARG16 },

-

-/************** OPCODES WITH SINGLE BYTE ARGUMENT (arg8) ***************/

-

-/* 0x40 */ { invOp,   NOARG16 },

-/* 0x41 */ { invOp,   NOARG16 },

-/* 0x42 */ { invOp,   NOARG16 },

-/* 0x43 */ { invOp,   NOARG16 },

-/* 0x44 */ { invOp,   NOARG16 },

-/* 0x45 */ { invOp,   NOARG16 },

-/* 0x46 */ { invOp,   NOARG16 },

-/* 0x47 */ { invOp,   NOARG16 },

-/* 0x48 */ { invOp,   NOARG16 },

-/* 0x49 */ { invOp,   NOARG16 },

-/* 0x4a */ { invOp,   NOARG16 },

-/* 0x4b */ { invOp,   NOARG16 },

-/* 0x4c */ { invOp,   NOARG16 },

-/* 0x4d */ { invOp,   NOARG16 },

-/* 0x4e */ { invOp,   NOARG16 },

-/* 0x4f */ { invOp,   NOARG16 },

-

-/* 0x50 */ { invOp,   NOARG16 },

-/* 0x51 */ { invOp,   NOARG16 },

-/* 0x52 */ { invOp,   NOARG16 },

-/* 0x53 */ { invOp,   NOARG16 },

-/* 0x54 */ { invOp,   NOARG16 },

-/* 0x55 */ { invOp,   NOARG16 },

-/* 0x56 */ { invOp,   NOARG16 },

-/* 0x57 */ { invOp,   NOARG16 },

-/* 0x58 */ { invOp,   NOARG16 },

-/* 0x59 */ { invOp,   NOARG16 },

-/* 0x5a */ { invOp,   NOARG16 },

-/* 0x5b */ { invOp,   NOARG16 },

-/* 0x5c */ { invOp,   NOARG16 },

-/* 0x5d */ { invOp,   NOARG16 },

-/* 0x5e */ { invOp,   NOARG16 },

-/* 0x5f */ { invOp,   NOARG16 },

-

-/* Data stack:  arg8 = 8 bit unsigned data (no stack arguments) */

-

-/* 0x60 */ { invOp,   NOARG16 },

-/* 0x61 */ { invOp,   NOARG16 },

-/* 0x62 */ { invOp,   NOARG16 },

-/* 0x63 */ { invOp,   NOARG16 },

-/* 0x64 */ { invOp,   NOARG16 },

-/* 0x65 */ { invOp,   NOARG16 },

-/* 0x66 */ { invOp,   NOARG16 },

-/* 0x67 */ { invOp,   NOARG16 },

-/* 0x68 */ { invOp,   NOARG16 },

-/* 0x69 */ { invOp,   NOARG16 },

-/* 0x6a */ { invOp,   NOARG16 },

-/* 0x6b */ { invOp,   NOARG16 },

-/* 0x6c */ { invOp,   NOARG16 },

-/* 0x6d */ { invOp,   NOARG16 },

-/* 0x6e */ { invOp,   NOARG16 },

-/* 0x6f */ { invOp,   NOARG16 },

-

-/* Floating Point Operations:  arg8 = FP op-code */

-

-/* 0x70 */ { "FLOAT", fpOP    },

-/* 0x71 */ { invOp,   NOARG16 },

-/* 0x72 */ { invOp,   NOARG16 },

-/* 0x73 */ { invOp,   NOARG16 },

-/* 0x74 */ { "PUSHB", NOARG16 },

-/* 0x75 */ { invOp,   NOARG16 },

-/* 0x76 */ { invOp,   NOARG16 },

-/* 0x77 */ { invOp,   NOARG16 },

-

-/* 0x78 */ { invOp,   NOARG16 },

-/* 0x79 */ { invOp,   NOARG16 },

-/* 0x7a */ { invOp,   NOARG16 },

-/* 0x7b */ { invOp,   NOARG16 },

-/* 0x7c */ { invOp,   NOARG16 },

-/* 0x7d */ { invOp,   NOARG16 },

-/* 0x7e */ { invOp,   NOARG16 },

-/* 0x7f */ { invOp,   NOARG16 },

-

-/************ OPCODES WITH SINGLE 16-BIT ARGUMENT (arg16) ************/

-

-/* 0x80 */ { invOp,   NOARG16 },

-/* 0x81 */ { invOp,   NOARG16 },

-/* 0x82 */ { invOp,   NOARG16 },

-/* 0x83 */ { invOp,   NOARG16 },

-/* 0x84 */ { invOp,   NOARG16 },

-/* 0x85 */ { invOp,   NOARG16 },

-/* 0x86 */ { invOp,   NOARG16 },

-/* 0x87 */ { invOp,   NOARG16 },

-/* 0x88 */ { invOp,   NOARG16 },

-/* 0x89 */ { invOp,   NOARG16 },

-/* 0x8a */ { invOp,   NOARG16 },

-/* 0x8b */ { invOp,   NOARG16 },

-/* 0x8c */ { invOp,   NOARG16 },

-/* 0x8d */ { invOp,   NOARG16 },

-/* 0x8e */ { invOp,   NOARG16 },

-/* 0x8f */ { invOp,   NOARG16 },

-

-/* Program control:  arg16 = unsigned label (One stack argument) */

-

-/* 0x90 */ { "JEQUZ", HEX },

-/* 0x91 */ { "JNEQZ", HEX },

-/* 0x92 */ { "JLTZ ", HEX },

-/* 0x93 */ { "JGTEZ", HEX },

-/* 0x94 */ { "JGTZ ", HEX },

-/* 0x95 */ { "JLTEZ", HEX },

-

-/* Program control:  arg16 = unsigned label (no stack arguments) */

-

-/* 0x96 */ { "JMP  ", HEX },

-/* 0x97 */ { invOp,   NOARG16 },

-

-/* Program control:  arg16 = unsigned label (One stack argument) */

-

-/* 0x98 */ { "JEQU ", HEX },

-/* 0x99 */ { "JNEQ ", HEX },

-/* 0x9a */ { "JLT  ", HEX },

-/* 0x9b */ { "JGTE ", HEX },

-/* 0x9c */ { "JGT  ", HEX },

-/* 0x9d */ { "JLTE ", HEX },

-/* 0x9e */ { invOp,   NOARG16 },

-/* 0x9f */ { invOp,   NOARG16 },

-

-/* Data stack:  arg16 = 16 bit signed data (no stack arguments) */

-

-/* Load:  arg16 = unsigned base offset (no stack arguments) */

-

-/* 0xa0 */ { "LD   ", UDECIMAL },

-/* 0xa1 */ { "LDH  ", UDECIMAL },

-/* 0xa2 */ { "LDB  ", UDECIMAL },

-/* 0xa3 */ { "LDM  ", UDECIMAL },

-

-/* Store: arg16 = unsigned base offset (One stack arguments) */

-

-/* 0xa4 */ { "ST   ", UDECIMAL },

-/* 0xa5 */ { "STH  ", UDECIMAL },

-/* 0xa6 */ { "STB  ", UDECIMAL },

-/* 0xa7 */ { "STM  ", UDECIMAL },

-

-/* Load Indexed: arg16 = unsigned base offset (One stack arguments) */

-

-/* 0xa8 */ { "LDX  ", UDECIMAL },

-/* 0xa9 */ { "LDXH ", UDECIMAL },

-/* 0xaa */ { "LDXB ", UDECIMAL },

-/* 0xab */ { "LDXM ", UDECIMAL },

-

-/* Store Indexed: arg16 = unsigned base offset (Two stack arguments) */

-

-/* 0xac */ { "STX  ", UDECIMAL },

-/* 0xad */ { "STXH ", UDECIMAL },

-/* 0xae */ { "STXB ", UDECIMAL },

-/* 0xaf */ { "STXM ", UDECIMAL },

-

-/* 0xb0 */ { "LA   ", UDECIMAL },

-/* 0xb1 */ { "LAC  ", HEX,    },

-/* 0xb2 */ { invOp,   NOARG16 },

-/* 0xb3 */ { invOp,   NOARG16 },

-/* 0xb4 */ { "PUSH ", DECIMAL },

-/* 0xb5 */ { "INDS ", DECIMAL },

-/* 0xb6 */ { invOp,   NOARG16 },

-/* 0xb7 */ { invOp,   NOARG16 },

-/* 0xb8 */ { "LAX  ", UDECIMAL },

-

-/* System operations: arg16 = 16-bit library function identifer */

-

-/* 0xb9 */ { "LIB  ", lbOP,   },

-/* 0xba */ { invOp,   NOARG16 },

-/* 0xbb */ { invOp,   NOARG16 },

-/* 0xbc */ { invOp,   NOARG16 },

-/* 0xbd */ { invOp,   NOARG16 },

-/* 0xbe */ { invOp,   NOARG16 },

-

-/* Program control:  arg16 = unsigned label (no stack arguments) */

-

-/* 0xbf */ { "LABEL", LABEL_DEC },

-

-/**** OPCODES WITH BYTE ARGUMENT (arg8) AND 16-BIT ARGUMENT (arg16) ****/

-

-/* 0xc0 */ { invOp,   NOARG16 },

-/* 0xc1 */ { invOp,   NOARG16 },

-/* 0xc2 */ { invOp,   NOARG16 },

-/* 0xc3 */ { invOp,   NOARG16 },

-/* 0xc4 */ { invOp,   NOARG16 },

-/* 0xc5 */ { invOp,   NOARG16 },

-/* 0xc6 */ { invOp,   NOARG16 },

-/* 0xc7 */ { invOp,   NOARG16 },

-

-/* Program Control:  arg8 = level; arg16 = unsigned label (No stack

- * arguments */

-

-/* 0xc8 */ { "PCAL ", HEX },

-/* 0xc9 */ { invOp,   NOARG16 },

-/* 0xca */ { invOp,   NOARG16 },

-/* 0xcb */ { invOp,   NOARG16 },

-/* 0xcc */ { invOp,   NOARG16 },

-/* 0xcd */ { invOp,   NOARG16 },

-/* 0xce */ { invOp,   NOARG16 },

-/* 0xcf */ { invOp,   NOARG16 },

-

-/* 0xd0 */ { invOp,   NOARG16 },

-/* 0xd1 */ { invOp,   NOARG16 },

-/* 0xd2 */ { invOp,   NOARG16 },

-/* 0xd3 */ { invOp,   NOARG16 },

-/* 0xd4 */ { invOp,   NOARG16 },

-/* 0xd5 */ { invOp,   NOARG16 },

-/* 0xd6 */ { invOp,   NOARG16 },

-/* 0xd7 */ { invOp,   NOARG16 },

-/* 0xd8 */ { invOp,   NOARG16 },

-/* 0xd9 */ { invOp,   NOARG16 },

-/* 0xda */ { invOp,   NOARG16 },

-/* 0xdb */ { invOp,   NOARG16 },

-/* 0xdc */ { invOp,   NOARG16 },

-/* 0xdd */ { invOp,   NOARG16 },

-/* 0xde */ { invOp,   NOARG16 },

-/* 0xdf */ { invOp,   NOARG16 },

-

-/* Load:  arg8 = level; arg16 = signed frame offset (no stack arguments) */

-

-/* 0xe0 */ { "LDS  ", DECIMAL },

-/* 0xe1 */ { "LDSH ", DECIMAL },

-/* 0xe2 */ { "LDSB ", DECIMAL },

-/* 0xe3 */ { "LDSM ", DECIMAL },

-

-/* Store: arg8 = level; arg16 = signed frame offset (One stack arguments) */

-

-/* 0xe4 */ { "STS  ", DECIMAL },

-/* 0xe5 */ { "STSH ", DECIMAL },

-/* 0xe6 */ { "STSB ", DECIMAL },

-/* 0xe7 */ { "STSM ", DECIMAL },

-

-/* Load Indexed: arg8 = level; arg16 = signed frame offset (One stack arguments) */

-

-/* 0xe8 */ { "LDSX ", DECIMAL },

-/* 0xe9 */ { "LDSXH", DECIMAL },

-/* 0xea */ { "LDSXB", DECIMAL },

-/* 0xeb */ { "LDSXM", DECIMAL },

-

-/* Store Indexed: arg8 = level; arg16 = signed frame offset (Two stack arguments) */

-

-/* 0xec */ { "STSX ", DECIMAL },

-/* 0xed */ { "STSXH", DECIMAL },

-/* 0xee */ { "STSXB", DECIMAL },

-/* 0xef */ { "STSXM", DECIMAL },

-

-/* Load Address:  arg8 = level; arg16 = signed frame offset (no stack arguments) */

-

-/* 0xf0 */ { "LAS  ", DECIMAL },

-/* 0xf1 */ { invOp,   NOARG16 },

-/* 0xf2 */ { invOp,   NOARG16 },

-/* 0xf3 */ { invOp,   NOARG16 },

-/* 0xf4 */ { invOp,   NOARG16 },

-/* 0xf5 */ { invOp,   NOARG16 },

-/* 0xf6 */ { invOp,   NOARG16 },

-/* 0xf7 */ { invOp,   NOARG16 },

-/* 0xf8 */ { "LASX ", DECIMAL },

-

-/* System Functions:  (No stack arguments)

- * For SYSIO:        arg8 = file number; arg16 = sub-function code

- */

-

-/* 0xf9 */ { "SYSIO", xOP,    },

-/* 0xfa */ { invOp,   NOARG16 },

-/* 0xfb */ { invOp,   NOARG16 },

-/* 0xfc */ { invOp,   NOARG16 },

-/* 0xfd */ { invOp,   NOARG16 },

-/* 0xfe */ { invOp,   NOARG16 },

-

-/* Psuedo-operations:

- * For LINE:         arg8 = file number; arg16 = line number

- */

-

-/* 0xff */ { "LINE ", COMMENT },

-};

-

-static const char invXOp[] = "Invalid SYSIO";

-static const char *xName[MAX_XOP] = { /* SYSIO opcode mnemonics */

-/* 0x00 */ invXOp,      "EOF",       "EOLN",       "RESET",

-/* 0x04 */ "REWRITE",   invXOp,      invXOp,       invXOp,

-/* 0x08 */ invXOp,      invXOp,      invXOp,       invXOp,

-/* 0x0c */ invXOp,      invXOp,      invXOp,       invXOp,

-/* 0x10 */ "READLN",    "READPG",    "READBIN",    "READINT",

-/* 0x14 */ "READCHR",   "READSTR",   "READRL",     invXOp,

-/* 0x18 */ invXOp,      invXOp,      invXOp,       invXOp,

-/* 0x1c */ invXOp,      invXOp,      invXOp,       invXOp,

-/* 0x20 */ "WRITELN",   "WRITEPG",   "WRITEBIN",   "WRITEINT",

-/* 0x24 */ "WRITECHR",  "WRITESTR",  "WRITERL" };

-

-static const char invLbOp[] = "Invalid runtime code";

-static const char *lbName[MAX_LBOP] = { /* LIB opcode mnemonics */

-/* 0x00 */ "GETENV",     "STR2STR",   "CSTR2STR",  "STR2RSTR",

-/* 0x04 */ "CSTR2RSTR",  "VAL",       "MKSTK",     "MKSTKSTR",

-/* 0x08 */ "MKSTKC",     "STRCAT",    "STRCATC",   "STRCMP" };

-

-static const char invFpOp[] = "Invalid FP Operation";

-static const char *fpName[MAX_FOP] = {

-/* 0x00 */ invFpOp,    "FLOAT",    "TRUNC",    "ROUND",

-/* 0x04 */ "ADD",      "SUB",      "MUL",      "DIV",

-/* 0x08 */ "MOD",      invFpOp,    "EQU",      "NEQ",

-/* 0x0c */ "LT",       "GTE",      "GT",       "LTE",

-/* 0x10 */ "NEG",      "ABS",      "SQR",      "SQRT",

-/* 0x14 */ "SIN",      "COS",      "ATAN",     "LN",

-/* 0x18 */ "EXP" };

-

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

-

-void insn_DisassemblePCode(FILE* lfile, OPTYPE *pop)

-{

-  /* Indent, comment or label */

-

-  switch (opTable[pop->op].format)

-    {

-    case LABEL_DEC :

-      fprintf(lfile, "L%04x:  ", pop->arg2);

-      break;

-    case COMMENT   :

-      fprintf(lfile, "; ");

-      break;

-    default   :

-      fprintf(lfile, "        ");

-    } /* end switch */

-

-  /* Special Case Comment line format */

-

-  if (opTable[pop->op].format == COMMENT)

-    {

-      fprintf(lfile, "%s ", opTable[pop->op].opName);

-      if (pop->op & o8)

-	{

-	  fprintf(lfile, "%d", pop->arg1);

-	  if (pop->op & o16)

-	    fprintf(lfile, ":%d", pop->arg2);

-	} /* end if */

-      else if (pop->op & o16)

-	fprintf(lfile, "%d", pop->arg2);

-    } /* end if */

-

-  /* Print normal opCode mnemonic */

-

-  else

-    {

-      fprintf(lfile, "%s ", opTable[pop->op].opName);

-

-      /* Print pop->arg1 (if present) */

-

-      if (pop->op & o8) fprintf(lfile, "%d", pop->arg1);

-

-      /* Print ar16 (if present) */

-

-      if (pop->op & o16)

-	{

-	  switch (opTable[pop->op].format)

-	    {

-	    case HEX       :

-	      if (pop->op & o8) fprintf(lfile, ", ");

-	      fprintf(lfile, "0x%04x", pop->arg2);

-	      break;

-

-	    case COMMENT   :

-	    case DECIMAL   :

-	      if (pop->op & o8) fprintf(lfile, ", ");

-	      fprintf(lfile, "%ld", signExtend16(pop->arg2));

-	      break;

-

-	    case UDECIMAL   :

-	      if (pop->op & o8) fprintf(lfile, ", ");

-	      fprintf(lfile, "%u", pop->arg2);

-	      break;

-

-	    case fpOP       :

-	      if ((pop->arg1 & fpMASK) < MAX_FOP)

-		fprintf(lfile, " %s", fpName[(pop->arg1 & 0x3f)]);

-	      else

-		fprintf(lfile, " %s", invFpOp);

-	      break;

-

-	    case xOP       :

-	      if (pop->arg2 < MAX_XOP)

-		fprintf(lfile, ", %s", xName[pop->arg2]);

-	      else

-		fprintf(lfile, ", %s", invXOp);

-	      break;

-

-	    case lbOP :

-	      if (pop->arg2 < MAX_LBOP)

-		fprintf(lfile, "%s", lbName[pop->arg2]);

-	      else

-		fprintf(lfile, "%s", invLbOp);

-	      break;

-

-	    case LABEL_DEC :

-	    default        :

-	      break;

-	    } /* end switch */

-	} /* end if */

-    } /* end else */

-

-  /* Don't forget the newline! */

-

-  fputc('\n', lfile);

-

-} /* end dissassemblePcode */

-

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

+/**********************************************************************
+ * pdasm.c
+ * P-Code Disassembler
+ *
+ *   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 <stdio.h>
+
+#include "keywords.h"
+#include "podefs.h"
+#include "pinsn16.h"
+#include "pfdefs.h"
+#include "pxdefs.h"
+#include "paslib.h"
+
+#include "pinsn.h"
+
+/***********************************************************************
+ * Pre-processor Definitions
+ ***********************************************************************/
+
+/* These are all the format codes that apply to opcodes the an arg16 */
+
+#define NOARG16     0
+#define HEX         1
+#define DECIMAL     2
+#define UDECIMAL    3
+#define LABEL_DEC   4
+#define xOP         5
+#define lbOP        6
+#define fpOP        7
+#define COMMENT     8
+
+/* The following table defines everything that is needed to disassemble
+ * a P-Code.  NOTE:  The order of definition in this table must exactly
+ * match the declaration sequence in pinsn.h. */
+
+static const char invOp[] = "Invalid Opcode";
+static const struct
+{
+  const char *opName;       /* Opcode mnemonics */
+  uint8_t format;           /* arg16 format */
+} opTable[256] =
+{
+
+/******************* OPCODES WITH NO ARGUMENTS ************************/
+/* Program control (No stack arguments) */
+
+/* 0x00 */ { "NOP  ", NOARG16 },
+
+/* Arithmetic & logical & and integer conversions (One stack argument) */
+
+/* 0x01 */ { "NEG  ", NOARG16 },
+/* 0x02 */ { "ABS  ", NOARG16 },
+/* 0x03 */ { "INC  ", NOARG16 },
+/* 0x04 */ { "DEC  ", NOARG16 },
+/* 0x05 */ { "NOT  ", NOARG16 },
+
+/* Arithmetic & logical (Two stack arguments) */
+
+/* 0x06 */ { "ADD  ", NOARG16 },
+/* 0x07 */ { "SUB  ", NOARG16 },
+/* 0x08 */ { "MUL  ", NOARG16 },
+/* 0x09 */ { "DIV  ", NOARG16 },
+/* 0x0a */ { "MOD  ", NOARG16 },
+/* 0x0b */ { "SLL  ", NOARG16 },
+/* 0x0c */ { "SRL  ", NOARG16 },
+/* 0x0d */ { "SRA  ", NOARG16 },
+/* 0x0e */ { "OR   ", NOARG16 },
+/* 0x0f */ { "AND  ", NOARG16 },
+
+/* Comparisons (One stack argument) */
+
+/* 0x10 */ { "EQUZ ", NOARG16 },
+/* 0x11 */ { "NEQZ ", NOARG16 },
+/* 0x12 */ { "LTZ  ", NOARG16 },
+/* 0x13 */ { "GTEZ ", NOARG16 },
+/* 0x14 */ { "GTZ  ", NOARG16 },
+/* 0x15 */ { "LTEZ ", NOARG16 },
+/* 0x16 */ { invOp,   NOARG16 },
+/* 0x17 */ { invOp,   NOARG16 },
+
+/* Comparisons (Two stack arguments) */
+
+/* 0x18 */ { "EQU  ", NOARG16 },
+/* 0x19 */ { "NEQ  ", NOARG16 },
+/* 0x1a */ { "LT   ", NOARG16 },
+/* 0x1b */ { "GTE  ", NOARG16 },
+/* 0x1c */ { "GT   ", NOARG16 },
+/* 0x1d */ { "LTE  ", NOARG16 },
+/* 0x1e */ { invOp,   NOARG16 },
+/* 0x1f */ { "BIT  ", NOARG16 },
+
+/* Load (One) or Store (Two stack argument) */
+
+/* 0x20 */ { "LDI ", NOARG16 },
+/* 0x21 */ { "LDIH", NOARG16 },
+/* 0x22 */ { "LDIB", NOARG16 },
+/* 0x23 */ { "LDIM", NOARG16 },
+/* 0x24 */ { "STI ", NOARG16 },
+/* 0x25 */ { "STIH", NOARG16 },
+/* 0x26 */ { "STIB", NOARG16 },
+/* 0x27 */ { "STIM", NOARG16 },
+
+/* Data stack operations */
+
+/* 0x29 */ { "DUP  ", NOARG16 },
+/* 0x29 */ { "DUPH ", NOARG16 },
+/* 0x2a */ { "PUSHS", NOARG16 },
+/* 0x2b */ { "POPS",  NOARG16 },
+/* 0x2c */ { invOp,   NOARG16 },
+/* 0x2d */ { invOp,   NOARG16 },
+/* 0x2e */ { invOp,   NOARG16 },
+/* 0x2f */ { "RET  ", NOARG16 },
+
+/* 0x30 */ { invOp,   NOARG16 },
+/* 0x31 */ { invOp,   NOARG16 },
+/* 0x32 */ { invOp,   NOARG16 },
+/* 0x33 */ { invOp,   NOARG16 },
+/* 0x34 */ { invOp,   NOARG16 },
+/* 0x35 */ { invOp,   NOARG16 },
+/* 0x36 */ { invOp,   NOARG16 },
+/* 0x37 */ { invOp,   NOARG16 },
+/* 0x38 */ { invOp,   NOARG16 },
+
+/* System Functions (No stack arguments) */
+
+/* 0x39 */ { invOp,   NOARG16 },
+/* 0x3a */ { invOp,   NOARG16 },
+/* 0x3b */ { invOp,   NOARG16 },
+/* 0x3c */ { invOp,   NOARG16 },
+/* 0x3d */ { invOp,   NOARG16 },
+/* 0x3e */ { invOp,   NOARG16 },
+/* 0x3f */ { "EXIT ", NOARG16 },
+
+/************** OPCODES WITH SINGLE BYTE ARGUMENT (arg8) ***************/
+
+/* 0x40 */ { invOp,   NOARG16 },
+/* 0x41 */ { invOp,   NOARG16 },
+/* 0x42 */ { invOp,   NOARG16 },
+/* 0x43 */ { invOp,   NOARG16 },
+/* 0x44 */ { invOp,   NOARG16 },
+/* 0x45 */ { invOp,   NOARG16 },
+/* 0x46 */ { invOp,   NOARG16 },
+/* 0x47 */ { invOp,   NOARG16 },
+/* 0x48 */ { invOp,   NOARG16 },
+/* 0x49 */ { invOp,   NOARG16 },
+/* 0x4a */ { invOp,   NOARG16 },
+/* 0x4b */ { invOp,   NOARG16 },
+/* 0x4c */ { invOp,   NOARG16 },
+/* 0x4d */ { invOp,   NOARG16 },
+/* 0x4e */ { invOp,   NOARG16 },
+/* 0x4f */ { invOp,   NOARG16 },
+
+/* 0x50 */ { invOp,   NOARG16 },
+/* 0x51 */ { invOp,   NOARG16 },
+/* 0x52 */ { invOp,   NOARG16 },
+/* 0x53 */ { invOp,   NOARG16 },
+/* 0x54 */ { invOp,   NOARG16 },
+/* 0x55 */ { invOp,   NOARG16 },
+/* 0x56 */ { invOp,   NOARG16 },
+/* 0x57 */ { invOp,   NOARG16 },
+/* 0x58 */ { invOp,   NOARG16 },
+/* 0x59 */ { invOp,   NOARG16 },
+/* 0x5a */ { invOp,   NOARG16 },
+/* 0x5b */ { invOp,   NOARG16 },
+/* 0x5c */ { invOp,   NOARG16 },
+/* 0x5d */ { invOp,   NOARG16 },
+/* 0x5e */ { invOp,   NOARG16 },
+/* 0x5f */ { invOp,   NOARG16 },
+
+/* Data stack:  arg8 = 8 bit unsigned data (no stack arguments) */
+
+/* 0x60 */ { invOp,   NOARG16 },
+/* 0x61 */ { invOp,   NOARG16 },
+/* 0x62 */ { invOp,   NOARG16 },
+/* 0x63 */ { invOp,   NOARG16 },
+/* 0x64 */ { invOp,   NOARG16 },
+/* 0x65 */ { invOp,   NOARG16 },
+/* 0x66 */ { invOp,   NOARG16 },
+/* 0x67 */ { invOp,   NOARG16 },
+/* 0x68 */ { invOp,   NOARG16 },
+/* 0x69 */ { invOp,   NOARG16 },
+/* 0x6a */ { invOp,   NOARG16 },
+/* 0x6b */ { invOp,   NOARG16 },
+/* 0x6c */ { invOp,   NOARG16 },
+/* 0x6d */ { invOp,   NOARG16 },
+/* 0x6e */ { invOp,   NOARG16 },
+/* 0x6f */ { invOp,   NOARG16 },
+
+/* Floating Point Operations:  arg8 = FP op-code */
+
+/* 0x70 */ { "FLOAT", fpOP    },
+/* 0x71 */ { invOp,   NOARG16 },
+/* 0x72 */ { invOp,   NOARG16 },
+/* 0x73 */ { invOp,   NOARG16 },
+/* 0x74 */ { "PUSHB", NOARG16 },
+/* 0x75 */ { invOp,   NOARG16 },
+/* 0x76 */ { invOp,   NOARG16 },
+/* 0x77 */ { invOp,   NOARG16 },
+
+/* 0x78 */ { invOp,   NOARG16 },
+/* 0x79 */ { invOp,   NOARG16 },
+/* 0x7a */ { invOp,   NOARG16 },
+/* 0x7b */ { invOp,   NOARG16 },
+/* 0x7c */ { invOp,   NOARG16 },
+/* 0x7d */ { invOp,   NOARG16 },
+/* 0x7e */ { invOp,   NOARG16 },
+/* 0x7f */ { invOp,   NOARG16 },
+
+/************ OPCODES WITH SINGLE 16-BIT ARGUMENT (arg16) ************/
+
+/* 0x80 */ { invOp,   NOARG16 },
+/* 0x81 */ { invOp,   NOARG16 },
+/* 0x82 */ { invOp,   NOARG16 },
+/* 0x83 */ { invOp,   NOARG16 },
+/* 0x84 */ { invOp,   NOARG16 },
+/* 0x85 */ { invOp,   NOARG16 },
+/* 0x86 */ { invOp,   NOARG16 },
+/* 0x87 */ { invOp,   NOARG16 },
+/* 0x88 */ { invOp,   NOARG16 },
+/* 0x89 */ { invOp,   NOARG16 },
+/* 0x8a */ { invOp,   NOARG16 },
+/* 0x8b */ { invOp,   NOARG16 },
+/* 0x8c */ { invOp,   NOARG16 },
+/* 0x8d */ { invOp,   NOARG16 },
+/* 0x8e */ { invOp,   NOARG16 },
+/* 0x8f */ { invOp,   NOARG16 },
+
+/* Program control:  arg16 = unsigned label (One stack argument) */
+
+/* 0x90 */ { "JEQUZ", HEX },
+/* 0x91 */ { "JNEQZ", HEX },
+/* 0x92 */ { "JLTZ ", HEX },
+/* 0x93 */ { "JGTEZ", HEX },
+/* 0x94 */ { "JGTZ ", HEX },
+/* 0x95 */ { "JLTEZ", HEX },
+
+/* Program control:  arg16 = unsigned label (no stack arguments) */
+
+/* 0x96 */ { "JMP  ", HEX },
+/* 0x97 */ { invOp,   NOARG16 },
+
+/* Program control:  arg16 = unsigned label (One stack argument) */
+
+/* 0x98 */ { "JEQU ", HEX },
+/* 0x99 */ { "JNEQ ", HEX },
+/* 0x9a */ { "JLT  ", HEX },
+/* 0x9b */ { "JGTE ", HEX },
+/* 0x9c */ { "JGT  ", HEX },
+/* 0x9d */ { "JLTE ", HEX },
+/* 0x9e */ { invOp,   NOARG16 },
+/* 0x9f */ { invOp,   NOARG16 },
+
+/* Data stack:  arg16 = 16 bit signed data (no stack arguments) */
+
+/* Load:  arg16 = unsigned base offset (no stack arguments) */
+
+/* 0xa0 */ { "LD   ", UDECIMAL },
+/* 0xa1 */ { "LDH  ", UDECIMAL },
+/* 0xa2 */ { "LDB  ", UDECIMAL },
+/* 0xa3 */ { "LDM  ", UDECIMAL },
+
+/* Store: arg16 = unsigned base offset (One stack arguments) */
+
+/* 0xa4 */ { "ST   ", UDECIMAL },
+/* 0xa5 */ { "STH  ", UDECIMAL },
+/* 0xa6 */ { "STB  ", UDECIMAL },
+/* 0xa7 */ { "STM  ", UDECIMAL },
+
+/* Load Indexed: arg16 = unsigned base offset (One stack arguments) */
+
+/* 0xa8 */ { "LDX  ", UDECIMAL },
+/* 0xa9 */ { "LDXH ", UDECIMAL },
+/* 0xaa */ { "LDXB ", UDECIMAL },
+/* 0xab */ { "LDXM ", UDECIMAL },
+
+/* Store Indexed: arg16 = unsigned base offset (Two stack arguments) */
+
+/* 0xac */ { "STX  ", UDECIMAL },
+/* 0xad */ { "STXH ", UDECIMAL },
+/* 0xae */ { "STXB ", UDECIMAL },
+/* 0xaf */ { "STXM ", UDECIMAL },
+
+/* 0xb0 */ { "LA   ", UDECIMAL },
+/* 0xb1 */ { "LAC  ", HEX,    },
+/* 0xb2 */ { invOp,   NOARG16 },
+/* 0xb3 */ { invOp,   NOARG16 },
+/* 0xb4 */ { "PUSH ", DECIMAL },
+/* 0xb5 */ { "INDS ", DECIMAL },
+/* 0xb6 */ { invOp,   NOARG16 },
+/* 0xb7 */ { invOp,   NOARG16 },
+/* 0xb8 */ { "LAX  ", UDECIMAL },
+
+/* System operations: arg16 = 16-bit library function identifer */
+
+/* 0xb9 */ { "LIB  ", lbOP,   },
+/* 0xba */ { invOp,   NOARG16 },
+/* 0xbb */ { invOp,   NOARG16 },
+/* 0xbc */ { invOp,   NOARG16 },
+/* 0xbd */ { invOp,   NOARG16 },
+/* 0xbe */ { invOp,   NOARG16 },
+
+/* Program control:  arg16 = unsigned label (no stack arguments) */
+
+/* 0xbf */ { "LABEL", LABEL_DEC },
+
+/**** OPCODES WITH BYTE ARGUMENT (arg8) AND 16-BIT ARGUMENT (arg16) ****/
+
+/* 0xc0 */ { invOp,   NOARG16 },
+/* 0xc1 */ { invOp,   NOARG16 },
+/* 0xc2 */ { invOp,   NOARG16 },
+/* 0xc3 */ { invOp,   NOARG16 },
+/* 0xc4 */ { invOp,   NOARG16 },
+/* 0xc5 */ { invOp,   NOARG16 },
+/* 0xc6 */ { invOp,   NOARG16 },
+/* 0xc7 */ { invOp,   NOARG16 },
+
+/* Program Control:  arg8 = level; arg16 = unsigned label (No stack
+ * arguments */
+
+/* 0xc8 */ { "PCAL ", HEX },
+/* 0xc9 */ { invOp,   NOARG16 },
+/* 0xca */ { invOp,   NOARG16 },
+/* 0xcb */ { invOp,   NOARG16 },
+/* 0xcc */ { invOp,   NOARG16 },
+/* 0xcd */ { invOp,   NOARG16 },
+/* 0xce */ { invOp,   NOARG16 },
+/* 0xcf */ { invOp,   NOARG16 },
+
+/* 0xd0 */ { invOp,   NOARG16 },
+/* 0xd1 */ { invOp,   NOARG16 },
+/* 0xd2 */ { invOp,   NOARG16 },
+/* 0xd3 */ { invOp,   NOARG16 },
+/* 0xd4 */ { invOp,   NOARG16 },
+/* 0xd5 */ { invOp,   NOARG16 },
+/* 0xd6 */ { invOp,   NOARG16 },
+/* 0xd7 */ { invOp,   NOARG16 },
+/* 0xd8 */ { invOp,   NOARG16 },
+/* 0xd9 */ { invOp,   NOARG16 },
+/* 0xda */ { invOp,   NOARG16 },
+/* 0xdb */ { invOp,   NOARG16 },
+/* 0xdc */ { invOp,   NOARG16 },
+/* 0xdd */ { invOp,   NOARG16 },
+/* 0xde */ { invOp,   NOARG16 },
+/* 0xdf */ { invOp,   NOARG16 },
+
+/* Load:  arg8 = level; arg16 = signed frame offset (no stack arguments) */
+
+/* 0xe0 */ { "LDS  ", DECIMAL },
+/* 0xe1 */ { "LDSH ", DECIMAL },
+/* 0xe2 */ { "LDSB ", DECIMAL },
+/* 0xe3 */ { "LDSM ", DECIMAL },
+
+/* Store: arg8 = level; arg16 = signed frame offset (One stack arguments) */
+
+/* 0xe4 */ { "STS  ", DECIMAL },
+/* 0xe5 */ { "STSH ", DECIMAL },
+/* 0xe6 */ { "STSB ", DECIMAL },
+/* 0xe7 */ { "STSM ", DECIMAL },
+
+/* Load Indexed: arg8 = level; arg16 = signed frame offset (One stack arguments) */
+
+/* 0xe8 */ { "LDSX ", DECIMAL },
+/* 0xe9 */ { "LDSXH", DECIMAL },
+/* 0xea */ { "LDSXB", DECIMAL },
+/* 0xeb */ { "LDSXM", DECIMAL },
+
+/* Store Indexed: arg8 = level; arg16 = signed frame offset (Two stack arguments) */
+
+/* 0xec */ { "STSX ", DECIMAL },
+/* 0xed */ { "STSXH", DECIMAL },
+/* 0xee */ { "STSXB", DECIMAL },
+/* 0xef */ { "STSXM", DECIMAL },
+
+/* Load Address:  arg8 = level; arg16 = signed frame offset (no stack arguments) */
+
+/* 0xf0 */ { "LAS  ", DECIMAL },
+/* 0xf1 */ { invOp,   NOARG16 },
+/* 0xf2 */ { invOp,   NOARG16 },
+/* 0xf3 */ { invOp,   NOARG16 },
+/* 0xf4 */ { invOp,   NOARG16 },
+/* 0xf5 */ { invOp,   NOARG16 },
+/* 0xf6 */ { invOp,   NOARG16 },
+/* 0xf7 */ { invOp,   NOARG16 },
+/* 0xf8 */ { "LASX ", DECIMAL },
+
+/* System Functions:  (No stack arguments)
+ * For SYSIO:        arg8 = file number; arg16 = sub-function code
+ */
+
+/* 0xf9 */ { "SYSIO", xOP,    },
+/* 0xfa */ { invOp,   NOARG16 },
+/* 0xfb */ { invOp,   NOARG16 },
+/* 0xfc */ { invOp,   NOARG16 },
+/* 0xfd */ { invOp,   NOARG16 },
+/* 0xfe */ { invOp,   NOARG16 },
+
+/* Psuedo-operations:
+ * For LINE:         arg8 = file number; arg16 = line number
+ */
+
+/* 0xff */ { "LINE ", COMMENT },
+};
+
+static const char invXOp[] = "Invalid SYSIO";
+static const char *xName[MAX_XOP] = { /* SYSIO opcode mnemonics */
+/* 0x00 */ invXOp,      "EOF",       "EOLN",       "RESET",
+/* 0x04 */ "REWRITE",   invXOp,      invXOp,       invXOp,
+/* 0x08 */ invXOp,      invXOp,      invXOp,       invXOp,
+/* 0x0c */ invXOp,      invXOp,      invXOp,       invXOp,
+/* 0x10 */ "READLN",    "READPG",    "READBIN",    "READINT",
+/* 0x14 */ "READCHR",   "READSTR",   "READRL",     invXOp,
+/* 0x18 */ invXOp,      invXOp,      invXOp,       invXOp,
+/* 0x1c */ invXOp,      invXOp,      invXOp,       invXOp,
+/* 0x20 */ "WRITELN",   "WRITEPG",   "WRITEBIN",   "WRITEINT",
+/* 0x24 */ "WRITECHR",  "WRITESTR",  "WRITERL" };
+
+static const char invLbOp[] = "Invalid runtime code";
+static const char *lbName[MAX_LBOP] = { /* LIB opcode mnemonics */
+/* 0x00 */ "GETENV",     "STR2STR",   "CSTR2STR",  "STR2RSTR",
+/* 0x04 */ "CSTR2RSTR",  "VAL",       "MKSTK",     "MKSTKSTR",
+/* 0x08 */ "MKSTKC",     "STRCAT",    "STRCATC",   "STRCMP" };
+
+static const char invFpOp[] = "Invalid FP Operation";
+static const char *fpName[MAX_FOP] = {
+/* 0x00 */ invFpOp,    "FLOAT",    "TRUNC",    "ROUND",
+/* 0x04 */ "ADD",      "SUB",      "MUL",      "DIV",
+/* 0x08 */ "MOD",      invFpOp,    "EQU",      "NEQ",
+/* 0x0c */ "LT",       "GTE",      "GT",       "LTE",
+/* 0x10 */ "NEG",      "ABS",      "SQR",      "SQRT",
+/* 0x14 */ "SIN",      "COS",      "ATAN",     "LN",
+/* 0x18 */ "EXP" };
+
+/***********************************************************************/
+
+void insn_DisassemblePCode(FILE* lfile, OPTYPE *pop)
+{
+  /* Indent, comment or label */
+
+  switch (opTable[pop->op].format)
+    {
+    case LABEL_DEC :
+      fprintf(lfile, "L%04x:  ", pop->arg2);
+      break;
+    case COMMENT   :
+      fprintf(lfile, "; ");
+      break;
+    default   :
+      fprintf(lfile, "        ");
+    } /* end switch */
+
+  /* Special Case Comment line format */
+
+  if (opTable[pop->op].format == COMMENT)
+    {
+      fprintf(lfile, "%s ", opTable[pop->op].opName);
+      if (pop->op & o8)
+        {
+          fprintf(lfile, "%d", pop->arg1);
+          if (pop->op & o16)
+            fprintf(lfile, ":%d", pop->arg2);
+        } /* end if */
+      else if (pop->op & o16)
+        fprintf(lfile, "%d", pop->arg2);
+    } /* end if */
+
+  /* Print normal opCode mnemonic */
+
+  else
+    {
+      fprintf(lfile, "%s ", opTable[pop->op].opName);
+
+      /* Print pop->arg1 (if present) */
+
+      if (pop->op & o8) fprintf(lfile, "%d", pop->arg1);
+
+      /* Print ar16 (if present) */
+
+      if (pop->op & o16)
+        {
+          switch (opTable[pop->op].format)
+            {
+            case HEX       :
+              if (pop->op & o8) fprintf(lfile, ", ");
+              fprintf(lfile, "0x%04x", pop->arg2);
+              break;
+
+            case COMMENT   :
+            case DECIMAL   :
+              if (pop->op & o8) fprintf(lfile, ", ");
+              fprintf(lfile, "%ld", signExtend16(pop->arg2));
+              break;
+
+            case UDECIMAL   :
+              if (pop->op & o8) fprintf(lfile, ", ");
+              fprintf(lfile, "%u", pop->arg2);
+              break;
+
+            case fpOP       :
+              if ((pop->arg1 & fpMASK) < MAX_FOP)
+                fprintf(lfile, " %s", fpName[(pop->arg1 & 0x3f)]);
+              else
+                fprintf(lfile, " %s", invFpOp);
+              break;
+
+            case xOP       :
+              if (pop->arg2 < MAX_XOP)
+                fprintf(lfile, ", %s", xName[pop->arg2]);
+              else
+                fprintf(lfile, ", %s", invXOp);
+              break;
+
+            case lbOP :
+              if (pop->arg2 < MAX_LBOP)
+                fprintf(lfile, "%s", lbName[pop->arg2]);
+              else
+                fprintf(lfile, "%s", invLbOp);
+              break;
+
+            case LABEL_DEC :
+            default        :
+              break;
+            } /* end switch */
+        } /* end if */
+    } /* end else */
+
+  /* Don't forget the newline! */
+
+  fputc('\n', lfile);
+
+} /* end dissassemblePcode */
+
+/***********************************************************************/