#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <inttypes.h>

#include "user.h"
#include "types.h"
#include "em-const.h"

#include "sysent.h"

typedef struct bittbl BITTBL;

struct bittbl {
  const char *name;
  uint32_t mask;
  uint32_t val;
  } ;
#define BIT(name) { #name, em_##name, em_##name }
#define MASKVAL(name,mask,val) { #name, mask, val }
#define TBLEND() { 0 }

/*
 * The table of syscalls.
 */
SYSENT sysent[]
 = { SYSINIT(syscall,0,0),				// 0
     SYSINIT(exit,"V","d"),				// 1
     SYSINIT(fork,"dd",""),				// 2
     SYSINIT(read,"d","dpd"),				// 3
     SYSINIT(write,"d","dpd"),				// 4
     SYSINIT(open,"d","s(OPEN)O"),			// 5
     SYSINIT(close,"V","d"),				// 6
     SYSINIT(wait4,"d","dp(WAIT)p"),			// 7
     // 4.3 creat					// 8
     SYSINIT(link,"V","ss"),				// 9
     SYSINIT(unlink,"d","s"),				// 10
     // obsolete execv					// 11
     SYSINIT(chdir,"V","s"),				// 12
     SYSINIT(fchdir,"V","d"),				// 13
     SYSINIT(mknod,"V","p(MKNOD)"),			// 14
     SYSINIT(chmod,"V","so"),				// 15
     SYSINIT(chown,"V","sdd"),				// 16
     SYSINIT(break,"V","p"),				// 17
     SYSINIT(getfsstat,"d","pd(MNTWAIT)"),		// 18
     // 4.3 lseek					// 19
     SYSINIT(getpid,"dd",""),				// 20
     SYSINIT(mount,"d","ss(MOUNT)p"),			// 21
     SYSINIT(unmount,"V","s(UNMOUNT)"),			// 22
     SYSINIT(setuid,"V","d"),				// 23
     SYSINIT(getuid,"d",""),				// 24
     SYSINIT(geteuid,"d",""),				// 25
     SYSINIT(ptrace,"b","(PTRACE)dxb"),			// 26
     SYSINIT(recvmsg,"d","dp(RECVMSG)"),		// 27
     SYSINIT(sendmsg,"d","dp(SENDMSG)"),		// 28
     SYSINIT(recvfrom,"d","dpd(RECVMSG)pp"),		// 29
     SYSINIT(accept,"d","dpp"),				// 30
     SYSINIT(getpeername,"V","dpp"),			// 31
     SYSINIT(getsockname,"V","dpp"),			// 32
     SYSINIT(access,"V","s(ACCESS)"),			// 33
     SYSINIT(chflags,"V","s(CHFLAGS)"),			// 34
     SYSINIT(fchflags,"V","d(CHFLAGS)"),		// 35
     SYSINIT(sync,"V",""),				// 36
     SYSINIT(kill,"V","d(SIG)"),			// 37
     // 4.3 stat					// 38
     SYSINIT(getppid,"d",""),				// 39
     // 4.3 lstat					// 40
     SYSINIT(dup,"d","d"),				// 41
     SYSINIT(pipe,"dd",""),				// 42
     SYSINIT(getegid,"d",""),				// 43
     SYSINIT(profil,"V","pddd"),			// 44
     SYSINIT(ktrace,"V","s(KTROPS)(KTRFAC)d"),		// 45
     // SYSINIT(__sigaction13,"V","(SIG)pp"),		// 46
     SYSINIT(getgid,"d",""),				// 47
     // SYSINIT(__sigprocmask13,"V",			// 48
     //		"(SIGPROCMASK)(SIGMASK13)"),
     SYSINIT(__getlogin,"d","pd"),			// 49
     SYSINIT(setlogin,"V","s"),				// 50
     SYSINIT(acct,"V","s"),				// 51
     // SYSINIT(__sigpending13,"(SIGMASK13)",""),	// 52
     // SYSINIT(__sigaltstack13,"V","pp"),		// 53
     SYSINIT(ioctl,"d","d(IOCTL)p"),			// 54
     // SYSINIT(__reboot12,"V","(REBOOT)"),		// 55
     SYSINIT(revoke,"V","s"),				// 56
     SYSINIT(symlink,"V","ss"),				// 57
     SYSINIT(readlink,"d","spd"),			// 58
     SYSINIT(execve,"V","sxx"),				// 59
     SYSINIT(umask,"o","o"),				// 60
     SYSINIT(chroot,"V","s"),				// 61
     // 4.3 fstat					// 62
     // 4.3 getkerninfo					// 63
     // 4.3 getpagesize					// 64
     // SYSINIT(__msync12,"V","pb"),			// 65
     SYSINIT(vfork,"p",""),				// 66
     // obsolete vread					// 67
     // obsolete vwrite					// 68
     // obsolete sbrk					// 69
     // obsolete sstk					// 70
     // 4.3 mmap					// 71
     // SYSINIT(ovadvise,"V","d"),			// 72
     SYSINIT(munmap,"V","pd"),				// 73
     SYSINIT(mprotect,"V","pd(MMPROT)"),		// 74
     SYSINIT(madvise,"V","pd(MADV)"),			// 75
     // obsolete vhangup				// 76
     // obsolete vlimit					// 77
     SYSINIT(mincore,"V","pdp"),			// 78
     SYSINIT(getgroups,"d","dp"),			// 79
     SYSINIT(setgroups,"V","dp"),			// 80
     SYSINIT(getpgrp,"d",""),				// 81
     SYSINIT(setpgid,"V","dd"),				// 82
     SYSINIT(setitimer,"V","(ITIMER)pp"),		// 83
     // 4.3 wait					// 84
     // SYSINIT(__swapon12,"V","s"),			// 85
     SYSINIT(getitimer,"V","(ITIMER)p"),		// 86
     // 4.3 gethostname					// 87
     // 4.3 sethostname					// 88
     // 4.3 getdtablesize				// 89
     SYSINIT(dup2,"d","dd"),				// 90
     // unimplemented getdopt				// 91
     SYSINIT(fcntl,"d","d(FCNTL)b"),			// 92
     SYSINIT(select,"d","dpppp"),			// 93
     // unimplemented setdopt				// 94
     SYSINIT(fsync,"V","d"),				// 95
     SYSINIT(setpriority,"V","(PRIOWHICH)dd"),		// 96
     SYSINIT(socket,"d","(SOCKAF)(SOCKTYPE)d"),		// 97
     SYSINIT(connect,"V","dpd"),			// 98
     // 4.3 accept					// 99
     SYSINIT(getpriority,"d","(PRIOWHICH)d"),		// 100
     // 4.3 send					// 101
     // 4.3 recv					// 102
     // SYSINIT(__sigreturn13,"V","p"),			// 103
     SYSINIT(bind,"V","dpd"),				// 104
     SYSINIT(setsockopt,"V","dddpd"),			// 105
     SYSINIT(listen,"V","dd"),				// 106
     // obsolete vtimes					// 107
     // 4.3 sigvec					// 108
     // 4.3 sigblock					// 109
     // 4.3 sigsetmask					// 110
     // SYSINIT(__sigsuspend13,"V","x"),		// 111
     // 4.3 sigstack					// 112
     // 4.3 recvmsg					// 113
     // 4.3 sendmsg					// 114
     // obsolete vtrace					// 115
     SYSINIT(gettimeofday,"V","pp"),			// 116
     SYSINIT(getrusage,"V","(RUSAGE)p"),		// 117
     SYSINIT(getsockopt,"V","dddpp"),			// 118
     // obsolete resuba					// 119
     SYSINIT(readv,"d","dpd"),				// 120
     SYSINIT(writev,"d","dpd"),				// 121
     SYSINIT(settimeofday,"V","pp"),			// 122
     SYSINIT(fchown,"V","ddd"),				// 123
     SYSINIT(fchmod,"V","do"),				// 124
     // 4.3 recvfrom					// 125
     SYSINIT(setreuid,"V","dd"),			// 126
     SYSINIT(setregid,"V","dd"),			// 127
     SYSINIT(rename,"V","ss"),				// 128
     // 4.3 truncate					// 129
     // 4.3 ftruncate					// 130
     SYSINIT(flock,"V","d(FLOCK)"),			// 131
     SYSINIT(mkfifo,"V","so"),				// 132
     SYSINIT(sendto,"d","dpd(SENDMSG)pd"),		// 133
     SYSINIT(shutdown,"V","d(SHUTDOWN)"),		// 134
     SYSINIT(socketpair,"V","(SOCKAF)(SOCKTYPE)dp"),	// 135
     SYSINIT(mkdir,"V","so"),				// 136
     SYSINIT(rmdir,"V","s"),				// 137
     SYSINIT(utimes,"V","sp"),				// 138
     // obsolete sigreturn				// 139
     SYSINIT(adjtime,"V","pp"),				// 140
     // 4.3 getpeername					// 141
     // 4.3 gethostid					// 142
     // 4.3 sethostid					// 143
     // 4.3 getrlimit					// 144
     // 4.3 setrlimit					// 145
     // 4.3 killpg					// 146
     SYSINIT(setsid,"V",""),				// 147
     SYSINIT(quotactl,"V","s(QUOTACTL)dp"),		// 148
     // 4.3 quota					// 149
     // 4.3 getsockname					// 150
     // unimplemented					// 151
     // unimplemented					// 152
     // unimplemented					// 153
     // unimplemented					// 154
     SYSINIT(nfssvc,"V","(NFSSVC)p"),			// 155
     // 4.3 getdirentries				// 156
     SYSINIT(statfs,"V","sp"),				// 157
     SYSINIT(fstatfs,"V","dp"),				// 158
     // unimplemented					// 159
     // unimplemented					// 160
     SYSINIT(getfh,"V","sp"),				// 161
     // SYSINIT(__getdomainname09,"V","pd"),		// 162
     // SYSINIT(__setdomainname09,"V","sd"),		// 163
     // SYSINIT(__uname09,"V","p"),			// 164
     SYSINIT(sysarch,"V","dp"),				// 165
     // unimplemented					// 166
     // unimplemented					// 167
     // unimplemented					// 168
     // SYSINIT(__semsys10,"ddddd"),			// 169
     // SYSINIT(__msgsys10,"dddddd"),			// 170
     // SYSINIT(__shmsys10,"dddd"),			// 171
     // unimplemented					// 172
     SYSINIT(pread,"d","dpd-D"),			// 173
     SYSINIT(pwrite,"d","dpd-D"),			// 174
     SYSINIT(ntp_gettime,"(NTPSTATE)","p"),		// 175
     SYSINIT(ntp_adjtime,"(NTPSTATE)","p"),		// 176
     // unimplemented					// 177
     // unimplemented					// 178
     // unimplemented					// 179
     // unimplemented					// 180
     SYSINIT(setgid,"V","d"),				// 181
     SYSINIT(setegid,"V","d"),				// 182
     SYSINIT(seteuid,"V","d"),				// 183
     SYSINIT(lfs_bmapv,"V","ppd"),			// 184
     SYSINIT(lfs_markv,"V","ppd"),			// 185
     SYSINIT(lfs_segclean,"V","pd"),			// 186
     SYSINIT(lfs_segwait,"d","pp"),			// 187
     // SYSINIT(__stat12,"V","sp"),			// 188
     // SYSINIT(__fstat12,"V","dp"),			// 189
     // SYSINIT(__lstat12,"V","sp"),			// 190
     SYSINIT(pathconf,"d","s(PATHCONF)"),		// 191
     SYSINIT(fpathconf,"d","d(PATHCONF)"),		// 192
     // unimplemented					// 193
     SYSINIT(getrlimit,"V","(RLIMIT)p"),		// 194
     SYSINIT(setrlimit,"V","(RLIMIT)p"),		// 195
     // SYSINIT(__getdirentries12,"d","dpdp"),		// 196
     SYSINIT(mmap,"p","pd(MMPROT)(MMFLAG)d-D"),		// 197
     SYSINIT(__syscall,0,0),				// 198
     SYSINIT(lseek,"D","d-D(LSEEK)"),			// 199
     SYSINIT(truncate,"V","s-D"),			// 200
     SYSINIT(ftruncate,"V","d-D"),			// 201
     SYSINIT(__sysctl,"d","mpppd"),			// 202
     SYSINIT(mlock,"V","pd"),				// 203
     SYSINIT(munlock,"V","pd"),				// 204
     SYSINIT(undelete,"V","s"),				// 205
     SYSINIT(futimes,"V","dp"),				// 206
     SYSINIT(getpgid,"d","d"),				// 207
     SYSINIT(reboot,"V","(REBOOT)s"),			// 208
     SYSINIT(poll,"d","pdd"),				// 209
     // reserved for LKMs				// 210
     // reserved for LKMs				// 211
     // reserved for LKMs				// 212
     // reserved for LKMs				// 213
     // reserved for LKMs				// 214
     // reserved for LKMs				// 215
     // reserved for LKMs				// 216
     // reserved for LKMs				// 217
     // reserved for LKMs				// 218
     // reserved for LKMs				// 219
     // SYSINIT(__semctl14,"V","dd(SEMCTL)p"),		// 220
     SYSINIT(semget,"d","(IPCKEY)d(SEMFLG)"),		// 221
     SYSINIT(semop,"V","dpd"),				// 222
     SYSINIT(semconfig,"V","(SEMCONFIG)"),		// 223
     // SYSINIT(__msgctl14,"V","d(MSGCTL)p"),		// 224
     SYSINIT(msgget,"V","(IPCKEY)(MSGGET)"),		// 225
     SYSINIT(msgsnd,"V","dpd(MSGSND)"),			// 226
     SYSINIT(msgrcv,"d","dpdd(MSGRCV)"),		// 227
     SYSINIT(shmat,"p","dp(SHMAT)"),			// 228
     // SYSINIT(__shmctl14,"V","d(SHMAT)p"),		// 229
     SYSINIT(shmdt,"V","p"),				// 230
     SYSINIT(shmget,"d","(IPCKEY)d(SHMFLG)"),		// 231
     SYSINIT(clock_gettime,"V","(CLOCKID)p"),		// 232
     SYSINIT(clock_settime,"V","(CLOCKID)p"),		// 233
     SYSINIT(clock_getres,"V","(CLOCKID)p"),		// 234
     // unimplemented timer_create			// 235
     // unimplemented timer_delete			// 236
     // unimplemented timer_settime			// 237
     // unimplemented timer_gettime			// 238
     // unimplemented timer_getoverrun			// 239
     SYSINIT(nanosleep,"V","pp"),			// 240
     SYSINIT(fdatasync,"V","d"),			// 241
     SYSINIT(mlockall,"V","(MLOCKALL)"),		// 242
     SYSINIT(munlockall,"V",""),			// 243
     // unimplemented					// 244
     // unimplemented					// 245
     // unimplemented					// 246
     // unimplemented					// 247
     // unimplemented					// 248
     // unimplemented					// 249
     // unimplemented					// 250
     // unimplemented					// 251
     // unimplemented					// 252
     // unimplemented					// 253
     // unimplemented					// 254
     // unimplemented					// 255
     // unimplemented					// 256
     // unimplemented					// 257
     // unimplemented					// 258
     // unimplemented					// 259
     // unimplemented					// 260
     // unimplemented					// 261
     // unimplemented					// 262
     // unimplemented					// 263
     // unimplemented					// 264
     // unimplemented					// 265
     // unimplemented					// 266
     // unimplemented					// 267
     // unimplemented					// 268
     // unimplemented					// 269
     SYSINIT(__posix_rename,"V","ss"),			// 270
     SYSINIT(swapctl,"d","(SWAPCTL)pd"),		// 271
     SYSINIT(getdents,"d","dpd"),			// 272
     SYSINIT(minherit,"V","pd(MINHERIT)"),		// 273
     SYSINIT(lchmod,"V","so"),				// 274
     SYSINIT(lchown,"V","sdd"),				// 275
     SYSINIT(lutimes,"V","sp"),				// 276
     SYSINIT(__msync13,"V","pd(MSYNC)"),		// 277
     SYSINIT(__stat13,"V","sp"),			// 278
     SYSINIT(__fstat13,"V","dp"),			// 279
     SYSINIT(__lstat13,"V","sp"),			// 280
     SYSINIT(__sigaltstack14,"V","pp"),			// 281
     SYSINIT(__vfork14,"dd",""),			// 282
     SYSINIT(__posix_chown,"V","sdd"),			// 283
     SYSINIT(__posix_fchown,"V","ddd"),			// 284
     SYSINIT(__posix_lchown,"V","sdd"),			// 285
     SYSINIT(getsid,"d","d"),				// 286
     // unimplemented					// 287
     SYSINIT(fktrace,"V","d(KTROPS)(KTRFAC)d"),		// 288
     SYSINIT(preadv,"d","dpd-D"),			// 289
     SYSINIT(pwritev,"d","dpd-D"),			// 290
     SYSINIT(__sigaction14,"V","(SIG)pp"),		// 291
     SYSINIT(__sigpending14,"V","p"),			// 292
     SYSINIT(__sigprocmask14,"V","(SIGPROCMASK)pp"),	// 293
     SYSINIT(__sigsuspend14,"V","p"),			// 294
     SYSINIT(__sigreturn14,"V","p"),			// 295
     SYSINIT(__getcwd,"d","pd"),			// 296
     SYSINIT(fchroot,"V","d"),				// 297
     SYSINIT(fhopen,"d","p(OPEN)"),			// 298
     SYSINIT(fhstat,"V","pp"),				// 299
     SYSINIT(fhstatfs,"V","pp"),			// 300
     SYSINIT(____semctl13,"d","dd(SEMCTL)p"),		// 301
     SYSINIT(__msgctl13,"V","d(MSGCTL)p"),		// 302
     SYSINIT(__shmctl13,"V","d(SHMCTL)p"),		// 303
     [0] = { 0, 0 } };

