Changeset 5117699 in buchla-68k


Ignore:
Timestamp:
07/16/2017 02:23:05 PM (3 years ago)
Author:
Thomas Lopatic <thomas@…>
Branches:
master
Children:
4cfe69a
Parents:
897a874
Message:

No more warnings for bios.abs.

Location:
rom
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • rom/romp.c

    r897a874 r5117699  
    266266
    267267uint16_t        *tba0,          /* breakpoint 0 temporary */
    268         *tba1;          /* breakpoint 1 temporary */
     268                *tba1;          /* breakpoint 1 temporary */
    269269
    270270uint16_t        p_bv0,          /* breakpoint 0 value */
    271         p_bv1;          /* breakpoint 1 value */
     271                p_bv1;          /* breakpoint 1 value */
    272272
    273273uint16_t        *p_ba0,         /* breakpoint 0 address */
    274         *p_ba1;         /* breakpoint 1 address */
     274                *p_ba1;         /* breakpoint 1 address */
    275275
    276276jmp_buf restart;        /* jmp environment */
     
    368368
    369369                writeln(cmdunit, "File name: ");
    370                 endc = getln(cmdunit, MAXFNLN+1, bfname);
     370                endc = (int8_t)getln(cmdunit, MAXFNLN+1, bfname);
    371371                writeln(cmdunit, CRLF);
    372372
     
    472472void dosw(int16_t nb, int16_t sv)
    473473{
    474         register uint16_t *bp;
    475         register int16_t i, j;
     474        register uint16_t *bp, j;
     475        register int16_t i;
    476476
    477477        if ((nb LT 1) OR (nb GT 82))
     
    667667
    668668        for (i = 0; i < 22; i++)
    669                 if (c EQ *ap++)
     669                if (c EQ *ap++) {
    670670                        if (i >15)
    671671                                return(i - 6);
    672672                        else
    673673                                return(i);
     674                }
    674675
    675676        return(-1);
     
    699700                case A_LF:
    700701
    701                         argsep = c;
     702                        argsep = (int8_t)c;
    702703                        return(argln);
    703704
     
    712713                                c = 0x00FF & *sptr;
    713714
    714                         argsep = c;
     715                        argsep = (int8_t)c;
    715716                        return(argln);
    716717
     
    720721                                c = _tolower(c);
    721722
    722                         *aptr++ = c;
     723                        *aptr++ = (int8_t)c;
    723724                        ++sptr;
    724725                        ++argln;
     
    753754                case A_LF:
    754755
    755                         argsep = c;
     756                        argsep = (int8_t)c;
    756757                        return(argln);
    757758
     
    766767                                c = 0x00FF & *sptr;
    767768
    768                         argsep = c;
     769                        argsep = (int8_t)c;
    769770                        return(argln);
    770771
     
    772773
    773774                        ++sptr;
    774                         argsep = c;
     775                        argsep = (int8_t)c;
    775776                        return(argln);
    776777
    777778                default:
    778779
    779                         *aptr++ = c;
     780                        *aptr++ = (int8_t)c;
    780781                        ++sptr;
    781782                        ++argln;
     
    901902        putn(num/10, cw-1, unit);
    902903
    903         d =  num % 10;
     904        d =  (int16_t)(num % 10);
    904905
    905906        BIOS(B_PUTC, unit, (d + '0')); 
     
    10601061                        return(FALSE);
    10611062
    1062                 *p_from++ = 0xFF & p_value;
     1063                *p_from++ = (int8_t)(0xFF & p_value);
    10631064
    10641065                if (argsep EQ A_CR)
     
    11131114                        return(FALSE);
    11141115
    1115                 *p_uint++ = 0xFFFF & p_value;
     1116                *p_uint++ = (uint16_t)(0xFFFF & p_value);
    11161117
    11171118                if (argsep EQ A_CR)
     
    11841185                        *loc = mask;
    11851186
    1186                         if (mask NE (was = *loc))
     1187                        if (mask NE (was = *loc)) {
    11871188                                if (p_from LT (int8_t *)USER_RAM)
    11881189                                        halt();
     
    11901191                                        printf("%08lX was %04X, expected %04X\r\n",
    11911192                                                loc, was, mask);
     1193                        }
    11921194
    11931195                        *loc = ~mask;
    11941196
    1195                         if (~mask NE (was = *loc))
     1197                        if (~mask NE (was = *loc)) {
    11961198                                if (p_from LT (int8_t *)USER_RAM)
    11971199                                        halt();
     
    11991201                                        printf("%08lX was %04X, expected %04X\r\n",
    12001202                                                loc, was, ~mask);
     1203                        }
    12011204
    12021205                        mask <<= 1;
     
    13171320        for (i = 0; i < 16; i++) {
    13181321
    1319                 xloc = v_odtab[i][1] & 0x03FF;
     1322                xloc = (int16_t)(v_odtab[i][1] & 0x03FF);
    13201323
    13211324                if (xloc & 0x0200)              /* sign extend xloc */
    1322                         xloc |= 0xFC00;
    1323 
    1324                 width = (v_odtab[i][1] >> 10) & 0x003F;
     1325                        xloc = xloc - 0x400;
     1326
     1327                width = (int16_t)((v_odtab[i][1] >> 10) & 0x003F);
    13251328
    13261329                printf("%2d %s ",
     
    13501353        writeln(cmdunit, CRLF);
    13511354
    1352         for (i = 0; i < NCMDS; i++) {
     1355        for (i = 0; i < (int16_t)NCMDS; i++) {
    13531356
    13541357                if (j++ EQ 22) {
     
    14351438
    14361439        if (goflag)
    1437                 regptr->reg_pc = p_goto;
     1440                regptr->reg_pc = (uint32_t)p_goto;
    14381441
    14391442        if (b0flag ) {
     
    17591762        if (rnum < 9) {         /* d0..d7 -- data register */
    17601763
    1761                 regptr->d_reg[rnum-1] = p_value;
     1764                regptr->d_reg[rnum-1] = (uint32_t)p_value;
    17621765                return(TRUE);
    17631766        }
     
    17651768        if (rnum < 17) {        /* a0..a7 -- address register */
    17661769
    1767                 regptr->a_reg[rnum-9] = p_value;
     1770                regptr->a_reg[rnum-9] = (uint32_t)p_value;
    17681771                return(TRUE);
    17691772        }
     
    17831786                        return(FALSE);
    17841787
    1785                 regptr->reg_pc = p_value;
     1788                regptr->reg_pc = (uint32_t)p_value;
    17861789                return(TRUE);
    17871790        }
     
    17921795                        return(FALSE);
    17931796
    1794                 regptr->a_reg[7] = p_value;
     1797                regptr->a_reg[7] = (uint32_t)p_value;
    17951798                return(TRUE);
    17961799        }
     
    18681871        if (vrnum < 17) {       /* 1..16 -- r0..r15 -- complete register */
    18691872
    1870                 v_regs[vrnum-1] = p_value;
     1873                v_regs[vrnum-1] = (uint16_t)p_value;
    18711874                return(TRUE);
    18721875        }
     
    18751878
    18761879                v_regs[vrnum-5] = (v_regs[vrnum-5] & 0x03FF) |
    1877                         ((p_value << 10) & 0xFC00);
     1880                        (((uint16_t)p_value << 10) & 0xFC00);
    18781881                return(TRUE);
    18791882        }
     
    18811884        if (vrnum < 25) {       /* 21..24 -- v0..v3 -- vertical register */
    18821885
    1883                 v_regs[vrnum-9] = (v_regs[vrnum-9] & 0xFC00) | p_value;
     1886                v_regs[vrnum-9] = (v_regs[vrnum-9] & 0xFC00) | (uint16_t)p_value;
    18841887                return(TRUE);
    18851888        }
     
    19321935{
    19331936        register int8_t *ldadr;
    1934         register int16_t c, csum, i, len;
    1935         register uint16_t val;
     1937        register int16_t c, i, len;
     1938        register uint16_t val, csum;
    19361939
    19371940        if ('S' NE (c = *line++))
     
    19611964
    19621965                        if (isxdigit(c = *line++))
    1963                                 val = xdtoi(c);
     1966                                val = (uint16_t)xdtoi(c);
    19641967                        else
    19651968                                return(-3);     /* error 3 = bad address byte */
    19661969
    19671970                        if (isxdigit(c = *line++))
    1968                                 val = (val << 4) + xdtoi(c);
     1971                                val = (val << 4) + (uint16_t)xdtoi(c);
    19691972                        else
    19701973                                return(-3);
     
    19771980
    19781981                        if (isxdigit(c = *line++))
    1979                                 val = xdtoi(c);
     1982                                val = (uint16_t)xdtoi(c);
    19801983                        else
    19811984                                return(-4);     /* error 4 = bad data byte */
    19821985
    19831986                        if (isxdigit(c = *line++))
    1984                                 val = (val << 4) + xdtoi(c);
     1987                                val = (val << 4) + (uint16_t)xdtoi(c);
    19851988                        else
    19861989                                return(-4);
    19871990
    19881991                        csum += (val & 0xFF);
    1989                         *ldadr = val & 0xFF;
     1992                        *ldadr = (int8_t)(val & 0xFF);
    19901993
    19911994                        if ((*ldadr & 0xFF) NE (val & 0xFF))
     
    19982001
    19992002                if (isxdigit(c = *line++))
    2000                         val = xdtoi(c);
     2003                        val = (uint16_t)xdtoi(c);
    20012004                else
    20022005                        return(-6);             /* error 6 = bad checksum byte */
    20032006
    20042007                if (isxdigit(c = *line++))
    2005                         val = (val << 4) + xdtoi(c);
     2008                        val = (val << 4) + (uint16_t)xdtoi(c);
    20062009                else
    20072010                        return(-6);
     
    22162219        d_next = p_to + 1;
    22172220        d_last = ((int32_t)p_to - (int32_t)p_from) + d_next;
    2218         nw = p_width;
     2221        nw = (int16_t)p_width;
    22192222        rc = TRUE;
    22202223
     
    22822285*/
    22832286
    2284 int16_t ldump(int32_t *loc, int32_t *lastloc, int16_t nwide, int16_t unit)
     2287int16_t ldump(uint32_t *loc, uint32_t *lastloc, int16_t nwide, int16_t unit)
    22852288{
    22862289        while (nwide--) {
    22872290
    2288                 puthn((uint32_t)*loc, 8, unit);
     2291                puthn(*loc, 8, unit);
    22892292                BIOS(B_PUTC,unit, ' ');
    22902293
     
    24482451                return(FALSE);
    24492452
    2450         iplev = iplevl;
     2453        iplev = (int16_t)iplevl;
    24512454
    24522455        return(TRUE);
     
    25382541        case MON_C:
    25392542
    2540                 vc = *monptr & 0x0FF;
     2543                vc = (int8_t)(*monptr & 0x0FF);
    25412544                puthn((uint32_t)vc, 2, cmdunit);
    25422545                writeln(cmdunit, "\r\n");
     
    25442547                while (!(0xFFFFL & BIOS(B_RDAV, CON_DEV))) {
    25452548
    2546                         vcc = *monptr & 0x0FF;
     2549                        vcc = (int8_t)(*monptr & 0x0FF);
    25472550
    25482551                        if (vc NE vcc) {
     
    26212624        d_next = p_to + 2;
    26222625        d_last = ((int32_t)p_to - (int32_t)p_from) + d_next;
    2623         nw = p_width;
     2626        nw = (int16_t)p_width;
    26242627        rc = TRUE;
    26252628
     
    26302633                dflag = FALSE;
    26312634
    2632                 if (wdump(p_from, p_to, nw, cmdunit))
     2635                if (wdump((uint16_t *)p_from, (uint16_t *)p_to, nw, cmdunit))
    26332636                        rc = FALSE;
    26342637
     
    26602663        d_next = p_to + 4;
    26612664        d_last = ((int32_t)p_to - (int32_t)p_from) + d_next;
    2662         nw = p_width;
     2665        nw = (int16_t)p_width;
    26632666        rc = TRUE;
    26642667
     
    26692672                dflag = FALSE;
    26702673
    2671                 if (ldump(p_from, p_to, nw, cmdunit))
     2674                if (ldump((uint32_t *)p_from, (uint32_t *)p_to, nw, cmdunit))
    26722675                        rc = FALSE;
    26732676
     
    27182721                if (getcmd()) {
    27192722
    2720                         for (i = 0; i < NCMDS; i++) {
     2723                        for (i = 0; i < (int16_t)NCMDS; i++) {
    27212724
    27222725                                if (0 EQ strcmp(argstr, cmtab[i].cname)) {
     
    27962799
    27972800        ns = p_len & 0x7FFFL;
    2798         recno = (int32_t)p_from & 0xFFFFL;
     2801        recno = (int16_t)((int32_t)p_from & 0xFFFFL);
    27992802
    28002803        rc = BIOS(B_RDWR, 2, p_to, ns, recno, 0);
     
    28252828
    28262829        ns = p_len & 0x7FFFL;
    2827         recno = (int32_t)p_from & 0xFFFFL;
     2830        recno = (int16_t)((int32_t)p_from & 0xFFFFL);
    28282831
    28292832        rc = BIOS(B_RDWR, 3, p_to, ns, recno, 0);
     
    31543157        rc = FALSE;
    31553158
    3156         if (p_ba0 EQ regptr->reg_pc) {
     3159        if ((uint32_t)p_ba0 EQ regptr->reg_pc) {
    31573160
    31583161                if (*p_ba0 EQ BPINST) {
     
    31763179        }
    31773180
    3178         if (p_ba1 EQ regptr->reg_pc) {
     3181        if ((uint32_t)p_ba1 EQ regptr->reg_pc) {
    31793182
    31803183                if (*p_ba1 EQ BPINST) {
     
    34043407
    34053408                if ((baseled + 3) > 23)                 /* turn on a LED */
    3406                         io_leds = baseled - 21;
     3409                        io_leds = (uint8_t)(baseled - 21);
    34073410                else
    3408                         io_leds = baseled + 3;
    3409 
    3410                 io_leds = 0x80 + baseled;               /* turn off a LED */
     3411                        io_leds = (uint8_t)(baseled + 3);
     3412
     3413                io_leds = (uint8_t)(0x80 + baseled);    /* turn off a LED */
    34113414
    34123415                if (++baseled > 23)                     /* update LED number */
     
    34453448
    34463449                        for (i = 0; i < 24; i++)        /* turn off LEDs */
    3447                                 io_leds = 0x80 + i;
     3450                                io_leds = (uint8_t)(0x80 + i);
    34483451
    34493452                        io_leds = 0x1F;                 /* turn off LCD lamp */
     
    34653468
    34663469                        for (i = 0; i < 24; i++)        /* turn off LEDs */
    3467                                 io_leds = 0x80 + i;
     3470                                io_leds = (uint8_t)(0x80 + i);
    34683471
    34693472                        return(TRUE);
     
    35023505        *pdptr++ = '-';
    35033506        *pdptr++ = ' ';
    3504         *pdptr++ = ((*pcptr >> 4) & 0x0F) + '0';
    3505         *pdptr++ = (*pcptr++ & 0x0F) + '0';
    3506         *pdptr++ = ((*pcptr >> 4) & 0x0F) + '0';
    3507         *pdptr++ = (*pcptr++ & 0x0F) + '0';
     3507        *pdptr++ = (int8_t)(((*pcptr >> 4) & 0x0F) + '0');
     3508        *pdptr++ = (int8_t)((*pcptr++ & 0x0F) + '0');
     3509        *pdptr++ = (int8_t)(((*pcptr >> 4) & 0x0F) + '0');
     3510        *pdptr++ = (int8_t)((*pcptr++ & 0x0F) + '0');
    35083511        *pdptr++ = '-';
    3509         *pdptr++ = ((*pcptr >> 4) & 0x0F) + '0';
    3510         *pdptr++ = (*pcptr++ & 0x0F) + '0';
     3512        *pdptr++ = (int8_t)(((*pcptr >> 4) & 0x0F) + '0');
     3513        *pdptr++ = (int8_t)((*pcptr++ & 0x0F) + '0');
    35113514        *pdptr++ = '-';
    3512         *pdptr++ = ((*pcptr >> 4) & 0x0F) + '0';
    3513         *pdptr++ = (*pcptr++ & 0x0F) + '0';
     3515        *pdptr++ = (int8_t)(((*pcptr >> 4) & 0x0F) + '0');
     3516        *pdptr++ = (int8_t)((*pcptr++ & 0x0F) + '0');
    35143517        *pdptr++ = '\0';
    35153518
  • rom/romp.x

    r897a874 r5117699  
    156156extern  int16_t         getcmd(void);
    157157extern  int16_t         getlong(int32_t *var);
    158 extern  int16_t         ldump(int32_t *loc, int32_t *lastloc, int16_t nwide, int16_t unit);
     158extern  int16_t         ldump(uint32_t *loc, uint32_t *lastloc, int16_t nwide, int16_t unit);
    159159extern  void            main(void);
    160160extern  void            padr(void *adr, int16_t unit);
Note: See TracChangeset for help on using the changeset viewer.