Changeset 298f0b4 in buchla-68k


Ignore:
Timestamp:
07/14/2017 01:45:36 PM (3 years ago)
Author:
Thomas Lopatic <thomas@…>
Branches:
master
Children:
7d4cf30
Parents:
33b5477
Message:

Fewer incompatible pointers.

Files:
7 edited

Legend:

Unmodified
Added
Removed
  • include/regs.h

    r33b5477 r298f0b4  
    1515struct regs {
    1616
    17         int32_t d_reg[8];               /* Data registers d0..d7 */
     17        uint32_t        d_reg[8];       /* Data registers d0..d7 */
    1818
    19         int8_t  *a_reg[8];              /* Address registers */
     19        uint32_t        a_reg[8];       /* Address registers */
    2020
    2121        uint16_t        reg_fill,       /* Filler to keep long alignment */
    22                         reg_sr,         /* Status register */
    23                         *reg_pc;        /* Program counter */
     22                        reg_sr;         /* Status register */
     23
     24        uint32_t        reg_pc; /* Program counter */
    2425};
  • misc/proto.x

    r33b5477 r298f0b4  
    2626extern  int8_t          VerDate[];
    2727extern  int8_t          ac_code;
    28 extern  int16_t         *crshpc;
    29 extern  int32_t         crshrg[16];
    30 extern  int16_t         *crshsp;
     28extern  uint32_t        crshpc;
     29extern  uint32_t        crshrg[16];
     30extern  uint32_t        crshsp;
    3131extern  uint16_t        crshsr;
    32 extern  int16_t         crshst[16];
    33 extern  int16_t         *crshus;
     32extern  uint16_t        crshst[16];
     33extern  uint32_t        crshus;
    3434extern  int8_t          crshvc[4];
    3535extern  int8_t          edata;
  • misc/rewrite.txt

    r33b5477 r298f0b4  
    1 ___divsi3 __divsi3
    2 ___modsi3 __modsi3
    3 ___mulsi3 __mulsi3
     1___divsi3       __divsi3
     2___modsi3       __modsi3
     3___mulsi3       __mulsi3
     4___udivsi3      __udivsi3
     5___umodsi3      __umodsi3
  • ram/libdsp.c

    r33b5477 r298f0b4  
    235235*/
    236236
    237 int32_t chksum(int8_t *area, int32_t len)
    238 {
    239         register int32_t cs, i;
    240 
     237int32_t chksum(void *area, int32_t len)
     238{
     239        uint8_t *area8;
     240        int32_t cs, i;
     241
     242        area8 = area;
    241243        cs = 0L;
    242244
    243245        for (i = 0; i < len; i++)
    244                 cs += 0x000000FFL & *area++;
     246                cs += 0x000000FFL & *area8++;
    245247
    246248        return(cs);
     
    306308*/
    307309
    308 int16_t wr_ec(FILE *fp, int8_t *from, int32_t len)
    309 {
    310         register int32_t count;
    311         register int8_t c;
     310int16_t wr_ec(FILE *fp, void *from, int32_t len)
     311{
     312        uint8_t *from8, c;
     313        int32_t count;
     314
     315        from8 = from;
     316
    312317        for (count = 0; count < len; count++) {
    313318
    314319                errno = 0;
    315                 c  = *from++;
     320                c  = *from8++;
    316321
    317322                if (EOF EQ putc(c, fp)) {
     
    346351*/
    347352
    348 int16_t rd_ec(FILE *fp, int8_t *to, int32_t len)
    349 {
    350         register int32_t count;
    351         register int16_t c;
     353int16_t rd_ec(FILE *fp, void *to, int32_t len)
     354{
     355        uint8_t *to8;
     356        int32_t count;
     357        int16_t c;
     358
     359        to8 = to;
    352360
    353361        for (count = 0; count < len; count++) {
     
    368376                } else {
    369377
    370                         *to++ = c;
     378                        *to8++ = (uint8_t)c;
    371379
    372380#if     DEBUGRE
  • ram/libdsp.x

    r33b5477 r298f0b4  
    2929extern  void            advlcur(void);
    3030extern  void            bsplcur(void);
    31 extern  int32_t         chksum(int8_t *area, int32_t len);
     31extern  int32_t         chksum(void *area, int32_t len);
    3232extern  int16_t         ckdups(void);
    3333extern  int16_t         ckstor(void);
     
    5757extern  int16_t         ocslot(int16_t slot);
    5858extern  int16_t         putcat(void);
    59 extern  int16_t         rd_ec(FILE *fp, int8_t *to, int32_t len);
     59extern  int16_t         rd_ec(FILE *fp, void *to, int32_t len);
    6060extern  int16_t         showcat(void);
    6161extern  int16_t         showsiz(void);
     
    6565extern  int16_t         storit(void);
    6666extern  void            streset(void);
    67 extern  int16_t         wr_ec(FILE *fp, int8_t *from, int32_t len);
     67extern  int16_t         wr_ec(FILE *fp, void *from, int32_t len);
    6868extern  int16_t         writem(void);
    6969extern  int16_t         wrtfile(int16_t kind);
  • rom/romp.c

    r33b5477 r298f0b4  
    324324*/
    325325
    326 void cx_exit(void)
     326int16_t cx_exit(void)
    327327{
    328328        longjmp(&restart, 1);           /* restart ROMP */
     329        return(TRUE);                   /* not reached */
    329330}
    330331
     
    335336*/
    336337
    337 void cx_rest(void)
     338int16_t cx_rest(void)
    338339{
    339340        rjumpto(ROMADDR);
     341        return(TRUE);                   /* not reached */
    340342}
    341343
     
    363365        } else {
    364366
    365                 for (i = 0; i < 8; i++)         /* clear d0..d7 */
     367                for (i = 0; i < 8; i++)                 /* clear d0..d7 */
    366368                        regptr->d_reg[i] = 0L;
    367369
    368                 for (i = 0; i < 7; i++)         /* clear a0..a6 */
    369                         regptr->a_reg[i] = (int8_t *)0L;
    370 
    371                 regptr->a_reg[7] = ISTACK;      /* setup initial stack */
    372 
    373                 regptr->reg_sr = INITSR;        /* setup sr */
    374                 regptr->reg_pc = B_buf_a;       /* setup pc */
     370                for (i = 0; i < 7; i++)                 /* clear a0..a6 */
     371                        regptr->a_reg[i] = 0L;
     372
     373                regptr->a_reg[7] = ISTACK;              /* setup initial stack */
     374
     375                regptr->reg_sr = INITSR;                /* setup sr */
     376                regptr->reg_pc = (uint32_t)B_buf_a;     /* setup pc */
    375377
    376378                return(TRUE);
     
    451453
    452454                for (i = 0; i < 7; i++)         /* clear a0..a6 */
    453                         regptr->a_reg[i] = (int8_t *)0L;
     455                        regptr->a_reg[i] = 0L;
    454456
    455457                regptr->a_reg[7] = ISTACK;      /* setup initial stack */
     
    975977*/
    976978
    977 void putn(int32_t num, int16_t cw, int16_t unit)
     979void putn(uint32_t num, int16_t cw, int16_t unit)
    978980{
    979981        register int16_t        d;
     
    10011003*/
    10021004
    1003 void puthn(int32_t num, int16_t cw, int16_t unit)
     1005void puthn(uint32_t num, int16_t cw, int16_t unit)
    10041006{
    10051007        register int16_t        d;
     
    10341036        while (nwide--) {
    10351037
    1036                 puthn((int32_t)(0xFF & *loc), 2, unit);
     1038                puthn((uint32_t)(0xFF & *loc), 2, unit);
    10371039                BIOS(B_PUTC, unit, ' ');
    10381040
     
    10681070void padr(int32_t adr, int16_t unit)
    10691071{
    1070         puthn(adr, 8, unit);
     1072        puthn((uint32_t)adr, 8, unit);
    10711073        BIOS(B_PUTC, unit, ' ');
    10721074        BIOS(B_PUTC, unit, '-');
     
    14131415*/
    14141416
    1415 void cx_zap(void)
     1417int16_t cx_zap(void)
    14161418{
    14171419        register int16_t *p, *q;
     
    14261428
    14271429        rjumpto(ROMADDR);
     1430        return(TRUE);                   /* not reached */
    14281431}
    14291432
     
    15271530                writeln(cmdunit, "\r\n\nBPB values:\r\n");
    15281531                writeln(cmdunit, "\r\n   recsiz   ");
    1529                 putn((int32_t)bpp->recsiz, 5, cmdunit);
     1532                putn((uint32_t)bpp->recsiz, 5, cmdunit);
    15301533                writeln(cmdunit, "\r\n   clsiz     ");
    1531                 putn((int32_t)bpp->clsiz, 4, cmdunit);
     1534                putn((uint32_t)bpp->clsiz, 4, cmdunit);
    15321535                writeln(cmdunit, "\r\n   clsizb   ");
    1533                 putn((int32_t)bpp->clsizb, 5, cmdunit);
     1536                putn((uint32_t)bpp->clsizb, 5, cmdunit);
    15341537                writeln(cmdunit, "\r\n   rdlen     ");
    1535                 putn((int32_t)bpp->rdlen, 4, cmdunit);
     1538                putn((uint32_t)bpp->rdlen, 4, cmdunit);
    15361539                writeln(cmdunit, "\r\n   fsiz      ");
    1537                 putn((int32_t)bpp->fsiz, 4, cmdunit);
     1540                putn((uint32_t)bpp->fsiz, 4, cmdunit);
    15381541                writeln(cmdunit, "\r\n   fatrec   ");
    1539                 putn((int32_t)bpp->fatrec, 5, cmdunit);
     1542                putn((uint32_t)bpp->fatrec, 5, cmdunit);
    15401543                writeln(cmdunit, "\r\n   datrec   ");
    1541                 putn((int32_t)bpp->datrec, 5, cmdunit);
     1544                putn((uint32_t)bpp->datrec, 5, cmdunit);
    15421545                writeln(cmdunit, "\r\n   numcl    ");
    1543                 putn((int32_t)bpp->numcl, 5, cmdunit);
     1546                putn((uint32_t)bpp->numcl, 5, cmdunit);
    15441547                writeln(cmdunit, "\r\n   bflags    ");
    1545                 puthn((int32_t)bpp->bflags, 4, cmdunit);
     1548                puthn((uint32_t)bpp->bflags, 4, cmdunit);
    15461549                writeln(cmdunit, "\r\n   ntracks   ");
    1547                 putn((int32_t)bpp->ntracks, 4, cmdunit);
     1550                putn((uint32_t)bpp->ntracks, 4, cmdunit);
    15481551                writeln(cmdunit, "\r\n   nsides    ");
    1549                 putn((int32_t)bpp->nsides, 4, cmdunit);
     1552                putn((uint32_t)bpp->nsides, 4, cmdunit);
    15501553                writeln(cmdunit, "\r\n   sec/cyl  ");
    1551                 putn((int32_t)bpp->dspc, 5, cmdunit);
     1554                putn((uint32_t)bpp->dspc, 5, cmdunit);
    15521555                writeln(cmdunit, "\r\n   sec/trk  ");
    1553                 putn((int32_t)bpp->dspt, 5, cmdunit);
     1556                putn((uint32_t)bpp->dspt, 5, cmdunit);
    15541557                writeln(cmdunit, "\r\n   hidden    ");
    1555                 putn((int32_t)bpp->hidden, 4, cmdunit);
     1558                putn((uint32_t)bpp->hidden, 4, cmdunit);
    15561559                writeln(cmdunit, "\r\n\n");
    15571560                return(TRUE);
     
    15851588
    15861589                                writeln(cmdunit, "\r\n\n** Breakpoint 0 at ");
    1587                                 puthn((int32_t)p_ba0, 8, cmdunit);
     1590                                puthn((uint32_t)p_ba0, 8, cmdunit);
    15881591                                writeln(cmdunit, " was ");
    1589                                 puthn(0xFFFFL & (int32_t)(*p_ba0), 4, cmdunit);
     1592                                puthn(0xFFFFL & (uint32_t)(*p_ba0), 4, cmdunit);
    15901593                                writeln(cmdunit, " instead of ");
    1591                                 puthn(0xFFFFL & (int32_t)BPINST, 4, cmdunit);
     1594                                puthn(0xFFFFL & (uint32_t)BPINST, 4, cmdunit);
    15921595                                writeln(cmdunit, " **\r\n\n");
    15931596                        }
     
    16121615
    16131616                                writeln(cmdunit, "\r\n\n** Breakpoint 1 at ");
    1614                                 puthn((int32_t)p_ba1, 8, cmdunit);
     1617                                puthn((uint32_t)p_ba1, 8, cmdunit);
    16151618                                writeln(cmdunit, " was ");
    1616                                 puthn(0xFFFFL & (int32_t)(*p_ba1), 4, cmdunit);
     1619                                puthn(0xFFFFL & (uint32_t)(*p_ba1), 4, cmdunit);
    16171620                                writeln(cmdunit, " instead of ");
    1618                                 puthn(0xFFFFL & (int32_t)BPINST, 4, cmdunit);
     1621                                puthn(0xFFFFL & (uint32_t)BPINST, 4, cmdunit);
    16191622                                writeln(cmdunit, " **\r\n\n");
    16201623                        }
     
    19431946        if (rnum < 17) {        /* a0..a7 -- address register */
    19441947
    1945                 regptr->a_reg[rnum-9] = (int8_t *)p_value;
     1948                regptr->a_reg[rnum-9] = p_value;
    19461949                return(TRUE);
    19471950        }
     
    19651968                        return(FALSE);
    19661969
    1967                 regptr->reg_pc = (int8_t *)p_value;
     1970                regptr->reg_pc = p_value;
    19681971                return(TRUE);
    19691972        }
     
    19741977                        return(FALSE);
    19751978
    1976                 regptr->a_reg[7] = (int8_t *)p_value;
     1979                regptr->a_reg[7] = p_value;
    19771980                return(TRUE);
    19781981        }
     
    21032106
    21042107                                writeln(cmdunit, "  ");
    2105                                 putn((int32_t)l++, 2, cmdunit);
     2108                                putn((uint32_t)l++, 2, cmdunit);
    21062109                                writeln(cmdunit, ":");
    2107                                 puthn((int32_t)*rp++, 4, cmdunit);
     2110                                puthn((uint32_t)*rp++, 4, cmdunit);
    21082111                        }
    21092112
     
    22542257                                writeln(cmdunit, NACK);
    22552258                                writeln(cmdunit, "** Load error ");
    2256                                 putn((int32_t)rc, 3, cmdunit);
     2259                                putn((uint32_t)rc, 3, cmdunit);
    22572260                                writeln(cmdunit, " **\r\n\n");
    22582261                                return(FALSE);
     
    22792282                        writeln(cmdunit, NACK);
    22802283                        writeln(cmdunit, "** Load aborted on ");
    2281                         puthn(rc, 2, cmdunit);
     2284                        puthn((uint32_t)rc, 2, cmdunit);
    22822285                        writeln(cmdunit, " **\r\n\n");
    22832286                        return(FALSE);
     
    23132316
    23142317                        writeln(cmdunit, "\r\n** FILL failed at ");
    2315                         puthn((int32_t)cp, 8, cmdunit);
     2318                        puthn((uint32_t)cp, 8, cmdunit);
    23162319                        writeln(cmdunit, " **\r\n");
    23172320                        return(FALSE);
     
    23792382
    23802383                                writeln(cmdunit, "\r\n** COPY failed from ");
    2381                                 puthn((int32_t)from, 8, cmdunit);
     2384                                puthn((uint32_t)from, 8, cmdunit);
    23822385                                writeln(cmdunit, " to ");
    2383                                 puthn((int32_t)to, 8, cmdunit);
     2386                                puthn((uint32_t)to, 8, cmdunit);
    23842387                                writeln(cmdunit, " with (from) = ");
    2385                                 puthn((int32_t)(*from), 2, cmdunit);
     2388                                puthn((uint32_t)(*from), 2, cmdunit);
    23862389                                writeln(cmdunit, " and (to) = ");
    2387                                 puthn((int32_t)(*to), 2, cmdunit);
     2390                                puthn((uint32_t)(*to), 2, cmdunit);
    23882391                                writeln(cmdunit, " **\r\n");
    23892392                                return(FALSE);
     
    24042407
    24052408                                writeln(cmdunit, "\r\n** COPY failed from ");
    2406                                 puthn((int32_t)from, 8, cmdunit);
     2409                                puthn((uint32_t)from, 8, cmdunit);
    24072410                                writeln(cmdunit, " to ");
    2408                                 puthn((int32_t)to, 8, cmdunit);
     2411                                puthn((uint32_t)to, 8, cmdunit);
    24092412                                writeln(cmdunit, " with (from) = ");
    2410                                 puthn((int32_t)(*from), 2, cmdunit);
     2413                                puthn((uint32_t)(*from), 2, cmdunit);
    24112414                                writeln(cmdunit, " and (to) = ");
    2412                                 puthn((int32_t)(*to), 2, cmdunit);
     2415                                puthn((uint32_t)(*to), 2, cmdunit);
    24132416                                writeln(cmdunit, " **\r\n");
    24142417                                return(FALSE);
     
    24872490        while (nwide--) {
    24882491
    2489                 puthn((int32_t)(0xFFFFL & *loc), 4, unit);
     2492                puthn((uint32_t)(0xFFFFL & *loc), 4, unit);
    24902493                BIOS(B_PUTC,unit, ' ');
    24912494
     
    25192522        while (nwide--) {
    25202523
    2521                 puthn(*loc, 8, unit);
     2524                puthn((uint32_t)*loc, 8, unit);
    25222525                BIOS(B_PUTC,unit, ' ');
    25232526
     
    27962799
    27972800                vc = *monptr & 0x0FF;
    2798                 puthn((int32_t)vc, 2, cmdunit);
     2801                puthn((uint32_t)vc, 2, cmdunit);
    27992802                writeln(cmdunit, "\r\n");
    28002803
     
    28062809
    28072810                                vc = vcc;
    2808                                 puthn((int32_t)vc, 2, cmdunit);
     2811                                puthn((uint32_t)vc, 2, cmdunit);
    28092812                                writeln(cmdunit, "\r\n");
    28102813                        }
     
    28182821                vsp = (int16_t *)monptr;
    28192822                vs = *vsp;
    2820                 puthn((int32_t)vs, 4, cmdunit);
     2823                puthn((uint32_t)vs, 4, cmdunit);
    28212824                writeln(cmdunit, "\r\n");
    28222825
     
    28282831
    28292832                                vs = vss;
    2830                                 puthn((int32_t)vs, 4, cmdunit);
     2833                                puthn((uint32_t)vs, 4, cmdunit);
    28312834                                writeln(cmdunit, "\r\n");
    28322835                        }
     
    28432846                vlp = (int32_t *)monptr;
    28442847                vl = *vlp;
    2845                 puthn(vl, 8, cmdunit);
     2848                puthn((uint32_t)vl, 8, cmdunit);
    28462849                writeln(cmdunit, "\r\n");
    28472850
     
    28532856
    28542857                                vl = vll;
    2855                                 puthn(vl, 8, cmdunit);
     2858                                puthn((uint32_t)vl, 8, cmdunit);
    28562859                                writeln(cmdunit, "\r\n");
    28572860                        }
     
    30893092
    30903093                writeln(cmdunit, "\r\nERROR reading disk:  ");
    3091                 puthn(rc, 8, cmdunit);
     3094                puthn((uint32_t)rc, 8, cmdunit);
    30923095                writeln(cmdunit, "\r\n\n");
    30933096                return(FALSE);
     
    31223125
    31233126                writeln(cmdunit, "\r\nERROR writing disk:  ");
    3124                 puthn(rc, 8, cmdunit);
     3127                puthn((uint32_t)rc, 8, cmdunit);
    31253128                writeln(cmdunit, "\r\n\n");
    31263129                return(FALSE);
     
    31733176
    31743177        writeln(cmdunit, "\r\nPC =  ");
    3175         puthn((int32_t)rp->reg_pc, 8, cmdunit);
     3178        puthn((uint32_t)rp->reg_pc, 8, cmdunit);
    31763179
    31773180        srtemp = rp->reg_sr;
    31783181        writeln(cmdunit, ",    SR = ");
    3179         puthn( (int32_t)srtemp & 0xFFFFL, 4, cmdunit);
     3182        puthn((uint32_t)srtemp & 0xFFFFL, 4, cmdunit);
    31803183
    31813184/*
     
    31843187
    31853188        writeln(cmdunit, "  (IPL = ");
    3186         puthn( (int32_t)(srtemp >> 8) & 0x7L, 1, cmdunit);
     3189        puthn((uint32_t)(srtemp >> 8) & 0x7L, 1, cmdunit);
    31873190        writeln(cmdunit, ", ");
    31883191
     
    32703273
    32713274        writeln(cmdunit, "\r\n\nPC =  ");
    3272         puthn((int32_t)crshpc, 8, cmdunit);
     3275        puthn(crshpc, 8, cmdunit);
    32733276
    32743277        srtemp = crshsr;
    32753278        writeln(cmdunit, ",    SR = ");
    3276         puthn((int32_t)srtemp & 0xFFFFL, 4, cmdunit);
     3279        puthn((uint32_t)srtemp & 0xFFFFL, 4, cmdunit);
    32773280
    32783281/*
     
    32813284
    32823285        writeln(cmdunit, "  (IPL = ");
    3283         puthn((int32_t)(srtemp >> 8) & 0x7L, 1, cmdunit);
     3286        puthn((uint32_t)(srtemp >> 8) & 0x7L, 1, cmdunit);
    32843287        writeln(cmdunit, ", ");
    32853288
     
    33273330*/
    33283331        writeln(cmdunit, "TRAP vector number = ");
    3329         putn((int32_t)crshvc[0], 2, cmdunit);
     3332        putn((uint32_t)crshvc[0], 2, cmdunit);
    33303333
    33313334        cause = "  (no handler for interrupt)";
     
    34703473        rc = FALSE;
    34713474
    3472         if ((int8_t *)p_ba0 EQ regptr->reg_pc) {
     3475        if (p_ba0 EQ regptr->reg_pc) {
    34733476
    34743477                if (*p_ba0 EQ BPINST) {
     
    34823485
    34833486                        writeln(cmdunit, "** Breakpoint word at ");
    3484                         puthn(p_ba0, 8 , cmdunit);
     3487                        puthn((uint32_t)p_ba0, 8 , cmdunit);
    34853488                        writeln(cmdunit, " was ");
    3486                         puthn(0xFFFFL & (int32_t)(*p_ba0), 4, cmdunit);
     3489                        puthn(0xFFFFL & (uint32_t)(*p_ba0), 4, cmdunit);
    34873490                        writeln(cmdunit, " instead of ");
    3488                         puthn((int32_t)BPINST, 4, cmdunit);
     3491                        puthn((uint32_t)BPINST, 4, cmdunit);
    34893492                        writeln(cmdunit, " **\r\n\n");
    34903493                        rc = TRUE;
     
    34963499*/
    34973500
    3498         if ((int8_t *)p_ba1 EQ regptr->reg_pc) {
     3501        if (p_ba1 EQ regptr->reg_pc) {
    34993502
    35003503                if (*p_ba1 EQ BPINST) {
     
    35083511
    35093512                        writeln(cmdunit, "** Breakpoint word at ");
    3510                         puthn((int32_t)p_ba0, 8 , cmdunit);
     3513                        puthn((uint32_t)p_ba0, 8 , cmdunit);
    35113514                        writeln(cmdunit, " was ");
    3512                         puthn(0xFFFFL & (int32_t)(*p_ba1), 4, cmdunit);
     3515                        puthn(0xFFFFL & (uint32_t)(*p_ba1), 4, cmdunit);
    35133516                        writeln(cmdunit, " instead of ");
    3514                         puthn((int32_t)BPINST, 4, cmdunit);
     3517                        puthn((uint32_t)BPINST, 4, cmdunit);
    35153518                        writeln(cmdunit, " **\r\n\n");
    35163519                        rc = TRUE;
     
    35323535
    35333536                        writeln(cmdunit, "** Breakpoint word at ");
    3534                         puthn(p_ba0, 8 , cmdunit);
     3537                        puthn((uint32_t)p_ba0, 8 , cmdunit);
    35353538                        writeln(cmdunit, " was ");
    3536                         puthn(0xFFFFL & (int32_t)(*p_ba0), 4, cmdunit);
     3539                        puthn(0xFFFFL & (uint32_t)(*p_ba0), 4, cmdunit);
    35373540                        writeln(cmdunit, " instead of ");
    3538                         puthn((int32_t)BPINST, 4, cmdunit);
     3541                        puthn((uint32_t)BPINST, 4, cmdunit);
    35393542                        writeln(cmdunit, " **\r\n\n");
    35403543                        rc = TRUE;
     
    35583561
    35593562                        writeln(cmdunit, "** Breakpoint word at ");
    3560                         puthn((int32_t)p_ba0, 8 , cmdunit);
     3563                        puthn((uint32_t)p_ba0, 8 , cmdunit);
    35613564                        writeln(cmdunit, " was ");
    3562                         puthn(0xFFFFL & (int32_t)(*p_ba1), 4, cmdunit);
     3565                        puthn(0xFFFFL & (uint32_t)(*p_ba1), 4, cmdunit);
    35633566                        writeln(cmdunit, " instead of ");
    3564                         puthn((int32_t)BPINST, 4, cmdunit);
     3567                        puthn((uint32_t)BPINST, 4, cmdunit);
    35653568                        writeln(cmdunit, " **\r\n\n");
    35663569                        rc = TRUE;
     
    36173620
    36183621                for (i = 0; i < 7; i++)         /* clear a0..a6 */
    3619                         regptr->a_reg[i] = (int8_t *)0L;
     3622                        regptr->a_reg[i] = 0L;
    36203623
    36213624                regptr->a_reg[7] = ISTACK;      /* setup initial stack */
     
    36823685        writeln(cmdunit, "\r\n  BIOS Version ");
    36833686        pcptr = (int8_t *)PRM_VERS;
    3684         putn((int32_t)*pcptr++, 2, cmdunit);
     3687        putn((uint32_t)*pcptr++, 2, cmdunit);
    36853688        BIOS(B_PUTC, cmdunit, '.');
    3686         putn((int32_t)*pcptr++, 2, cmdunit);
     3689        putn((uint32_t)*pcptr++, 2, cmdunit);
    36873690        writeln(cmdunit, promdate);
    36883691
  • rom/romp.x

    r33b5477 r298f0b4  
    122122extern  int16_t         cx_dini(void);
    123123extern  int16_t         cx_dump(void);
    124 extern  void            cx_exit(void);
     124extern  int16_t         cx_exit(void);
    125125extern  int16_t         cx_fill(void);
    126126extern  int16_t         cx_go(void);
     
    137137extern  int16_t         cx_read(void);
    138138extern  int16_t         cx_regs(void);
    139 extern  void            cx_rest(void);
     139extern  int16_t         cx_rest(void);
    140140extern  int16_t         cx_rset(void);
    141141extern  int16_t         cx_vreg(void);
     
    145145extern  int16_t         cx_writ(void);
    146146extern  int16_t         cx_wset(void);
    147 extern  void            cx_zap(void);
     147extern  int16_t         cx_zap(void);
    148148extern  int16_t         ddump(int8_t *loc, int8_t *lastloc, int16_t nwide, int16_t unit);
    149149extern  void            do_cmd(void);
     
    162162extern  void            progid(void);
    163163extern  int16_t         pscan(void);
    164 extern  void            puthn(int32_t num, int16_t cw, int16_t unit);
    165 extern  void            putn(int32_t num, int16_t cw, int16_t unit);
     164extern  void            puthn(uint32_t num, int16_t cw, int16_t unit);
     165extern  void            putn(uint32_t num, int16_t cw, int16_t unit);
    166166extern  void            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, uint16_t sr0, uint16_t sr, int8_t *pc);
    167167extern  int16_t         setvar(int32_t *var, int32_t deflt);
Note: See TracChangeset for help on using the changeset viewer.