const int nsysent = sizeof(sysent) / sizeof(sysent[0]);

static int simple_format(FILE *f, const char c, uint32_t val)
{
 switch (c)
  { case 'd':
       fprintf(f,"%ld",(LI)(int32_t)val);
       break;
    case 'p':
    case 'x': // same as p for the moment
       if (val) fprintf(f,"%08lx",(ULI)val); else fprintf(f,"0");
       break;
    case 'b':
       if (val < 10)
	{ fprintf(f,"%d",(int)(unsigned int)val);
	}
       else
	{ fprintf(f,"%#lx=%ld",(ULI)val,(LI)(int32_t)val);
	}
       break;
    case 's':
	{ VAL8 c;
	  int defer;
	  fprintf(f,"%08lx=\"",(ULI)val);
	  defer = -1;
	  while (1)
	   { c = mem_get_1(val++);
	     if (defer >= 0)
	      { if ((c.d == 0xff) && ((c.v >= '0') && (c.v <= '9')))
		 { fprintf(f,"\\%03o",defer);
		 }
		else
		 { fprintf(f,"\\%o",defer);
		 }
		defer = -1;
	      }
	     if ((c.d == 0xff) && (c.v == 0)) break;
	     switch (c.d)
	      { case 0x00:
		   fprintf(f,"\\<u>");
		   break;
		case 0xff:
		   switch (c.v)
		    { case '\a': fprintf(f,"\\a"); break;
		      case '\b': fprintf(f,"\\b"); break;
		      case '\e': fprintf(f,"\\e"); break;
		      case '\f': fprintf(f,"\\f"); break;
		      case '\n': fprintf(f,"\\n"); break;
		      case '\r': fprintf(f,"\\r"); break;
		      case '\t': fprintf(f,"\\t"); break;
		      case '\v': fprintf(f,"\\v"); break;
		      case '\\': fprintf(f,"\\\\"); break;
		      default:
			 if (c.v < 31)
			  { defer = c.v;
			  }
			 else if ((c.v >= 127) && (c.v < 160))
			  { fprintf(f,"\\%o",c.v);
			  }
			 else
			  { fprintf(f,"%c",c.v);
			  }
			 break;
		    }
		   break;
		default:
		    { int i;
		      fprintf(f,"\\<");
		      for (i=8-1;i>=0;i--)
		       { if ((c.d >> i) & 1)
			  { putc(((c.v>>i)&1)?'1':'0',f);
			  }
			 else
			  { putc('?',f);
			  }
		       }
		      fprintf(f,">");
		    }
		   break;
	      }
	     if ((c.v & c.d) == 0) break;
	   }
	  fprintf(f,"\"");
	}
       break;
    case 'o':
       fprintf(f,"%#lo",(ULI)val);
       break;
    case '-':
       fprintf(f,"pad");
       break;
    default:
       return(0);
       break;
  }
 return(1);
}

