Changeset 7258c6a in buchla-68k for rom


Ignore:
Timestamp:
07/09/2017 04:45:34 PM (7 years ago)
Author:
Thomas Lopatic <thomas@…>
Branches:
master
Children:
8618599
Parents:
0292fbb
Message:

Use standard integer types.

Location:
rom
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • rom/booter.c

    r0292fbb r7258c6a  
    1515#include "biosdefs.h"
    1616
    17 extern  FILE    *fopenb(char *name, char *mode);
    18 extern  int     fclose(FILE *ptr);
    19 extern  int     fread(char *buffer, unsigned size, int number, FILE *stream);
    20 extern  int     flread(char *buff, long len, FILE *fp);
    21 extern  long    getl(FILE *stream);
     17extern  FILE    *fopenb(int8_t *name, int8_t *mode);
     18extern  int16_t fclose(FILE *ptr);
     19extern  int16_t fread(int8_t *buffer, uint16_t size, int16_t number, FILE *stream);
     20extern  int16_t flread(int8_t *buff, int32_t len, FILE *fp);
     21extern  int32_t getl(FILE *stream);
    2222
    2323#if     PRINTIT
    2424extern  struct  fcb     *SnapFCB(struct fcb *fcp);
    25 extern  int     ClusMap(struct fcb *fcp);
     25extern  int16_t ClusMap(struct fcb *fcp);
    2626#endif
    2727
    … …  
    3030struct  EXFILE B_fhdr;  /* executable file header */
    3131
    32 long    B_txt_o,        /* test origin from file header */
     32int32_t B_txt_o,        /* test origin from file header */
    3333        B_dat_o,        /* data origin from file header */
    3434        B_bss_o,        /* bss origin from file header */
    … …  
    4040        B_chk;          /* checksum */
    4141
    42 char    *B_buf_a;       /* boot load address */
     42int8_t  *B_buf_a;       /* boot load address */
    4343
    44 short   B_log_s;        /* boot log switch */
    45 short   B_dbg_s;        /* boot debug switch */
     44int16_t B_log_s;        /* boot log switch */
     45int16_t B_dbg_s;        /* boot debug switch */
    4646
    4747/*
    … …  
    5656*/
    5757
    58 short booter(char *fn, long textadr)
     58int16_t booter(int8_t *fn, int32_t textadr)
    5959{
    60         register long i, bgnbss, endbss;
    61         register char *cp;
     60        register int32_t i, bgnbss, endbss;
     61        register int8_t *cp;
    6262#if     PRINTIT
    6363        register struct fcb *fcp;

  • rom/romp.c

    r0292fbb r7258c6a  
    4242#include "vsddvars.h"
    4343#endif
    44 
    45 typedef unsigned short  UWORD16;        /* unsigned 16 bit word */
    4644
    4745/*
    … …  
    122120*/
    123121
    124 extern  unsigned        setipl(unsigned arg);
     122extern  uint16_t        setipl(uint16_t arg);
    125123
    126124extern  void    rjumpto(void *addr);
    127125extern  void    halt(void);
    128 extern  int     getln(int unit, int nb, char *buf);
     126extern  int16_t getln(int16_t unit, int16_t nb, int8_t *buf);
    129127extern  void    sjumpto(void *addr, void *stack);
    130128extern  void    trap15(void);
    … …  
    133131#if     ON_B700
    134132extern  void    hdvini(void);
    135 extern  short   booter(char *fn, long textadr);
    136 extern  void    vsndpal(short pp[16][3]);
     133extern  int16_t booter(int8_t *fn, int32_t textadr);
     134extern  void    vsndpal(int16_t pp[16][3]);
    137135#endif
    138136
    139137/* external variables */
    140138
    141 extern  short   wzcrsh, *crshpc, *crshsp, *crshus, crshst[16];
     139extern  int16_t wzcrsh, *crshpc, *crshsp, *crshus, crshst[16];
    142140
    143141#if     ON_B700
    144 extern  short   B_log_s;
    145 extern  short   B_dbg_s;
    146 extern  char    *B_buf_a;
    147 extern  int     _bpbin;
    148 extern  short   dfltpal[16][3];
     142extern  int16_t B_log_s;
     143extern  int16_t B_dbg_s;
     144extern  int8_t  *B_buf_a;
     145extern  int16_t _bpbin;
     146extern  int16_t dfltpal[16][3];
    149147#endif
    150148
    151 extern  UWORD16 crshsr;
    152 extern  long    crshrg[16];
    153 extern  char    crshvc[4];
     149extern  uint16_t        crshsr;
     150extern  int32_t crshrg[16];
     151extern  int8_t  crshvc[4];
    154152
    155153/* forward references */
    156154
    157 int     cp_dump(void);
    158 int     cp_fill(void);
    159 int     cp_copy(void);
    160 int     cp_null(void);
    161 int     cp_ilev(void);
    162 int     cp_ldmp(void);
    163 int     cp_go(void);
    164 int     cp_read(void);
    165 int     cp_mset(void);
    166 int     cp_rset(void);
    167 int     cp_wset(void);
    168 int     cp_mtst(void);
    169 int     cp_wdmp(void);
    170 int     cp_wfil(void);
    171 int     cp_vrst(void);
    172 int     cp_monc(void);
    173 int     cp_mons(void);
    174 int     cp_monl(void);
    175 int     cp_chek(void);
     155int16_t cp_dump(void);
     156int16_t cp_fill(void);
     157int16_t cp_copy(void);
     158int16_t cp_null(void);
     159int16_t cp_ilev(void);
     160int16_t cp_ldmp(void);
     161int16_t cp_go(void);
     162int16_t cp_read(void);
     163int16_t cp_mset(void);
     164int16_t cp_rset(void);
     165int16_t cp_wset(void);
     166int16_t cp_mtst(void);
     167int16_t cp_wdmp(void);
     168int16_t cp_wfil(void);
     169int16_t cp_vrst(void);
     170int16_t cp_monc(void);
     171int16_t cp_mons(void);
     172int16_t cp_monl(void);
     173int16_t cp_chek(void);
    176174
    177175#if     ON_B700
    178 int     cx_dini(void);
    179 int     cx_mlod(void);
    180 int     cp_boot(void);
    181 int     cx_boot(void);
    182 int     cx_adsp(void);
     176int16_t cx_dini(void);
     177int16_t cx_mlod(void);
     178int16_t cp_boot(void);
     179int16_t cx_boot(void);
     180int16_t cx_adsp(void);
    183181#endif
    184182
    185 int     cx_dump(void);
    186 int     cx_fill(void);
    187 int     cx_copy(void);
    188 int     cx_rset(void);
    189 int     cx_load(void);
    190 int     cx_go(void);
    191 int     cx_read(void);
    192 int     cx_help(void);
     183int16_t cx_dump(void);
     184int16_t cx_fill(void);
     185int16_t cx_copy(void);
     186int16_t cx_rset(void);
     187int16_t cx_load(void);
     188int16_t cx_go(void);
     189int16_t cx_read(void);
     190int16_t cx_help(void);
    193191void    cx_exit(void);
    194 int     cx_writ(void);
    195 int     cx_regs(void);
    196 int     cx_mset(void);
    197 int     cx_bpb(void);
    198 int     cx_wset(void);
    199 int     cx_wdmp(void);
    200 int     cx_wfil(void);
     192int16_t cx_writ(void);
     193int16_t cx_regs(void);
     194int16_t cx_mset(void);
     195int16_t cx_bpb(void);
     196int16_t cx_wset(void);
     197int16_t cx_wdmp(void);
     198int16_t cx_wfil(void);
    201199void    cx_rest(void);
    202 int     cx_vrst(void);
    203 int     cx_vreg(void);
    204 int     cx_mon(void);
    205 int     cx_next(void);
    206 int     cx_ilev(void);
    207 int     do_srec(char *line);
    208 int     cx_crsh(void);
    209 int     cx_mtst(void);
     200int16_t cx_vrst(void);
     201int16_t cx_vreg(void);
     202int16_t cx_mon(void);
     203int16_t cx_next(void);
     204int16_t cx_ilev(void);
     205int16_t do_srec(int8_t *line);
     206int16_t cx_crsh(void);
     207int16_t cx_mtst(void);
    210208void    cx_zap(void);
    211 int     cx_ldmp(void);
    212 int     cx_omap(void);
    213 int     cx_chek(void);
    214 
    215 char    hs_mtst[];
     209int16_t cx_ldmp(void);
     210int16_t cx_omap(void);
     211int16_t cx_chek(void);
     212
     213int8_t  hs_mtst[];
    216214
    217215/*
    … …  
    247245struct cmdent {                 /* command table entry */
    248246
    249         char    *cname;         /* command name pointer */
    250         int     (*cp)();        /* command parser function pointer */
    251         int     (*cx)();        /* command execution function pointer */
    252         char    *hstr;          /* help string pointer */
     247        int8_t  *cname;         /* command name pointer */
     248        int16_t (*cp)();        /* command parser function pointer */
     249        int16_t (*cx)();        /* command execution function pointer */
     250        int8_t  *hstr;          /* help string pointer */
    253251};
    254252
    … …  
    316314*/
    317315
    318 char    ahex[] = "0123456789abcdefABCDEF";
    319 
    320 char    *rlist[] = {            /* register name list */
     316int8_t  ahex[] = "0123456789abcdefABCDEF";
     317
     318int8_t  *rlist[] = {            /* register name list */
    321319
    322320        "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
    323321        "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
    324322        "sr", "pc", "sp",
    325         (char *)0
     323        (int8_t *)0
    326324};
    327325
    328 char    *vrlist[] = {           /* video register name list */
     326int8_t  *vrlist[] = {           /* video register name list */
    329327
    330328        "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
    331329        "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
    332330        "h0", "h1", "h2", "h3", "v0", "v1", "v2", "v3",
    333         (char *)0
     331        (int8_t *)0
    334332};
    335333
    336334#if     ON_B700
    337 int     sigadr[] = {            /* display offsets for signals */
     335int16_t sigadr[] = {            /* display offsets for signals */
    338336
    339337         0,  0,  0,  0,  0,   1,  1,  1,  1,  1,                /* keys      */
    … …  
    366364*/
    367365
    368 char    argsep;         /* argument separator */
    369 
    370 char    *aptr,          /* argument pointer */
     366int8_t  argsep;         /* argument separator */
     367
     368int8_t  *aptr,          /* argument pointer */
    371369        *monptr,        /* monitored variable pointer */
    372370        *d_cur,         /* dump current from */
    … …  
    379377        *sptr;          /* string scan pointer */
    380378
    381 short   argln,          /* argument length */
     379int16_t argln,          /* argument length */
    382380        b0flag,         /* breakpoint 0 flag */
    383381        b1flag,         /* breakpoint 1 flag */
    … …  
    400398
    401399#if     ON_B700
    402 short   asig,           /* signal number */
     400int16_t asig,           /* signal number */
    403401        aval,           /* signal value */
    404402        astat,          /* signal status */
    … …  
    407405        ledcntr;        /* LED scan counter */
    408406
    409 short   sigtab[128][2]; /* signal table */
    410 
    411 long    afi,            /* analog FIFO input */
     407int16_t sigtab[128][2]; /* signal table */
     408
     409int32_t afi,            /* analog FIFO input */
    412410        ftimer;         /* analog FIFO clear timer */
    413411
    414 unsigned        baron,          /* bar 'on' color */
     412uint16_t        baron,          /* bar 'on' color */
    415413                baroff,         /* bar 'off' color */
    416414                swon,           /* switch 'on' color */
    … …  
    419417#endif
    420418
    421 UWORD16 *tba0,          /* breakpoint 0 temporary */
     419uint16_t        *tba0,          /* breakpoint 0 temporary */
    422420        *tba1;          /* breakpoint 1 temporary */
    423421
    424 UWORD16 p_bv0,          /* breakpoint 0 value */
     422uint16_t        p_bv0,          /* breakpoint 0 value */
    425423        p_bv1;          /* breakpoint 1 value */
    426424
    427 UWORD16 *p_ba0,         /* breakpoint 0 address */
     425uint16_t        *p_ba0,         /* breakpoint 0 address */
    428426        *p_ba1;         /* breakpoint 1 address */
    429427
    430428jmp_buf restart;        /* jmp environment */
    431429
    432 long    p_len,          /* length parameter */
     430int32_t p_len,          /* length parameter */
    433431        p_value,        /* value parameter */
    434432        p_width;        /* width parameter */
    … …  
    436434struct  regs    *regptr;        /* register save area pointer */
    437435
    438 char    argstr[MAXARGLN+1],     /* argument string */
     436int8_t  argstr[MAXARGLN+1],     /* argument string */
    439437        cmdline[MAXCMDLN+1],    /* command line */
    440438        bfname[MAXFNLN+1],      /* boot file name */
    … …  
    475473*/
    476474
    477 int cx_mlod(void)
    478 {
    479         register short i;
     475int16_t cx_mlod(void)
     476{
     477        register int16_t i;
    480478
    481479        B_log_s = TRUE;
    … …  
    496494
    497495                for (i = 0; i < 7; i++)         /* clear a0..a6 */
    498                         regptr->a_reg[i] = (char *)0L;
     496                        regptr->a_reg[i] = (int8_t *)0L;
    499497
    500498                regptr->a_reg[7] = ISTACK;      /* setup initial stack */
    … …  
    517515*/
    518516
    519 int cp_boot(void)
    520 {
    521         register int i;
    522         register char endc;
     517int16_t cp_boot(void)
     518{
     519        register int16_t i;
     520        register int8_t endc;
    523521
    524522        redo = FALSE;
    … …  
    560558*/
    561559
    562 int cx_boot(void)
    563 {
    564         register short i;
     560int16_t cx_boot(void)
     561{
     562        register int16_t i;
    565563
    566564        B_log_s = TRUE;
    … …  
    580578
    581579                for (i = 0; i < 7; i++)         /* clear a0..a6 */
    582                         regptr->a_reg[i] = (char *)0L;
     580                        regptr->a_reg[i] = (int8_t *)0L;
    583581
    584582                regptr->a_reg[7] = ISTACK;      /* setup initial stack */
    … …  
    601599*/
    602600
    603 void dobar(int nb, int bv)
    604 {
    605         register unsigned *bp;
    606         register int i;
     601void dobar(int16_t nb, int16_t bv)
     602{
     603        register uint16_t *bp;
     604        register int16_t i;
    607605
    608606        if ((nb LT 1) OR (nb GT 82))
    … …  
    610608
    611609        --nb;
    612         bp = obj0 + BARBASE + (long)(sigadr[nb] + MARGIN + nb);
     610        bp = obj0 + BARBASE + (int32_t)(sigadr[nb] + MARGIN + nb);
    613611
    614612        for (i = 127; i GE 0; --i) {
    … …  
    641639*/
    642640
    643 void dosw(int nb, int sv)
    644 {
    645         register unsigned *bp;
    646         register int i, j;
     641void dosw(int16_t nb, int16_t sv)
     642{
     643        register uint16_t *bp;
     644        register int16_t i, j;
    647645
    648646        if ((nb LT 1) OR (nb GT 82))
    … …  
    650648
    651649        --nb;
    652         bp = obj0 + SWBASE + (long)(sigadr[nb] + MARGIN + nb);
     650        bp = obj0 + SWBASE + (int32_t)(sigadr[nb] + MARGIN + nb);
    653651
    654652        if (sv)
    … …  
    674672*/
    675673
    676 unsigned exp_c(unsigned c)
     674uint16_t exp_c(uint16_t c)
    677675{
    678676        c &= 0x000F;
    … …  
    693691*/
    694692
    695 int cx_adsp(void)
    696 {
    697         register int xasig, xastat, xaval;
    698         register long xafi;
    699         register long lc;
    700         register unsigned *bp;
    701         int     i, j, k;
    702         int     oldi;
     693int16_t cx_adsp(void)
     694{
     695        register int16_t xasig, xastat, xaval;
     696        register int32_t xafi;
     697        register int32_t lc;
     698        register uint16_t *bp;
     699        int16_t i, j, k;
     700        int16_t oldi;
    703701
    704702        memsetw(sigtab, 0, sizeof sigtab / 2);
    … …  
    831829*/
    832830
    833 int waitcr(void)
    834 {
    835         char    c;
     831int16_t waitcr(void)
     832{
     833        int8_t  c;
    836834
    837835        BIOS(B_PUTC, CON_DEV, '\007');
    … …  
    856854*/
    857855
    858 int xdtoi(int c)
    859 {
    860         register int i;
    861         register char *ap = &ahex[0];
     856int16_t xdtoi(int16_t c)
     857{
     858        register int16_t i;
     859        register int8_t *ap = &ahex[0];
    862860
    863861        for (i = 0; i < 22; i++)
    … …  
    881879*/
    882880
    883 int getcmd(void)
    884 {
    885         register int c;
     881int16_t getcmd(void)
     882{
     883        register int16_t c;
    886884
    887885        sptr = cmdline;
    … …  
    944942*/
    945943
    946 int getarg(void)
    947 {
    948         register int c;
     944int16_t getarg(void)
     945{
     946        register int16_t c;
    949947
    950948        argln = 0;
    … …  
    10091007*/
    10101008
    1011 int getlong(long *var)
    1012 {
    1013         register long   temp = 0L;
    1014         register int    csw = FALSE,
     1009int16_t getlong(int32_t *var)
     1010{
     1011        register int32_t        temp = 0L;
     1012        register int16_t        csw = FALSE,
    10151013                        c;
    10161014
    … …  
    10501048*/
    10511049
    1052 int setvar(long *var, long deflt)
    1053 {
    1054         int rc;
    1055         long temp;
     1050int16_t setvar(int32_t *var, int32_t deflt)
     1051{
     1052        int16_t rc;
     1053        int32_t temp;
    10561054
    10571055        *var = deflt;
    … …  
    11041102*/
    11051103
    1106 void putn(long num, int cw, int unit)
    1107 {
    1108         register int    d;
     1104void putn(int32_t num, int16_t cw, int16_t unit)
     1105{
     1106        register int16_t        d;
    11091107
    11101108        if (!cw)
    … …  
    11301128*/
    11311129
    1132 void puthn(long num, int cw, int unit)
    1133 {
    1134         register int    d;
     1130void puthn(int32_t num, int16_t cw, int16_t unit)
     1131{
     1132        register int16_t        d;
    11351133
    11361134        if (!cw)
    … …  
    11591157*/
    11601158
    1161 int ddump(char *loc, char *lastloc, int nwide, int unit)
     1159int16_t ddump(int8_t *loc, int8_t *lastloc, int16_t nwide, int16_t unit)
    11621160{
    11631161        while (nwide--) {
    11641162
    1165                 puthn((long)(0xFF & *loc), 2, unit);
     1163                puthn((int32_t)(0xFF & *loc), 2, unit);
    11661164                BIOS(B_PUTC, unit, ' ');
    11671165
    … …  
    11951193*/
    11961194
    1197 void padr(long adr, int unit)
     1195void padr(int32_t adr, int16_t unit)
    11981196{
    11991197        puthn(adr, 8, unit);
    … …  
    12131211*/
    12141212
    1215 int dtext(char *loc, char *lastloc, int nwide, int unit)
    1216 {
    1217         register int c;
     1213int16_t dtext(int8_t *loc, int8_t *lastloc, int16_t nwide, int16_t unit)
     1214{
     1215        register int16_t c;
    12181216
    12191217        BIOS(B_PUTC, unit, ' ');
    … …  
    12591257*/
    12601258
    1261 int cp_mset(void)
     1259int16_t cp_mset(void)
    12621260{
    12631261        redo = FALSE;
    … …  
    12811279*/
    12821280
    1283 int cx_mset(void)
     1281int16_t cx_mset(void)
    12841282{
    12851283        while (TRUE) {
    … …  
    13081306*/
    13091307
    1310 int cp_wset(void)
     1308int16_t cp_wset(void)
    13111309{
    13121310        redo = FALSE;
    … …  
    13211319                return(FALSE);
    13221320
    1323         if ((long)p_from & 1L)
     1321        if ((int32_t)p_from & 1L)
    13241322                return(FALSE);
    13251323
    … …  
    13371335*/
    13381336
    1339 int cx_wset(void)
    1340 {
    1341         UWORD16 *p_uint;
    1342 
    1343         p_uint = (UWORD16 *)p_from;
     1337int16_t cx_wset(void)
     1338{
     1339        uint16_t        *p_uint;
     1340
     1341        p_uint = (uint16_t *)p_from;
    13441342
    13451343        while (TRUE) {
    … …  
    13691367*/
    13701368
    1371 int cp_mtst(void)
     1369int16_t cp_mtst(void)
    13721370{
    13731371        inext = ilast;
    … …  
    13751373        if (argsep EQ A_CR OR argsep EQ '\0') {
    13761374
    1377                 p_from = (char *)0x00000008L;
    1378                 p_to   = (char *)USER_RAM - 2L;
     1375                p_from = (int8_t *)0x00000008L;
     1376                p_to   = (int8_t *)USER_RAM - 2L;
    13791377                return(TRUE);
    13801378        }
    … …  
    13911389                        return(FALSE);
    13921390
    1393         if ((long)p_from & 1L)
     1391        if ((int32_t)p_from & 1L)
    13941392                return(FALSE);
    13951393
    1396         if ((long)p_to & 1L)
     1394        if ((int32_t)p_to & 1L)
    13971395                return(FALSE);
    13981396
    … …  
    14131411*/
    14141412
    1415 int cx_mtst(void)
    1416 {
    1417         register short  mask, was, *loc, *eloc, *oldloc;
     1413int16_t cx_mtst(void)
     1414{
     1415        register int16_t        mask, was, *loc, *eloc, *oldloc;
    14181416
    14191417        mask = 0x0001;
    1420         loc = (short *)p_from;
    1421         eloc = (short *)p_to;
     1418        loc = (int16_t *)p_from;
     1419        eloc = (int16_t *)p_to;
    14221420        oldloc = loc;
    14231421
    1424         if (p_from LT (char *)USER_RAM)
     1422        if (p_from LT (int8_t *)USER_RAM)
    14251423                setipl(7);
    14261424
    … …  
    14321430
    14331431                        if (mask NE (was = *loc))
    1434                                 if (p_from LT (char *)USER_RAM)
     1432                                if (p_from LT (int8_t *)USER_RAM)
    14351433                                        halt();
    14361434                                else
    … …  
    14411439
    14421440                        if (~mask NE (was = *loc))
    1443                                 if (p_from LT (char *)USER_RAM)
     1441                                if (p_from LT (int8_t *)USER_RAM)
    14441442                                        halt();
    14451443                                else
    … …  
    14551453        } while (loc LE eloc);
    14561454
    1457         if (oldloc LT (short *)USER_RAM)
    1458                 rjumpto((long)ROMADDR);
     1455        if (oldloc LT (int16_t *)USER_RAM)
     1456                rjumpto((int32_t)ROMADDR);
    14591457
    14601458        return(TRUE);
    … …  
    14711469*/
    14721470
    1473 int cp_go(void)
     1471int16_t cp_go(void)
    14741472{
    14751473        redo = FALSE;
    … …  
    14831481                        return(FALSE);
    14841482
    1485                 if (1L & (long)p_goto)
     1483                if (1L & (int32_t)p_goto)
    14861484                        return(FALSE);
    14871485
    … …  
    14951493                        return(FALSE);
    14961494
    1497                 if (1L & (long)tba0)
     1495                if (1L & (int32_t)tba0)
    14981496                        return(FALSE);
    14991497
    … …  
    15061504                        return(FALSE);
    15071505
    1508                 if (1L & (long)tba1)
     1506                if (1L & (int32_t)tba1)
    15091507                        return(FALSE);
    15101508
    … …  
    15271525*/
    15281526
    1529 int cx_dini(void)
     1527int16_t cx_dini(void)
    15301528{
    15311529        redo = TRUE;
    … …  
    15441542void cx_zap(void)
    15451543{
    1546         register short *p, *q;
    1547 
    1548         p = (short *)USER_RAM;
    1549         q = (short *)RAM_TOP;
     1544        register int16_t *p, *q;
     1545
     1546        p = (int16_t *)USER_RAM;
     1547        q = (int16_t *)RAM_TOP;
    15501548
    15511549        setipl(7);
    … …  
    15671565*/
    15681566
    1569 int cx_omap(void)
    1570 {
    1571         register short i, width, xloc;
     1567int16_t cx_omap(void)
     1568{
     1569        register int16_t i, width, xloc;
    15721570
    15731571        printf("Pr B/C Locn      Wd Xloc Flags\r\n");
    … …  
    15861584
    15871585                printf("$%08lX %2d %4d ",
    1588                         ((long)v_odtab[i][2] << 1), width, xloc);
     1586                        ((int32_t)v_odtab[i][2] << 1), width, xloc);
    15891587
    15901588                printf("$%04X\r\n", v_odtab[i][0]);
    … …  
    16041602*/
    16051603
    1606 int cx_help(void)
    1607 {
    1608         int     i, j;
     1604int16_t cx_help(void)
     1605{
     1606        int16_t i, j;
    16091607
    16101608        j = 0;
    … …  
    16431641*/
    16441642
    1645 int cx_bpb(void)
     1643int16_t cx_bpb(void)
    16461644{
    16471645        register struct bpb *bpp;
    … …  
    16561654                writeln(cmdunit, "\r\n\nBPB values:\r\n");
    16571655                writeln(cmdunit, "\r\n   recsiz   ");
    1658                 putn((long)bpp->recsiz, 5, cmdunit);
     1656                putn((int32_t)bpp->recsiz, 5, cmdunit);
    16591657                writeln(cmdunit, "\r\n   clsiz     ");
    1660                 putn((long)bpp->clsiz, 4, cmdunit);
     1658                putn((int32_t)bpp->clsiz, 4, cmdunit);
    16611659                writeln(cmdunit, "\r\n   clsizb   ");
    1662                 putn((long)bpp->clsizb, 5, cmdunit);
     1660                putn((int32_t)bpp->clsizb, 5, cmdunit);
    16631661                writeln(cmdunit, "\r\n   rdlen     ");
    1664                 putn((long)bpp->rdlen, 4, cmdunit);
     1662                putn((int32_t)bpp->rdlen, 4, cmdunit);
    16651663                writeln(cmdunit, "\r\n   fsiz      ");
    1666                 putn((long)bpp->fsiz, 4, cmdunit);
     1664                putn((int32_t)bpp->fsiz, 4, cmdunit);
    16671665                writeln(cmdunit, "\r\n   fatrec   ");
    1668                 putn((long)bpp->fatrec, 5, cmdunit);
     1666                putn((int32_t)bpp->fatrec, 5, cmdunit);
    16691667                writeln(cmdunit, "\r\n   datrec   ");
    1670                 putn((long)bpp->datrec, 5, cmdunit);
     1668                putn((int32_t)bpp->datrec, 5, cmdunit);
    16711669                writeln(cmdunit, "\r\n   numcl    ");
    1672                 putn((long)bpp->numcl, 5, cmdunit);
     1670                putn((int32_t)bpp->numcl, 5, cmdunit);
    16731671                writeln(cmdunit, "\r\n   bflags    ");
    1674                 puthn((long)bpp->bflags, 4, cmdunit);
     1672                puthn((int32_t)bpp->bflags, 4, cmdunit);
    16751673                writeln(cmdunit, "\r\n   ntracks   ");
    1676                 putn((long)bpp->ntracks, 4, cmdunit);
     1674                putn((int32_t)bpp->ntracks, 4, cmdunit);
    16771675                writeln(cmdunit, "\r\n   nsides    ");
    1678                 putn((long)bpp->nsides, 4, cmdunit);
     1676                putn((int32_t)bpp->nsides, 4, cmdunit);
    16791677                writeln(cmdunit, "\r\n   sec/cyl  ");
    1680                 putn((long)bpp->dspc, 5, cmdunit);
     1678                putn((int32_t)bpp->dspc, 5, cmdunit);
    16811679                writeln(cmdunit, "\r\n   sec/trk  ");
    1682                 putn((long)bpp->dspt, 5, cmdunit);
     1680                putn((int32_t)bpp->dspt, 5, cmdunit);
    16831681                writeln(cmdunit, "\r\n   hidden    ");
    1684                 putn((long)bpp->hidden, 4, cmdunit);
     1682                putn((int32_t)bpp->hidden, 4, cmdunit);
    16851683                writeln(cmdunit, "\r\n\n");
    16861684                return(TRUE);
    … …  
    16981696*/
    16991697
    1700 int cx_go(void)
     1698int16_t cx_go(void)
    17011699{
    17021700        redo = FALSE;
    … …  
    17111709                if (p_ba0) {
    17121710
    1713                         if (*p_ba0 NE (UWORD16)BPINST) {
     1711                        if (*p_ba0 NE (uint16_t)BPINST) {
    17141712
    17151713                                writeln(cmdunit, "\r\n\n** Breakpoint 0 at ");
    1716                                 puthn((long)p_ba0, 8, cmdunit);
     1714                                puthn((int32_t)p_ba0, 8, cmdunit);
    17171715                                writeln(cmdunit, " was ");
    1718                                 puthn(0xFFFFL & (long)(*p_ba0), 4, cmdunit);
     1716                                puthn(0xFFFFL & (int32_t)(*p_ba0), 4, cmdunit);
    17191717                                writeln(cmdunit, " instead of ");
    1720                                 puthn(0xFFFFL & (long)BPINST, 4, cmdunit);
     1718                                puthn(0xFFFFL & (int32_t)BPINST, 4, cmdunit);
    17211719                                writeln(cmdunit, " **\r\n\n");
    17221720                        }
    … …  
    17271725                p_ba0 = tba0;
    17281726                p_bv0 = *p_ba0;
    1729                 *p_ba0 = (UWORD16)BPINST;
     1727                *p_ba0 = (uint16_t)BPINST;
    17301728        }
    17311729
    … …  
    17381736                if (p_ba1) {
    17391737
    1740                         if (*p_ba1 NE (UWORD16)BPINST) {
     1738                        if (*p_ba1 NE (uint16_t)BPINST) {
    17411739
    17421740                                writeln(cmdunit, "\r\n\n** Breakpoint 1 at ");
    1743                                 puthn((long)p_ba1, 8, cmdunit);
     1741                                puthn((int32_t)p_ba1, 8, cmdunit);
    17441742                                writeln(cmdunit, " was ");
    1745                                 puthn(0xFFFFL & (long)(*p_ba1), 4, cmdunit);
     1743                                puthn(0xFFFFL & (int32_t)(*p_ba1), 4, cmdunit);
    17461744                                writeln(cmdunit, " instead of ");
    1747                                 puthn(0xFFFFL & (long)BPINST, 4, cmdunit);
     1745                                puthn(0xFFFFL & (int32_t)BPINST, 4, cmdunit);
    17481746                                writeln(cmdunit, " **\r\n\n");
    17491747                        }
    … …  
    17541752                p_ba1 = tba1;
    17551753                p_bv1 = *p_ba1;
    1756                 *p_ba1 = (UWORD16)BPINST;
     1754                *p_ba1 = (uint16_t)BPINST;
    17571755        }
    17581756
    … …  
    17701768*/
    17711769
    1772 int cp_dump(void)
     1770int16_t cp_dump(void)
    17731771{
    17741772        inext = ilast;
    … …  
    18311829*/
    18321830
    1833 int cp_fill(void)
     1831int16_t cp_fill(void)
    18341832{
    18351833        redo = FALSE;
    … …  
    18631861*/
    18641862
    1865 int cp_wfil(void)
     1863int16_t cp_wfil(void)
    18661864{
    18671865        redo = FALSE;
    … …  
    18791877                        return(FALSE);
    18801878
    1881         if ((long)p_from & 1L)
     1879        if ((int32_t)p_from & 1L)
    18821880                return(FALSE);
    18831881
    … …  
    18981896*/
    18991897
    1900 int cp_copy(void)
     1898int16_t cp_copy(void)
    19011899{
    19021900        redo = FALSE;
    … …  
    19261924*/
    19271925
    1928 int cp_chek(void)
     1926int16_t cp_chek(void)
    19291927{
    19301928        redo = FALSE;
    … …  
    19511949*/
    19521950
    1953 int cp_read(void)
     1951int16_t cp_read(void)
    19541952{
    19551953        redo = FALSE;
    … …  
    19701968                return(FALSE);
    19711969
    1972         if ((~0xFFFFL) & (long)p_from)
     1970        if ((~0xFFFFL) & (int32_t)p_from)
    19731971                return(FALSE);
    19741972
    … …  
    19821980*/
    19831981
    1984 int cp_null(void)
     1982int16_t cp_null(void)
    19851983{
    19861984        return(TRUE);
    … …  
    19971995*/
    19981996
    1999 int cp_rset(void)
    2000 {
    2001         int     rc;
     1997int16_t cp_rset(void)
     1998{
     1999        int16_t rc;
    20022000
    20032001        rc = 0;
    … …  
    20312029*/
    20322030
    2033 int cx_chek(void)
    2034 {
    2035         register long csum;
    2036         register char *cp;
     2031int16_t cx_chek(void)
     2032{
     2033        register int32_t csum;
     2034        register int8_t *cp;
    20372035
    20382036        redo = FALSE;
    … …  
    20572055*/
    20582056
    2059 int cx_rset(void)
     2057int16_t cx_rset(void)
    20602058{
    20612059        redo = FALSE;
    … …  
    20722070        if (rnum < 17) {        /* a0..a7 -- address register */
    20732071
    2074                 regptr->a_reg[rnum-9] = (char *)p_value;
     2072                regptr->a_reg[rnum-9] = (int8_t *)p_value;
    20752073                return(TRUE);
    20762074        }
    … …  
    20852083                        return(FALSE);
    20862084
    2087                 regptr->reg_sr = (UWORD16)p_value;
     2085                regptr->reg_sr = (uint16_t)p_value;
    20882086                return(TRUE);
    20892087        }
    … …  
    20942092                        return(FALSE);
    20952093
    2096                 regptr->reg_pc = (char *)p_value;
     2094                regptr->reg_pc = (int8_t *)p_value;
    20972095                return(TRUE);
    20982096        }
    … …  
    21032101                        return(FALSE);
    21042102
    2105                 regptr->a_reg[7] = (char *)p_value;
     2103                regptr->a_reg[7] = (int8_t *)p_value;
    21062104                return(TRUE);
    21072105        }
    … …  
    21202118*/
    21212119
    2122 int cp_vrst(void)
    2123 {
    2124         int     rc;
     2120int16_t cp_vrst(void)
     2121{
     2122        int16_t rc;
    21252123
    21262124        rc = 0;
    … …  
    21782176*/
    21792177
    2180 int cx_vrst(void)
     2178int16_t cx_vrst(void)
    21812179{
    21822180        redo = FALSE;
    … …  
    22172215*/
    22182216
    2219 int cx_vreg(void)
    2220 {
    2221         register int    i, j, k, l;
    2222         register unsigned *rp;
     2217int16_t cx_vreg(void)
     2218{
     2219        register int16_t        i, j, k, l;
     2220        register uint16_t *rp;
    22232221
    22242222        rp = &v_regs[0];
    … …  
    22322230
    22332231                                writeln(cmdunit, "  ");
    2234                                 putn((long)l++, 2, cmdunit);
     2232                                putn((int32_t)l++, 2, cmdunit);
    22352233                                writeln(cmdunit, ":");
    2236                                 puthn((long)*rp++, 4, cmdunit);
     2234                                puthn((int32_t)*rp++, 4, cmdunit);
    22372235                        }
    22382236
    … …  
    22562254*/
    22572255
    2258 int do_srec(char *line)
    2259 {
    2260         register char *ldadr;
    2261         register int c, csum, i, len;
    2262         register unsigned val;
     2256int16_t do_srec(int8_t *line)
     2257{
     2258        register int8_t *ldadr;
     2259        register int16_t c, csum, i, len;
     2260        register uint16_t val;
    22632261
    22642262        if ('S' NE (c = *line++))
    … …  
    22822280
    22832281                csum += (len & 0xFF);
    2284                 ldadr = (char *)0;
     2282                ldadr = (int8_t *)0;
    22852283                len -= 4;
    22862284
    … …  
    22972295                                return(-3);
    22982296
    2299                         ldadr = (char *)(((long)ldadr << 8) + (long)val);
     2297                        ldadr = (int8_t *)(((int32_t)ldadr << 8) + (int32_t)val);
    23002298                        csum += (val & 0xFF);
    23012299                }
    … …  
    23642362*/
    23652363
    2366 int cx_load(void)
    2367 {
    2368         register int rc;
     2364int16_t cx_load(void)
     2365{
     2366        register int16_t rc;
    23692367
    23702368        do {
    … …  
    23832381                                writeln(cmdunit, NACK);
    23842382                                writeln(cmdunit, "** Load error ");
    2385                                 putn((long)rc, 3, cmdunit);
     2383                                putn((int32_t)rc, 3, cmdunit);
    23862384                                writeln(cmdunit, " **\r\n\n");
    23872385                                return(FALSE);
    … …  
    24282426*/
    24292427
    2430 int cx_fill(void)
    2431 {
    2432         register char *cp = p_from;
    2433         register long count;
     2428int16_t cx_fill(void)
     2429{
     2430        register int8_t *cp = p_from;
     2431        register int32_t count;
    24342432
    24352433        redo = FALSE;
    … …  
    24372435        for (count = p_len; count > 0L; count--) {
    24382436
    2439                 *cp = (char)(0xFFL & p_value);
    2440 
    2441                 if (*cp NE (char)(0xFFL & p_value)) {
     2437                *cp = (int8_t)(0xFFL & p_value);
     2438
     2439                if (*cp NE (int8_t)(0xFFL & p_value)) {
    24422440
    24432441                        writeln(cmdunit, "\r\n** FILL failed at ");
    2444                         puthn((long)cp, 8, cmdunit);
     2442                        puthn((int32_t)cp, 8, cmdunit);
    24452443                        writeln(cmdunit, " **\r\n");
    24462444                        return(FALSE);
    … …  
    24632461*/
    24642462
    2465 int cx_wfil(void)
    2466 {
    2467         register UWORD16 *cp = (UWORD16 *)p_from;
    2468         register long count;
     2463int16_t cx_wfil(void)
     2464{
     2465        register uint16_t *cp = (uint16_t *)p_from;
     2466        register int32_t count;
    24692467
    24702468        redo = FALSE;
    24712469
    24722470        for (count = p_len; count > 0L; count--)
    2473                 *cp++ = (UWORD16)(0xFFFFL & p_value);
     2471                *cp++ = (uint16_t)(0xFFFFL & p_value);
    24742472
    24752473        return(TRUE);
    … …  
    24862484*/
    24872485
    2488 int cx_copy(void)
    2489 {
    2490         register char   *from = p_from,
     2486int16_t cx_copy(void)
     2487{
     2488        register int8_t *from = p_from,
    24912489                        *to = p_to;
    2492         register long   count = p_len;
     2490        register int32_t        count = p_len;
    24932491
    24942492        redo = FALSE;
    … …  
    25082506
    25092507                                writeln(cmdunit, "\r\n** COPY failed from ");
    2510                                 puthn((long)from, 8, cmdunit);
     2508                                puthn((int32_t)from, 8, cmdunit);
    25112509                                writeln(cmdunit, " to ");
    2512                                 puthn((long)to, 8, cmdunit);
     2510                                puthn((int32_t)to, 8, cmdunit);
    25132511                                writeln(cmdunit, " with (from) = ");
    2514                                 puthn((long)(*from), 2, cmdunit);
     2512                                puthn((int32_t)(*from), 2, cmdunit);
    25152513                                writeln(cmdunit, " and (to) = ");
    2516                                 puthn((long)(*to), 2, cmdunit);
     2514                                puthn((int32_t)(*to), 2, cmdunit);
    25172515                                writeln(cmdunit, " **\r\n");
    25182516                                return(FALSE);
    … …  
    25332531
    25342532                                writeln(cmdunit, "\r\n** COPY failed from ");
    2535                                 puthn((long)from, 8, cmdunit);
     2533                                puthn((int32_t)from, 8, cmdunit);
    25362534                                writeln(cmdunit, " to ");
    2537                                 puthn((long)to, 8, cmdunit);
     2535                                puthn((int32_t)to, 8, cmdunit);
    25382536                                writeln(cmdunit, " with (from) = ");
    2539                                 puthn((long)(*from), 2, cmdunit);
     2537                                puthn((int32_t)(*from), 2, cmdunit);
    25402538                                writeln(cmdunit, " and (to) = ");
    2541                                 puthn((long)(*to), 2, cmdunit);
     2539                                puthn((int32_t)(*to), 2, cmdunit);
    25422540                                writeln(cmdunit, " **\r\n");
    25432541                                return(FALSE);
    … …  
    25622560*/
    25632561
    2564 int cx_dump(void)
    2565 {
    2566         register int    nw, rc;
     2562int16_t cx_dump(void)
     2563{
     2564        register int16_t        nw, rc;
    25672565
    25682566        redo= TRUE;
    25692567        d_cur = p_from;
    25702568        d_next = p_to + 1;
    2571         d_last = ((long)p_to - (long)p_from) + d_next;
     2569        d_last = ((int32_t)p_to - (int32_t)p_from) + d_next;
    25722570        nw = p_width;
    25732571        rc = TRUE;
    … …  
    26122610*/
    26132611
    2614 int wdump(UWORD16 *loc, UWORD16 *lastloc, int nwide, int unit)
     2612int16_t wdump(uint16_t *loc, uint16_t *lastloc, int16_t nwide, int16_t unit)
    26152613{
    26162614        while (nwide--) {
    26172615
    2618                 puthn((long)(0xFFFFL & *loc), 4, unit);
     2616                puthn((int32_t)(0xFFFFL & *loc), 4, unit);
    26192617                BIOS(B_PUTC,unit, ' ');
    26202618
    … …  
    26442642*/
    26452643
    2646 int ldump(long *loc, long *lastloc, int nwide, int unit)
     2644int16_t ldump(int32_t *loc, int32_t *lastloc, int16_t nwide, int16_t unit)
    26472645{
    26482646        while (nwide--) {
    … …  
    26762674*/
    26772675
    2678 int cp_wdmp(void)
     2676int16_t cp_wdmp(void)
    26792677{
    26802678        inext = ilast;
    … …  
    26872685                }
    26882686
    2689         if ((long)p_from & 1L) {
     2687        if ((int32_t)p_from & 1L) {
    26902688
    26912689                redo = FALSE;
    … …  
    27082706                }
    27092707
    2710         if ((long)p_to & 1L) {
     2708        if ((int32_t)p_to & 1L) {
    27112709
    27122710                redo = FALSE;
    … …  
    27422740*/
    27432741
    2744 int cp_ldmp(void)
     2742int16_t cp_ldmp(void)
    27452743{
    27462744        inext = ilast;
    … …  
    27532751                }
    27542752
    2755         if ((long)p_from & 1L) {
     2753        if ((int32_t)p_from & 1L) {
    27562754
    27572755                redo = FALSE;
    … …  
    27742772                }
    27752773
    2776         if ((long)p_to & 1L) {
     2774        if ((int32_t)p_to & 1L) {
    27772775
    27782776                redo = FALSE;
    … …  
    28082806*/
    28092807
    2810 int cp_ilev(void)
    2811 {
    2812         long    iplevl;
     2808int16_t cp_ilev(void)
     2809{
     2810        int32_t iplevl;
    28132811
    28142812        if (argsep EQ A_CR OR argsep EQ '\0')
    … …  
    28332831*/
    28342832
    2835 int cx_ilev(void)
     2833int16_t cx_ilev(void)
    28362834{
    28372835        if (-1 EQ setipl(iplev)) {
    … …  
    28552853*/
    28562854
    2857 int cp_monc(void)
     2855int16_t cp_monc(void)
    28582856{
    28592857        if (getarg())
    … …  
    28722870*/
    28732871
    2874 int cp_mons(void)
     2872int16_t cp_mons(void)
    28752873{
    28762874        if (getarg())
    … …  
    28932891*/
    28942892
    2895 int cp_monl(void)
     2893int16_t cp_monl(void)
    28962894{
    28972895        if (getarg())
    … …  
    29142912*/
    29152913
    2916 int cx_mon(void)
    2917 {
    2918         register char vc, vcc;
    2919         register short vs, vss, *vsp;
    2920         register long vl, vll, *vlp;
     2914int16_t cx_mon(void)
     2915{
     2916        register int8_t vc, vcc;
     2917        register int16_t vs, vss, *vsp;
     2918        register int32_t vl, vll, *vlp;
    29212919
    29222920        switch (monsw) {
    … …  
    29252923
    29262924                vc = *monptr & 0x0FF;
    2927                 puthn((long)vc, 2, cmdunit);
     2925                puthn((int32_t)vc, 2, cmdunit);
    29282926                writeln(cmdunit, "\r\n");
    29292927
    … …  
    29352933
    29362934                                vc = vcc;
    2937                                 puthn((long)vc, 2, cmdunit);
     2935                                puthn((int32_t)vc, 2, cmdunit);
    29382936                                writeln(cmdunit, "\r\n");
    29392937                        }
    … …  
    29452943        case MON_S:
    29462944
    2947                 vsp = (short *)monptr;
     2945                vsp = (int16_t *)monptr;
    29482946                vs = *vsp;
    2949                 puthn((long)vs, 4, cmdunit);
     2947                puthn((int32_t)vs, 4, cmdunit);
    29502948                writeln(cmdunit, "\r\n");
    29512949
    … …  
    29572955
    29582956                                vs = vss;
    2959                                 puthn((long)vs, 4, cmdunit);
     2957                                puthn((int32_t)vs, 4, cmdunit);
    29602958                                writeln(cmdunit, "\r\n");
    29612959                        }
    … …  
    29702968        case MON_L:
    29712969
    2972                 vlp = (long *)monptr;
     2970                vlp = (int32_t *)monptr;
    29732971                vl = *vlp;
    29742972                puthn(vl, 8, cmdunit);
    … …  
    30053003*/
    30063004
    3007 int cx_wdmp(void)
    3008 {
    3009         int     nw, rc;
     3005int16_t cx_wdmp(void)
     3006{
     3007        int16_t nw, rc;
    30103008
    30113009        d_cur = p_from;
    30123010        d_next = p_to + 2;
    3013         d_last = ((long)p_to - (long)p_from) + d_next;
     3011        d_last = ((int32_t)p_to - (int32_t)p_from) + d_next;
    30143012        nw = p_width;
    30153013        rc = TRUE;
    … …  
    30483046*/
    30493047
    3050 int cx_ldmp(void)
    3051 {
    3052         int     nw, rc;
     3048int16_t cx_ldmp(void)
     3049{
     3050        int16_t nw, rc;
    30533051
    30543052        d_cur = p_from;
    30553053        d_next = p_to + 4;
    3056         d_last = ((long)p_to - (long)p_from) + d_next;
     3054        d_last = ((int32_t)p_to - (int32_t)p_from) + d_next;
    30573055        nw = p_width;
    30583056        rc = TRUE;
    … …  
    30933091void do_cmd(void)
    30943092{
    3095         int     rc, i;
     3093        int16_t rc, i;
    30963094
    30973095        /* prompt for a command line */
    … …  
    31883186*/
    31893187
    3190 int cx_next(void)
     3188int16_t cx_next(void)
    31913189{
    31923190        p_to = d_last; 
    … …  
    32053203*/
    32063204
    3207 int cx_read(void)
    3208 {
    3209         long    rc;
    3210         int     ns, recno;
     3205int16_t cx_read(void)
     3206{
     3207        int32_t rc;
     3208        int16_t ns, recno;
    32113209
    32123210        ns = p_len & 0x7FFFL;
    3213         recno = (long)p_from & 0xFFFFL;
     3211        recno = (int32_t)p_from & 0xFFFFL;
    32143212
    32153213        rc = BIOS(B_RDWR, 2, p_to, ns, recno, 0);
    … …  
    32383236*/
    32393237
    3240 int cx_writ(void)
    3241 {
    3242         long    rc;
    3243         int     ns, recno;
     3238int16_t cx_writ(void)
     3239{
     3240        int32_t rc;
     3241        int16_t ns, recno;
    32443242
    32453243        ns = p_len & 0x7FFFL;
    3246         recno = (long)p_from & 0xFFFFL;
     3244        recno = (int32_t)p_from & 0xFFFFL;
    32473245
    32483246        rc = BIOS(B_RDWR, 3, p_to, ns, recno, 0);
    … …  
    32733271void showrs(struct regs *rp)
    32743272{
    3275         int     i;
    3276         UWORD16 srtemp;
     3273        int16_t i;
     3274        uint16_t        srtemp;
    32773275
    32783276        writeln(cmdunit, "       ");
    … …  
    33023300
    33033301        writeln(cmdunit, "\r\nPC =  ");
    3304         puthn((long)rp->reg_pc, 8, cmdunit);
     3302        puthn((int32_t)rp->reg_pc, 8, cmdunit);
    33053303
    33063304        srtemp = rp->reg_sr;
    33073305        writeln(cmdunit, ",    SR = ");
    3308         puthn( (long)srtemp & 0xFFFFL, 4, cmdunit);
     3306        puthn( (int32_t)srtemp & 0xFFFFL, 4, cmdunit);
    33093307
    33103308/*
    … …  
    33133311
    33143312        writeln(cmdunit, "  (IPL = ");
    3315         puthn( (long)(srtemp >> 8) & 0x7L, 1, cmdunit);
     3313        puthn( (int32_t)(srtemp >> 8) & 0x7L, 1, cmdunit);
    33163314        writeln(cmdunit, ", ");
    33173315
    … …  
    33683366void showcr(void)
    33693367{
    3370         register int    i;
    3371         register char   *cause;
    3372         register UWORD16        srtemp;
     3368        register int16_t        i;
     3369        register int8_t *cause;
     3370        register uint16_t       srtemp;
    33733371
    33743372        writeln(cmdunit, "BIOS Crash Area Dump\r\n");
    … …  
    33993397
    34003398        writeln(cmdunit, "\r\n\nPC =  ");
    3401         puthn((long)crshpc, 8, cmdunit);
     3399        puthn((int32_t)crshpc, 8, cmdunit);
    34023400
    34033401        srtemp = crshsr;
    34043402        writeln(cmdunit, ",    SR = ");
    3405         puthn((long)srtemp & 0xFFFFL, 4, cmdunit);
     3403        puthn((int32_t)srtemp & 0xFFFFL, 4, cmdunit);
    34063404
    34073405/*
    … …  
    34103408
    34113409        writeln(cmdunit, "  (IPL = ");
    3412         puthn((long)(srtemp >> 8) & 0x7L, 1, cmdunit);
     3410        puthn((int32_t)(srtemp >> 8) & 0x7L, 1, cmdunit);
    34133411        writeln(cmdunit, ", ");
    34143412
    … …  
    34563454*/
    34573455        writeln(cmdunit, "TRAP vector number = ");
    3458         putn((long)crshvc[0], 2, cmdunit);
     3456        putn((int32_t)crshvc[0], 2, cmdunit);
    34593457
    34603458        cause = "  (no handler for interrupt)";
    … …  
    35733571*/
    35743572
    3575 int cx_crsh(void)
     3573int16_t cx_crsh(void)
    35763574{
    35773575        if (!wzcrsh)
    … …  
    35933591*/
    35943592
    3595 int bphit(void)
    3596 {
    3597         int     rc;
     3593int16_t bphit(void)
     3594{
     3595        int16_t rc;
    35983596
    35993597        rc = FALSE;
    36003598
    3601         if ((char *)p_ba0 EQ regptr->reg_pc) {
     3599        if ((int8_t *)p_ba0 EQ regptr->reg_pc) {
    36023600
    36033601                if (*p_ba0 EQ BPINST) {
    … …  
    36133611                        puthn(p_ba0, 8 , cmdunit);
    36143612                        writeln(cmdunit, " was ");
    3615                         puthn(0xFFFFL & (long)(*p_ba0), 4, cmdunit);
     3613                        puthn(0xFFFFL & (int32_t)(*p_ba0), 4, cmdunit);
    36163614                        writeln(cmdunit, " instead of ");
    3617                         puthn((long)BPINST, 4, cmdunit);
     3615                        puthn((int32_t)BPINST, 4, cmdunit);
    36183616                        writeln(cmdunit, " **\r\n\n");
    36193617                        rc = TRUE;
    … …  
    36253623*/
    36263624
    3627         if ((char *)p_ba1 EQ regptr->reg_pc) {
     3625        if ((int8_t *)p_ba1 EQ regptr->reg_pc) {
    36283626
    36293627                if (*p_ba1 EQ BPINST) {
    … …  
    36373635
    36383636                        writeln(cmdunit, "** Breakpoint word at ");
    3639                         puthn((long)p_ba0, 8 , cmdunit);
     3637                        puthn((int32_t)p_ba0, 8 , cmdunit);
    36403638                        writeln(cmdunit, " was ");
    3641                         puthn(0xFFFFL & (long)(*p_ba1), 4, cmdunit);
     3639                        puthn(0xFFFFL & (int32_t)(*p_ba1), 4, cmdunit);
    36423640                        writeln(cmdunit, " instead of ");
    3643                         puthn((long)BPINST, 4, cmdunit);
     3641                        puthn((int32_t)BPINST, 4, cmdunit);
    36443642                        writeln(cmdunit, " **\r\n\n");
    36453643                        rc = TRUE;
    … …  
    36633661                        puthn(p_ba0, 8 , cmdunit);
    36643662                        writeln(cmdunit, " was ");
    3665                         puthn(0xFFFFL & (long)(*p_ba0), 4, cmdunit);
     3663                        puthn(0xFFFFL & (int32_t)(*p_ba0), 4, cmdunit);
    36663664                        writeln(cmdunit, " instead of ");
    3667                         puthn((long)BPINST, 4, cmdunit);
     3665                        puthn((int32_t)BPINST, 4, cmdunit);
    36683666                        writeln(cmdunit, " **\r\n\n");
    36693667                        rc = TRUE;
    … …  
    36873685
    36883686                        writeln(cmdunit, "** Breakpoint word at ");
    3689                         puthn((long)p_ba0, 8 , cmdunit);
     3687                        puthn((int32_t)p_ba0, 8 , cmdunit);
    36903688                        writeln(cmdunit, " was ");
    3691                         puthn(0xFFFFL & (long)(*p_ba1), 4, cmdunit);
     3689                        puthn(0xFFFFL & (int32_t)(*p_ba1), 4, cmdunit);
    36923690                        writeln(cmdunit, " instead of ");
    3693                         puthn((long)BPINST, 4, cmdunit);
     3691                        puthn((int32_t)BPINST, 4, cmdunit);
    36943692                        writeln(cmdunit, " **\r\n\n");
    36953693                        rc = TRUE;
    … …  
    37143712*/
    37153713
    3716 int cx_regs(void)
     3714int16_t cx_regs(void)
    37173715{
    37183716        showrs(regptr);
    … …  
    37303728*/
    37313729
    3732 void rompbp(long d0, long d1, long d2, long d3, long d4, long d5, long d6, long d7, char *a0, char *a1, char *a2, char *a3, char *a4, char *a5, char *a6, char *a7, char *pc, UWORD16 sr0, UWORD16 sr)
    3733 {
    3734         register int i;
     3730void rompbp(int32_t d0, int32_t d1, int32_t d2, int32_t d3, int32_t d4, int32_t d5, int32_t d6, int32_t d7, int8_t *a0, int8_t *a1, int8_t *a2, int8_t *a3, int8_t *a4, int8_t *a5, int8_t *a6, int8_t *a7, int8_t *pc, uint16_t sr0, uint16_t sr)
     3731{
     3732        register int16_t i;
    37353733
    37363734        regptr = (struct regs *)&d0;    /* make registers accessable */
    … …  
    37463744
    37473745                for (i = 0; i < 7; i++)         /* clear a0..a6 */
    3748                         regptr->a_reg[i] = (char *)0L;
     3746                        regptr->a_reg[i] = (int8_t *)0L;
    37493747
    37503748                regptr->a_reg[7] = ISTACK;      /* setup initial stack */
    … …  
    37883786void progid(void)
    37893787{
    3790         register char *pcptr;
     3788        register int8_t *pcptr;
    37913789
    37923790#if     TINYMSG
    … …  
    38103808
    38113809        writeln(cmdunit, "\r\n  BIOS Version ");
    3812         pcptr = (char *)PRM_VERS;
    3813         putn((long)*pcptr++, 2, cmdunit);
     3810        pcptr = (int8_t *)PRM_VERS;
     3811        putn((int32_t)*pcptr++, 2, cmdunit);
    38143812        BIOS(B_PUTC, cmdunit, '.');
    3815         putn((long)*pcptr++, 2, cmdunit);
     3813        putn((int32_t)*pcptr++, 2, cmdunit);
    38163814        writeln(cmdunit, promdate);
    38173815
    … …  
    38323830*/
    38333831
    3834 short pclr(void)
    3835 {
    3836         register short i;
     3832int16_t pclr(void)
     3833{
     3834        register int16_t i;
    38373835
    38383836        ftimer = FIFOLIM;
    … …  
    38723870*/
    38733871
    3874 short pscan(void)
    3875 {
    3876         register short i, c;
     3872int16_t pscan(void)
     3873{
     3874        register int16_t i, c;
    38773875
    38783876        if (0 EQ ledcntr--) {
    … …  
    39763974void main(void)
    39773975{
    3978         register short i;
    3979         register char *pdptr, *pcptr;
     3976        register int16_t i;
     3977        register int8_t *pdptr, *pcptr;
    39803978
    39813979        /* unpack PROM date */
    39823980
    3983         pcptr = (char *)PRM_DATE;       /* prom date: yyyymmdd */
     3981        pcptr = (int8_t *)PRM_DATE;     /* prom date: yyyymmdd */
    39843982        pdptr = promdate;               /*  -- yyyy-mm-dd */
    39853983        *pdptr++ = ' ';
    … …  
    40174015        b1flag = FALSE;
    40184016
    4019         p_goto  = (char *)ROMADDR;
     4017        p_goto  = (int8_t *)ROMADDR;
    40204018        p_len   = 0L;
    40214019        p_width = 16L;
    … …  
    40474045
    40484046        sprintf(idbuf, "BIOS Version %02d.%02d%s",
    4049                 *(char *)PRM_VERS, *(char *)(PRM_VERS+1), promdate);
     4047                *(int8_t *)PRM_VERS, *(int8_t *)(PRM_VERS+1), promdate);
    40504048        GLCtext(5, 30, idbuf);
    40514049
    … …  
    40544052        GLCcrc(0, 0);
    40554053
    4056         (char *)BIOS(B_SETV, 47, trap15);       /* set ROMP trap vec */
     4054        (int8_t *)BIOS(B_SETV, 47, trap15);     /* set ROMP trap vec */
    40574055
    40584056        for (i = 0; i < 128; i++) {
    … …  
    40794077        progid();       /* identify the program */
    40804078
    4081         (char *)BIOS(B_SETV, 47, trap15);       /* set ROMP trap vec */
     4079        (int8_t *)BIOS(B_SETV, 47, trap15);     /* set ROMP trap vec */
    40824080        writeln(cmdunit, "\r\n\n");
    40834081
Note: See TracChangeset for help on using the changeset viewer.