#define BM_PRINT0 0x00000001
static int print_special_bitmask(FILE *f, uint32_t val, const BITTBL *tbl, unsigned int flags)
{
 uint32_t used;
 int i;
 const char *sep;

 used = 0;
 sep = "";
 for (i=0;tbl[i].name;i++)
  { if (tbl[i].mask & used) continue;
    if ((val & tbl[i].mask) != tbl[i].val) continue;
    fprintf(f,"%s%s",sep,tbl[i].name);
    sep = "|";
    used |= tbl[i].mask;
  }
 val &= ~used;
 if (val)
  { fprintf(f,"%s%#lx",sep,(ULI)val);
    sep = "|";
  }
 if (sep[0]) return(1);
 if (flags & BM_PRINT0)
  { fprintf(f,"0");
    return(1);
  }
 return(0);
}

static void print_special_SIG(FILE *f, uint32_t val)
{
 switch (val)
  { case em_SIGHUP:    fprintf(f,"SIGHUP");    break;
    case em_SIGINT:    fprintf(f,"SIGINT");    break;
    case em_SIGQUIT:   fprintf(f,"SIGQUIT");   break;
    case em_SIGILL:    fprintf(f,"SIGILL");    break;
    case em_SIGTRAP:   fprintf(f,"SIGTRAP");   break;
    case em_SIGABRT:   fprintf(f,"SIGABRT");   break;
    case em_SIGEMT:    fprintf(f,"SIGEMT");    break;
    case em_SIGFPE:    fprintf(f,"SIGFPE");    break;
    case em_SIGKILL:   fprintf(f,"SIGKILL");   break;
    case em_SIGBUS:    fprintf(f,"SIGBUS");    break;
    case em_SIGSEGV:   fprintf(f,"SIGSEGV");   break;
    case em_SIGSYS:    fprintf(f,"SIGSYS");    break;
    case em_SIGPIPE:   fprintf(f,"SIGPIPE");   break;
    case em_SIGALRM:   fprintf(f,"SIGALRM");   break;
    case em_SIGTERM:   fprintf(f,"SIGTERM");   break;
    case em_SIGURG:    fprintf(f,"SIGURG");    break;
    case em_SIGSTOP:   fprintf(f,"SIGSTOP");   break;
    case em_SIGTSTP:   fprintf(f,"SIGTSTP");   break;
    case em_SIGCONT:   fprintf(f,"SIGCONT");   break;
    case em_SIGCHLD:   fprintf(f,"SIGCHLD");   break;
    case em_SIGTTIN:   fprintf(f,"SIGTTIN");   break;
    case em_SIGTTOU:   fprintf(f,"SIGTTOU");   break;
    case em_SIGIO:     fprintf(f,"SIGIO");     break;
    case em_SIGXCPU:   fprintf(f,"SIGXCPU");   break;
    case em_SIGXFSZ:   fprintf(f,"SIGXFSZ");   break;
    case em_SIGVTALRM: fprintf(f,"SIGVTALRM"); break;
    case em_SIGPROF:   fprintf(f,"SIGPROF");   break;
    case em_SIGWINCH:  fprintf(f,"SIGWINCH");  break;
    case em_SIGINFO:   fprintf(f,"SIGINFO");   break;
    case em_SIGUSR1:   fprintf(f,"SIGUSR1");   break;
    case em_SIGUSR2:   fprintf(f,"SIGUSR2");   break;
    case em_SIGPWR:    fprintf(f,"SIGPWR");    break;
    default: fprintf(f,"%lld",(long long int)(int32_t)val); break;
  }
}

static void print_special_MADV(FILE *f, uint32_t val)
{
 switch (val)
  { case em_MADV_NORMAL:     fprintf(f,"MADV_NORMAL");     break;
    case em_MADV_RANDOM:     fprintf(f,"MADV_RANDOM");     break;
    case em_MADV_SEQUENTIAL: fprintf(f,"MADV_SEQUENTIAL"); break;
    case em_MADV_WILLNEED:   fprintf(f,"MADV_WILLNEED");   break;
    case em_MADV_DONTNEED:   fprintf(f,"MADV_DONTNEED");   break;
    case em_MADV_SPACEAVAIL: fprintf(f,"MADV_SPACEAVAIL"); break;
    case em_MADV_FREE:       fprintf(f,"MADV_FREE");       break;
    default: fprintf(f,"%lld",(long long int)(int32_t)val); break;
  }
}

static void print_special_OPEN(FILE *f, uint32_t val)
{
 static const BITTBL bits_OPEN[]
  = { MASKVAL(O_RDONLY,em_O_ACCMODE,em_O_RDONLY),
      MASKVAL(O_WRONLY,em_O_ACCMODE,em_O_WRONLY),
      MASKVAL(O_RDWR,em_O_ACCMODE,em_O_RDWR),
      MASKVAL(O_NOACCESS,em_O_ACCMODE,em_O_NOACCESS),
      BIT(O_NONBLOCK),
      BIT(O_APPEND),
      BIT(O_SHLOCK),
      BIT(O_EXLOCK),
      BIT(O_ASYNC),
      BIT(O_SYNC),
      BIT(O_CREAT),
      BIT(O_TRUNC),
      BIT(O_EXCL),
      BIT(O_DSYNC),
      BIT(O_RSYNC),
      BIT(O_ALT_IO),
      BIT(O_NOCTTY),
      BIT(O_DIRECTORY),
      BIT(O_PLAIN),
      TBLEND() };

 print_special_bitmask(f,val,&bits_OPEN[0],0);
}

static void print_special_WAIT(FILE *f, uint32_t val)
{
 static const BITTBL bits_WAIT[]
  = { BIT(WNOHANG),
      BIT(WUNTRACED),
      BIT(WALTSIG),
      BIT(WNOREAP),
      TBLEND() };

 print_special_bitmask(f,val,&bits_WAIT[0],BM_PRINT0);
}

static void print_special_FCNTL(FILE *f, uint32_t val)
{
 switch (val)
  { case em_F_DUPFD:  fprintf(f,"F_DUPFD");  break;
    case em_F_GETFD:  fprintf(f,"F_GETFD");  break;
    case em_F_SETFD:  fprintf(f,"F_SETFD");  break;
    case em_F_GETFL:  fprintf(f,"F_GETFL");  break;
    case em_F_SETFL:  fprintf(f,"F_SETFL");  break;
    case em_F_GETOWN: fprintf(f,"F_GETOWN"); break;
    case em_F_SETOWN: fprintf(f,"F_SETOWN"); break;
    case em_F_GETLK:  fprintf(f,"F_GETLK");  break;
    case em_F_SETLK:  fprintf(f,"F_SETLK");  break;
    case em_F_SETLKW: fprintf(f,"F_SETLKW"); break;
    case em_F_CLOSEM: fprintf(f,"F_CLOSEM"); break;
    case em_F_MAXFD:  fprintf(f,"F_MAXFD");  break;
    default: fprintf(f,"%lld",(long long int)(int32_t)val); break;
  }
}

static void print_special_FLOCK(FILE *f, uint32_t val)
{
 static const BITTBL bits_FLOCK[]
  = { BIT(LOCK_SH),
      BIT(LOCK_EX),
      BIT(LOCK_NB),
      BIT(LOCK_UN),
      TBLEND() };

 print_special_bitmask(f,val,&bits_FLOCK[0],BM_PRINT0);
}

static void print_special_IOCTL(FILE *f, uint32_t val)
{
 switch (val)
  { case em_TIOCGETA:   fprintf(f,"TIOCGETA");   break;
    case em_TIOCGPGRP:  fprintf(f,"TIOCGPGRP");  break;
    case em_TIOCSPGRP:  fprintf(f,"TIOCSPGRP");  break;
    case em_TIOCGWINSZ: fprintf(f,"TIOCGWINSZ"); break;
    case em_FIOCLEX:    fprintf(f,"FIOCLEX");    break;
    case em_TIOCSETAW:  fprintf(f,"TIOCSETAW");  break;
    case em_FIONCLEX:   fprintf(f,"FIONCLEX");   break;
    case em_TIOCSETA:   fprintf(f,"TIOCSETA");   break;
    case em_TIOCGETD:   fprintf(f,"TIOCGETD");   break;
    case em_TIOCSETAF:  fprintf(f,"TIOCSETAF");  break;
    case em_TIOCSWINSZ: fprintf(f,"TIOCSWINSZ"); break;
    case em_MTIOCGET:   fprintf(f,"MTIOCGET");   break;
    case em_FIONREAD:   fprintf(f,"FIONREAD");   break;
    case em_FIONBIO:    fprintf(f,"FIONBIO");    break;
    // When adding cases to this switch, consider implementing them (sc_ioctl)
    default:
       fprintf(f,"%08lx=",(ULI)val);
       print_decoded_ioctl(f,val);
       break;
  }
}

static void print_special_LSEEK(FILE *f, uint32_t val)
{
 switch (val)
  { case em_SEEK_SET: fprintf(f,"SEEK_SET"); break;
    case em_SEEK_CUR: fprintf(f,"SEEK_CUR"); break;
    case em_SEEK_END: fprintf(f,"SEEK_END"); break;
    default: fprintf(f,"%lld",(long long int)(int32_t)val); break;
  }
}

static void print_special_MKNOD(FILE *f, uint32_t val)
{
 const char *sep;
 const char *vs;

 if (val & ~(uint32_t)0177777)
  { fprintf(f,"%#lx",(ULI)(val&~(uint32_t)0177777));
    sep = "|";
  }
 else
  { sep = "";
  }
 switch (val & em_S_IFMT)
  { case em_S_IFIFO:  vs = "S_IFIFO";  break;
    case em_S_IFCHR:  vs = "S_IFCHR";  break;
    case em_S_IFDIR:  vs = "S_IFDIR";  break;
    case em_S_IFBLK:  vs = "S_IFBLK";  break;
    case em_S_IFREG:  vs = "S_IFREG";  break;
    case em_S_IFLNK:  vs = "S_IFLNK";  break;
    case em_S_IFSOCK: vs = "S_IFSOCK"; break;
    case em_S_IFWHT:  vs = "S_IFWHT";  break;
    default: vs = 0; break;
  }
 if (vs)
  { fprintf(f,"%s%s",sep,vs);
  }
 else
  { fprintf(f,"%s%lo",sep,(ULI)(val&em_S_IFMT));
  }
 fprintf(f,"|%04lo",(ULI)(val&07777));
}

static void print_special_MOUNT(FILE *f, uint32_t val)
{
 static const BITTBL bits_FLOCK[]
  = { BIT(MNT_RDONLY),
      BIT(MNT_SYNCHRONOUS),
      BIT(MNT_NOEXEC),
      BIT(MNT_NOSUID),
      BIT(MNT_NODEV),
      BIT(MNT_UNION),
      BIT(MNT_NOCOREDUMP),
      BIT(MNT_UPDATE),
      TBLEND() };

 print_special_bitmask(f,val,&bits_FLOCK[0],BM_PRINT0);
}

static void print_special_MSYNC(FILE *f, uint32_t val)
{
 static const BITTBL bits_MSYNC[]
  = { BIT(MS_ASYNC),
      BIT(MS_INVALIDATE),
      BIT(MS_SYNC),
      TBLEND() };

 print_special_bitmask(f,val,&bits_MSYNC[0],BM_PRINT0);
}

static void print_special_SHMAT(FILE *f, uint32_t val)
{
 static const BITTBL bits_SHMAT[]
  = { BIT(SHM_RDONLY),
      BIT(SHM_RND),
      TBLEND() };

 print_special_bitmask(f,val,&bits_SHMAT[0],BM_PRINT0);
}

static void print_special_ACCESS(FILE *f, uint32_t val)
{
 static const BITTBL bits_ACCESS[]
  = { BIT(X_OK),
      BIT(W_OK),
      BIT(R_OK),
      TBLEND() };

 if (val == 0)
  { fprintf(f,"F_OK");
  }
 else
  { print_special_bitmask(f,val,&bits_ACCESS[0],0);
  }
}

static void print_special_SEMCTL(FILE *f, uint32_t val)
{
 switch (val)
  { case em_IPC_RMID: fprintf(f,"IPC_RMID"); break;
    case em_IPC_SET:  fprintf(f,"IPC_SET");  break;
    case em_IPC_STAT: fprintf(f,"IPC_STAT"); break;
    case em_GETNCNT:  fprintf(f,"GETNCNT");  break;
    case em_GETPID:   fprintf(f,"GETPID");   break;
    case em_GETVAL:   fprintf(f,"GETVAL");   break;
    case em_GETALL:   fprintf(f,"GETALL");   break;
    case em_GETZCNT:  fprintf(f,"GETZCNT");  break;
    case em_SETVAL:   fprintf(f,"SETVAL");   break;
    case em_SETALL:   fprintf(f,"SETALL");   break;
    default: fprintf(f,"%lld",(long long int)(int32_t)val); break;
  }
}

static void print_special_SEMFLG(FILE *f, uint32_t val)
{
 static const BITTBL bits_SEMFLG[]
  = { BIT(IPC_CREAT),
      BIT(IPC_EXCL),
      TBLEND() };

 if (print_special_bitmask(f,val&~0777,&bits_SEMFLG[0],0)) fprintf(f,"|");
 fprintf(f,"%o",(unsigned int)(val&0777));
}

static void print_special_REBOOT(FILE *f, uint32_t val)
{
 static const BITTBL bits_REBOOT[]
  = { BIT(RB_ASKNAME),
      BIT(RB_SINGLE),
      BIT(RB_NOSYNC),
      BIT(RB_HALT),
      BIT(RB_INITNAME),
      BIT(RB_DFLTROOT),
      BIT(RB_KDB),
      BIT(RB_RDONLY),
      BIT(RB_DUMP),
      BIT(RB_MINIROOT),
      BIT(RB_STRING),
      BIT(RB_POWERDOWN),
      BIT(RB_CHROOT),
      BIT(RB_INITPATH),
      TBLEND() };

 print_special_bitmask(f,val,&bits_REBOOT[0],BM_PRINT0);
}

static void print_special_NFSSVC(FILE *f, uint32_t val)
{
 static const BITTBL bits_NFSSVC[]
  = { BIT(NFSSVC_BIOD),
      BIT(NFSSVC_MNTD),
      BIT(NFSSVC_GOTAUTH),
      BIT(NFSSVC_ADDSOCK),
      BIT(NFSSVC_AUTHIN),
      BIT(NFSSVC_AUTHINFAIL),
      TBLEND() };

 print_special_bitmask(f,val,&bits_NFSSVC[0],BM_PRINT0);
}

static void print_special_SHMCTL(FILE *f, uint32_t val)
{
 switch (val)
  { case em_IPC_RMID: fprintf(f,"IPC_RMID"); break;
    case em_IPC_SET:  fprintf(f,"IPC_SET");  break;
    case em_IPC_STAT: fprintf(f,"IPC_STAT"); break;
    default: fprintf(f,"%lld",(long long int)(int32_t)val); break;
  }
}

static void print_special_SHMFLG(FILE *f, uint32_t val)
{
 static const BITTBL bits_SEMFLG[]
  = { BIT(IPC_CREAT),
      BIT(IPC_EXCL),
      TBLEND() };

 if (print_special_bitmask(f,val&~0777,&bits_SEMFLG[0],0)) fprintf(f,"|");
 fprintf(f,"%o",(unsigned int)(val&0777));
}

static void print_special_RLIMIT(FILE *f, uint32_t val)
{
 switch (val)
  { case em_RLIMIT_CPU:     fprintf(f,"RLIMIT_CPU");     break;
    case em_RLIMIT_FSIZE:   fprintf(f,"RLIMIT_FSIZE");   break;
    case em_RLIMIT_DATA:    fprintf(f,"RLIMIT_DATA");    break;
    case em_RLIMIT_STACK:   fprintf(f,"RLIMIT_STACK");   break;
    case em_RLIMIT_CORE:    fprintf(f,"RLIMIT_CORE");    break;
    case em_RLIMIT_RSS:     fprintf(f,"RLIMIT_RSS");     break;
    case em_RLIMIT_MEMLOCK: fprintf(f,"RLIMIT_MEMLOCK"); break;
    case em_RLIMIT_NPROC:   fprintf(f,"RLIMIT_NPROC");   break;
    case em_RLIMIT_NOFILE:  fprintf(f,"RLIMIT_NOFILE");  break;
    default: fprintf(f,"%lld",(long long int)(int32_t)val); break;
  }
}

static void print_special_MMFLAG(FILE *f, uint32_t val)
{
 static const BITTBL bits_MMFLAG[]
  = { BIT(MAP_SHARED),
      BIT(MAP_PRIVATE),
      BIT(MAP_COPY),
      BIT(MAP_FIXED),
      BIT(MAP_RENAME),
      BIT(MAP_NORESERVE),
      BIT(MAP_INHERIT),
      BIT(MAP_NOEXTEND),
      BIT(MAP_HASSEMAPHORE),
      MASKVAL(MAP_FILE,em_MAP_FILE|em_MAP_ANON,em_MAP_FILE),
      MASKVAL(MAP_ANON,em_MAP_FILE|em_MAP_ANON,em_MAP_ANON),
      TBLEND() };

 print_special_bitmask(f,val,&bits_MMFLAG[0],BM_PRINT0);
}

static void print_special_MMPROT(FILE *f, uint32_t val)
{
 static const BITTBL bits_MMPROT[]
  = { BIT(PROT_READ),
      BIT(PROT_WRITE),
      BIT(PROT_EXEC),
      TBLEND() };

 if (val == 0)
  { fprintf(f,"PROT_NONE");
  }
 else
  { print_special_bitmask(f,val,&bits_MMPROT[0],0);
  }
}

static void print_special_SOCKAF(FILE *f, uint32_t val)
{
 switch (val)
  { case em_AF_UNSPEC:          fprintf(f,"AF_UNSPEC");          break;
    case em_AF_LOCAL:           fprintf(f,"AF_LOCAL");           break;
    case em_AF_INET:            fprintf(f,"AF_INET");            break;
    case em_AF_IMPLINK:         fprintf(f,"AF_IMPLINK");         break;
    case em_AF_PUP:             fprintf(f,"AF_PUP");             break;
    case em_AF_CHAOS:           fprintf(f,"AF_CHAOS");           break;
    case em_AF_NS:              fprintf(f,"AF_NS");              break;
    case em_AF_ISO:             fprintf(f,"AF_ISO");             break;
    case em_AF_ECMA:            fprintf(f,"AF_ECMA");            break;
    case em_AF_DATAKIT:         fprintf(f,"AF_DATAKIT");         break;
    case em_AF_CCITT:           fprintf(f,"AF_CCITT");           break;
    case em_AF_SNA:             fprintf(f,"AF_SNA");             break;
    case em_AF_DECnet:          fprintf(f,"AF_DECnet");          break;
    case em_AF_DLI:             fprintf(f,"AF_DLI");             break;
    case em_AF_LAT:             fprintf(f,"AF_LAT");             break;
    case em_AF_HYLINK:          fprintf(f,"AF_HYLINK");          break;
    case em_AF_APPLETALK:       fprintf(f,"AF_APPLETALK");       break;
    case em_AF_ROUTE:           fprintf(f,"AF_ROUTE");           break;
    case em_AF_LINK:            fprintf(f,"AF_LINK");            break;
    case em_pseudo_AF_XTP:      fprintf(f,"pseudo_AF_XTP");      break;
    case em_AF_COIP:            fprintf(f,"AF_COIP");            break;
    case em_AF_CNT:             fprintf(f,"AF_CNT");             break;
    case em_pseudo_AF_RTIP:     fprintf(f,"pseudo_AF_RTIP");     break;
    case em_AF_IPX:             fprintf(f,"AF_IPX");             break;
    case em_AF_INET6:           fprintf(f,"AF_INET6");           break;
    case em_pseudo_AF_PIP:      fprintf(f,"pseudo_AF_PIP");      break;
    case em_AF_ISDN:            fprintf(f,"AF_ISDN");            break;
    case em_AF_NATM:            fprintf(f,"AF_NATM");            break;
    case em_AF_ARP:             fprintf(f,"AF_ARP");             break;
    case em_pseudo_AF_KEY:      fprintf(f,"pseudo_AF_KEY");      break;
    case em_pseudo_AF_HDRCMPLT: fprintf(f,"pseudo_AF_HDRCMPLT"); break;
    case em_AF_TIMER:           fprintf(f,"AF_TIMER");           break;
    default: fprintf(f,"%lld",(long long int)(int32_t)val); break;
  }
}

static void print_special_IPCKEY(FILE *f, uint32_t val)
{
 if (val == em_IPC_PRIVATE)
  { fprintf(f,"IPC_PRIVATE");
  }
 else
  { fprintf(f,"%lld",(long long int)(int32_t)val);
  }
}

static void print_special_MSGCTL(FILE *f, uint32_t val)
{
 switch (val)
  { case em_IPC_RMID: fprintf(f,"IPC_RMID"); break;
    case em_IPC_SET:  fprintf(f,"IPC_SET");  break;
    case em_IPC_STAT: fprintf(f,"IPC_STAT"); break;
    default: fprintf(f,"%lld",(long long int)(int32_t)val); break;
  }
}

static void print_special_MSGGET(FILE *f, uint32_t val)
{
 static const BITTBL bits_MSGGET[]
  = { BIT(IPC_CREAT),
      BIT(IPC_EXCL),
      TBLEND() };

 if (print_special_bitmask(f,val&~0777,&bits_MSGGET[0],0)) fprintf(f,"|");
 fprintf(f,"%o",(unsigned int)(val&0777));
}

static void print_special_MSGRCV(FILE *f, uint32_t val)
{
 static const BITTBL bits_MSGRCV[]
  = { BIT(IPC_NOWAIT),
      BIT(MSG_NOERROR),
      TBLEND() };

 print_special_bitmask(f,val,&bits_MSGRCV[0],BM_PRINT0);
}

static void print_special_MSGSND(FILE *f, uint32_t val)
{
 static const BITTBL bits_MSGSND[]
  = { BIT(IPC_NOWAIT),
      TBLEND() };

 print_special_bitmask(f,val,&bits_MSGSND[0],BM_PRINT0);
}

static void print_special_PTRACE(FILE *f, uint32_t val)
{
 switch (val)
  { case em_PT_TRACE_ME:  fprintf(f,"PT_TRACE_ME");  break;
    case em_PT_READ_I:    fprintf(f,"PT_READ_I");    break;
    case em_PT_READ_D:    fprintf(f,"PT_READ_D");    break;
    case em_PT_WRITE_I:   fprintf(f,"PT_WRITE_I");   break;
    case em_PT_WRITE_D:   fprintf(f,"PT_WRITE_D");   break;
    case em_PT_CONTINUE:  fprintf(f,"PT_CONTINUE");  break;
    case em_PT_KILL:      fprintf(f,"PT_KILL");      break;
    case em_PT_ATTACH:    fprintf(f,"PT_ATTACH");    break;
    case em_PT_DETACH:    fprintf(f,"PT_DETACH");    break;
    case em_PT_BLK:       fprintf(f,"PT_BLK");       break;
    case em_PT_SYSCALL:   fprintf(f,"PT_SYSCALL");   break;
    case em_PT_RSYSCALL:  fprintf(f,"PT_RSYSCALL");  break;
    case em_PT_WSYSCALL:  fprintf(f,"PT_WSYSCALL");  break;
    case em_PT_GETREGS:   fprintf(f,"PT_GETREGS");   break;
    case em_PT_SETREGS:   fprintf(f,"PT_SETREGS");   break;
    case em_PT_GETFPREGS: fprintf(f,"PT_GETFPREGS"); break;
    case em_PT_SETFPREGS: fprintf(f,"PT_SETFPREGS"); break;
    default: fprintf(f,"%lld",(long long int)(int32_t)val); break;
  }
}

static void print_special_KTRFAC(FILE *f, uint32_t val)
{
 static const BITTBL bits_KTRFAC[]
  = { BIT(KTRFAC_SYSCALL),
      BIT(KTRFAC_SYSRET),
      BIT(KTRFAC_NAMEI),
      BIT(KTRFAC_GENIO),
      BIT(KTRFAC_PSIG),
      BIT(KTRFAC_CSW),
      BIT(KTRFAC_EMUL),
      BIT(KTRFAC_INHERIT),
      TBLEND() };

 print_special_bitmask(f,val,&bits_KTRFAC[0],BM_PRINT0);
}

static void print_special_ITIMER(FILE *f, uint32_t val)
{
 switch (val)
  { case em_ITIMER_REAL: fprintf(f,"ITIMER_REAL"); break;
    case em_ITIMER_VIRTUAL: fprintf(f,"ITIMER_VIRTUAL"); break;
    case em_ITIMER_PROF: fprintf(f,"ITIMER_PROF"); break;
    default: fprintf(f,"%lld",(long long int)(int32_t)val); break;
  }
}

static void print_special_KTROPS(FILE *f, uint32_t val)
{
 static const BITTBL bits_KTROPS[]
  = { MASKVAL(KTROP_SET,em_KTROP_MASK,em_KTROP_SET),
      MASKVAL(KTROP_CLEAR,em_KTROP_MASK,em_KTROP_CLEAR),
      MASKVAL(KTROP_CLEARFILE,em_KTROP_MASK,em_KTROP_CLEARFILE),
      BIT(KTRFLAG_DESCEND),
      TBLEND() };

 print_special_bitmask(f,val,&bits_KTROPS[0],BM_PRINT0);
}

static void print_special_RUSAGE(FILE *f, uint32_t val)
{
 switch (val)
  { case em_RUSAGE_SELF:     fprintf(f,"RUSAGE_SELF");     break;
    case em_RUSAGE_CHILDREN: fprintf(f,"RUSAGE_CHILDREN"); break;
    default: fprintf(f,"%lld",(long long int)(int32_t)val); break;
  }
}

static void print_special_SWAPCTL(FILE *f, uint32_t val)
{
 switch (val)
  { case em_SWAP_ON:      fprintf(f,"SWAP_ON");      break;
    case em_SWAP_OFF:     fprintf(f,"SWAP_OFF");     break;
    case em_SWAP_NSWAP:   fprintf(f,"SWAP_NSWAP");   break;
    case em_SWAP_OSTATS:  fprintf(f,"SWAP_OSTATS");  break;
    case em_SWAP_CTL:     fprintf(f,"SWAP_CTL");     break;
    case em_SWAP_STATS:   fprintf(f,"SWAP_STATS");   break;
    case em_SWAP_DUMPDEV: fprintf(f,"SWAP_DUMPDEV"); break;
    default: fprintf(f,"%lld",(long long int)(int32_t)val); break;
  }
}

static void print_special_RECVMSG(FILE *f, uint32_t val)
{
 static const BITTBL bits_RECVMSG[]
  = { BIT(MSG_OOB),
      BIT(MSG_PEEK),
      BIT(MSG_WAITALL),
      TBLEND() };

 print_special_bitmask(f,val,&bits_RECVMSG[0],BM_PRINT0);
}

static void print_special_CHFLAGS(FILE *f, uint32_t val)
{
 static const BITTBL bits_CHFLAGS[]
  = { BIT(UF_NODUMP),
      BIT(UF_IMMUTABLE),
      BIT(UF_APPEND),
      BIT(UF_OPAQUE),
      BIT(SF_ARCHIVED),
      BIT(SF_IMMUTABLE),
      BIT(SF_APPEND),
      TBLEND() };

 print_special_bitmask(f,val,&bits_CHFLAGS[0],BM_PRINT0);
}

static void print_special_UNMOUNT(FILE *f, uint32_t val)
{
 static const BITTBL bits_UNMOUNT[]
  = { BIT(MNT_FORCE),
      TBLEND() };

 print_special_bitmask(f,val,&bits_UNMOUNT[0],BM_PRINT0);
}

static void print_special_SENDMSG(FILE *f, uint32_t val)
{
 static const BITTBL bits_SENDMSG[]
  = { BIT(MSG_OOB),
      BIT(MSG_DONTROUTE),
      BIT(MSG_DONTWAIT),
      BIT(MSG_NOSIGNAL),
      TBLEND() };

 print_special_bitmask(f,val,&bits_SENDMSG[0],BM_PRINT0);
}

static void print_special_CLOCKID(FILE *f, uint32_t val)
{
 switch (val)
  { case em_CLOCK_REALTIME: fprintf(f,"CLOCK_REALTIME"); break;
    default: fprintf(f,"%lld",(long long int)(int32_t)val); break;
  }
}

static void print_special_MNTWAIT(FILE *f, uint32_t val)
{
 switch (val)
  { case em_MNT_WAIT:   fprintf(f,"MNT_WAIT");   break;
    case em_MNT_NOWAIT: fprintf(f,"MNT_NOWAIT"); break;
    case em_MNT_LAZY:   fprintf(f,"MNT_LAZY");   break;
    default: fprintf(f,"%lld",(long long int)(int32_t)val); break;
  }
}

static void print_special_PATHCONF(FILE *f, uint32_t val)
{
 switch (val)
  { case em__PC_LINK_MAX:         fprintf(f,"_PC_LINK_MAX");         break;
    case em__PC_MAX_CANON:        fprintf(f,"_PC_MAX_CANON");        break;
    case em__PC_MAX_INPUT:        fprintf(f,"_PC_MAX_INPUT");        break;
    case em__PC_NAME_MAX:         fprintf(f,"_PC_NAME_MAX");         break;
    case em__PC_PATH_MAX:         fprintf(f,"_PC_PATH_MAX");         break;
    case em__PC_PIPE_BUF:         fprintf(f,"_PC_PIPE_BUF");         break;
    case em__PC_CHOWN_RESTRICTED: fprintf(f,"_PC_CHOWN_RESTRICTED"); break;
    case em__PC_NO_TRUNC:         fprintf(f,"_PC_NO_TRUNC");         break;
    case em__PC_VDISABLE:         fprintf(f,"_PC_VDISABLE");         break;
    case em__PC_SYNC_IO:          fprintf(f,"_PC_SYNC_IO");          break;
    case em__PC_FILESIZEBITS:     fprintf(f,"_PC_FILESIZEBITS");     break;
    default: fprintf(f,"%lld",(long long int)(int32_t)val); break;
  }
}

static void print_special_SHUTDOWN(FILE *f, uint32_t val)
{
 switch (val)
  { case em_SHUT_RD:   fprintf(f,"SHUT_RD");   break;
    case em_SHUT_WR:   fprintf(f,"SHUT_WR");   break;
    case em_SHUT_RDWR: fprintf(f,"SHUT_RDWR"); break;
    default: fprintf(f,"%lld",(long long int)(int32_t)val); break;
  }
}

static void print_special_MINHERIT(FILE *f, uint32_t val)
{
 switch (val)
  { case em_VM_INHERIT_NONE:  fprintf(f,"VM_INHERIT_NONE");  break;
    case em_VM_INHERIT_COPY:  fprintf(f,"VM_INHERIT_COPY");  break;
    case em_VM_INHERIT_SHARE: fprintf(f,"VM_INHERIT_SHARE"); break;
    default: fprintf(f,"%lld",(long long int)(int32_t)val); break;
  }
}

static void print_special_MLOCKALL(FILE *f, uint32_t val)
{
 static const BITTBL bits_MLOCKALL[]
  = { BIT(MCL_CURRENT),
      BIT(MCL_FUTURE),
      TBLEND() };

 print_special_bitmask(f,val,&bits_MLOCKALL[0],BM_PRINT0);
}

static void print_special_SOCKTYPE(FILE *f, uint32_t val)
{
 switch (val)
  { case em_SOCK_STREAM:    fprintf(f,"SOCK_STREAM");    break;
    case em_SOCK_DGRAM:     fprintf(f,"SOCK_DGRAM");     break;
    case em_SOCK_RAW:       fprintf(f,"SOCK_RAW");       break;
    case em_SOCK_RDM:       fprintf(f,"SOCK_RDM");       break;
    case em_SOCK_SEQPACKET: fprintf(f,"SOCK_SEQPACKET"); break;
    default: fprintf(f,"%lld",(long long int)(int32_t)val); break;
  }
}

static void print_special_NTPSTATE(FILE *f, uint32_t val)
{
 switch (val)
  { case em_TIME_OK:    fprintf(f,"TIME_OK");    break;
    case em_TIME_INS:   fprintf(f,"TIME_INS");   break;
    case em_TIME_DEL:   fprintf(f,"TIME_DEL");   break;
    case em_TIME_OOP:   fprintf(f,"TIME_OOP");   break;
    case em_TIME_WAIT:  fprintf(f,"TIME_WAIT");  break;
    case em_TIME_ERROR: fprintf(f,"TIME_ERROR"); break;
    default: fprintf(f,"%lld",(long long int)(int32_t)val); break;
  }
}

static void print_special_QUOTACTL(FILE *f, uint32_t val)
{
 fprintf(f,"QCMD(");
 switch (val & ~0xff)
  { case em_Q_QUOTAON:  fprintf(f,"Q_QUOTAON");  break;
    case em_Q_QUOTAOFF: fprintf(f,"Q_QUOTAOFF"); break;
    case em_Q_GETQUOTA: fprintf(f,"Q_GETQUOTA"); break;
    case em_Q_SETQUOTA: fprintf(f,"Q_SETQUOTA"); break;
    case em_Q_SETUSE:   fprintf(f,"Q_SETUSE");   break;
    case em_Q_SYNC:     fprintf(f,"Q_SYNC");     break;
    default: fprintf(f,"%#llx",(long long int)(int32_t)val); break;
  }
 fprintf(f,",");
 switch (val & 0xff)
  { case em_USRQUOTA: fprintf(f,"USRQUOTA"); break;
    case em_GRPQUOTA: fprintf(f,"GRPQUOTA"); break;
    default: fprintf(f,"%d",(int)(unsigned int)(val&0xff)); break;
  }
}

static void print_special_PRIOWHICH(FILE *f, uint32_t val)
{
 switch (val)
  { case em_PRIO_PROCESS: fprintf(f,"PRIO_PROCESS"); break;
    case em_PRIO_PGRP:    fprintf(f,"PRIO_PGRP");    break;
    case em_PRIO_USER:    fprintf(f,"PRIO_USER");    break;
    default: fprintf(f,"%lld",(long long int)(int32_t)val); break;
  }
}

static void print_special_SEMCONFIG(FILE *f, uint32_t val)
{
 switch (val)
  { case em_SEM_CONFIG_FREEZE: fprintf(f,"SEM_CONFIG_FREEZE"); break;
    case em_SEM_CONFIG_THAW:   fprintf(f,"SEM_CONFIG_THAW");   break;
    default: fprintf(f,"%lld",(long long int)(int32_t)val); break;
  }
}

static void print_special_SIGPROCMASK(FILE *f, uint32_t val)
{
 switch (val)
  { case em_SIG_BLOCK:   fprintf(f,"SIG_BLOCK");   break;
    case em_SIG_UNBLOCK: fprintf(f,"SIG_UNBLOCK"); break;
    case em_SIG_SETMASK: fprintf(f,"SIG_SETMASK"); break;
    default: fprintf(f,"%lld",(long long int)(int32_t)val); break;
  }
}

// The nested switches are basically a poor man's perfect hash...
static const char *print_special(FILE *f, const char *str, uint32_t val)
{
 int i;

 for (i=0;str[i]&&(str[i]!=')');i++) ;
 if (! str[i]) panic("unclosed ( in format: %s",str);
#define DO(name) do { if (! bcmp(str,#name,sizeof(#name)-1)) { print_special_##name(f,val); break <"done">; } } while (0)
 do <"done">
  { switch (i)
     { case 3:
	  DO(SIG);
	  break;
       case 4:
	  switch (str[0])
	   { case 'M': DO(MADV); break;
	     case 'O': DO(OPEN); break;
	     case 'W': DO(WAIT); break;
	   }
	  break;
       case 5:
	  switch (str[0]+str[2])
	   { case 'F'+'N': DO(FCNTL); break;
	     case 'F'+'O': DO(FLOCK); break;
	     case 'I'+'C': DO(IOCTL); break;
	     case 'L'+'E': DO(LSEEK); break;
	     case 'M'+'N': DO(MKNOD); break;
	     case 'M'+'U': DO(MOUNT); break;
	     case 'M'+'Y': DO(MSYNC); break;
	     case 'S'+'M': DO(SHMAT); break;
	   }
	  break;
       case 6:
#define D(a,b) (((a) * 0x100) + (b))
	  switch (D(str[1],str[3]))
	   { case D('C','E'): DO(ACCESS); break;
	     case D('E','C'): DO(SEMCTL); break;
	     case D('E','F'): DO(SEMFLG); break;
	     case D('E','O'): DO(REBOOT); break;
	     case D('F','S'): DO(NFSSVC); break;
	     case D('H','C'): DO(SHMCTL); break;
	     case D('H','F'): DO(SHMFLG); break;
	     case D('L','M'): DO(RLIMIT); break;
	     case D('M','L'): DO(MMFLAG); break;
	     case D('M','R'): DO(MMPROT); break;
	     case D('O','K'): DO(SOCKAF); break;
	     case D('P','K'): DO(IPCKEY); break;
	     case D('S','C'): DO(MSGCTL); break;
	     case D('S','G'): DO(MSGGET); break;
	     case D('S','R'): DO(MSGRCV); break;
	     case D('S','S'): DO(MSGSND); break;
	     case D('T','A'): DO(PTRACE); break;
	     case D('T','F'): DO(KTRFAC); break;
	     case D('T','M'): DO(ITIMER); break;
	     case D('T','O'): DO(KTROPS); break;
	     case D('U','A'): DO(RUSAGE); break;
	   }
#undef D
	  break;
       case 7:
	  switch (str[2])
	   { case 'A': DO(SWAPCTL); break;
	     case 'C': DO(RECVMSG); break;
	     case 'F': DO(CHFLAGS); break;
	     case 'M': DO(UNMOUNT); break;
	     case 'N': DO(SENDMSG); break;
	     case 'O': DO(CLOCKID); break;
	     case 'T': DO(MNTWAIT); break;
	   }
	  break;
       case 8:
	  switch (str[1])
	   { case 'A': DO(PATHCONF); break;
	     case 'H': DO(SHUTDOWN); break;
	     case 'I': DO(MINHERIT); break;
	     case 'L': DO(MLOCKALL); break;
	     case 'O': DO(SOCKTYPE); break;
	     case 'T': DO(NTPSTATE); break;
	     case 'U': DO(QUOTACTL); break;
	   }
	  break;
       case 9:
	  switch (str[0])
	   { case 'P': DO(PRIOWHICH); break;
	     case 'S': DO(SEMCONFIG); break;
	   }
	  break;
       case 11:
	  DO(SIGPROCMASK);
	  break;
     }
    panic("unrecognized special (%.*s) in format",i,str);
  } while (0);
 return(str+i+1);
}

/*
 * Print syscall argument/return values.  f is the FILE * to send the
 *  resulting text to.  str is the string describing the values, as
 *  described in the comment on struct sysent.  vals is the SCARGS
 *  holding (and maybe pointing to) the values to print.
 *
 * We use nomemacc to ensure TRC_MEM doesn't see any memory accesses we
 *  might do.
 */
void print_syscall_values(FILE *f, const char *str, SCARGS *vals)
{
 int vx;
 uint32_t v;

 if (! str) return;
 vx = 0;
 nomemacc ++;
 while <"loop"> (*str)
  { if (vx) fprintf(f,", ");
    v = scarg(vals,vx++);
    if (simple_format(f,*str,v))
     { str ++;
     }
    else
     { switch (*str++)
	{ case 'O':
	     if (scarg(vals,1) & em_O_CREAT)
	      { fprintf(f,"%#lo",(ULI)v);
	      }
	     else
	      { fprintf(f,"...");
	      }
	     break;
	  case 'D':
	      { uint64_t v64;
		v64 = v;
		v64 = (v64 << 32) | scarg(vals,vx++);
		fprintf(f,"%lld",(ULLI)(int64_t)v64);
	      }
	     break;
	  case 'm':
	      { uint32_t v2;
		VAL32 elt;
		int first;
		v2 = scarg(vals,vx++);
		fprintf(f,"%08lx/%ld=",(ULI)v,(ULI)v2);
		first = 1;
		while (v2)
		 { elt = mem_get_4(v);
		   v += 4;
		   v2 --;
		   if (! first) putc('.',f);
		   if (elt.d == 0xffffffff)
		    { fprintf(f,"%ld",(LI)elt.v);
		    }
		   else
		    { print_undefined(f,8,elt.v,elt.d);
		    }
		   first = 0;
		 }
	      }
	     break;
	  case '(':
	     str = print_special(f,str,v);
	     break;
	  default:
	     panic("print_syscall_values: invalid key char %02x",(unsigned char)str[-1]);
	     break;
	}
     }
  }
 nomemacc --;
}

/*
 * Print out an ioctl command using the _IO* macros.
 */
void print_decoded_ioctl(FILE *to, uint32_t ioc)
{
 switch (ioc & em_IOC_DIRMASK)
  { case em_IOC_VOID:
       if (em_IOC_LEN(ioc) == 0)
	{ fprintf(to,"_IO('%c',%d)",em_IOC_GROUP(ioc),em_IOC_NUM(ioc));
	}
       else
	{ fprintf(to,"_IOC(IOC_VOID,'%c',%d,%d)",em_IOC_GROUP(ioc),em_IOC_NUM(ioc),em_IOC_LEN(ioc));
	}
       break;
    case em_IOC_OUT:
       fprintf(to,"_IOR('%c',%d,%d)",em_IOC_GROUP(ioc),em_IOC_NUM(ioc),em_IOC_LEN(ioc));
       break;
    case em_IOC_IN:
       fprintf(to,"_IOW('%c',%d,%d)",em_IOC_GROUP(ioc),em_IOC_NUM(ioc),em_IOC_LEN(ioc));
       break;
    case em_IOC_INOUT:
       fprintf(to,"_IOWR('%c',%d,%d)",em_IOC_GROUP(ioc),em_IOC_NUM(ioc),em_IOC_LEN(ioc));
       break;
    default:
       fprintf(to,"unknown");
       break;
  }
}