6502
/
cc65
mirror of https://github.com/cc65/cc65.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Code review adaptations, removed "cc65_" prefix from functions

This commit is contained in:
IrgendwerA8 2019-03-29 22:36:01 +01:00 committed by Oliver Schmidt
parent 435f417c64
commit 3d8c3a4948
21 changed files with 107 additions and 148 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

75
doc/funcref.sgml
View File

@ -243,16 +243,19 @@ function.
<sect1><tt/cc65.h/<label id="cc65.h"><p>
<itemize>
<!-- <item><ref id="cc65_cos" name="cc65_cos"> -->
<!-- <item><ref id="cc65_idiv32by16r16" name="cc65_idiv32by16r16"> -->
<!-- <item><ref id="cc65_imul16x16r32" name="cc65_imul16x16r32"> -->
<!-- <item><ref id="cc65_imul8x8r16" name="cc65_imul8x8r16"> -->
<!-- <item><ref id="cc65_sin" name="cc65_sin"> -->
<!-- <item><ref id="cc65_udiv32by16r16" name="cc65_udiv32by16r16"> -->
<!-- <item><ref id="cc65_umul16x16r32" name="cc65_umul16x16r32"> -->
<!-- <item><ref id="cc65_umul16x8r32" name="cc65_umul16x8r32"> -->
<!-- <item><ref id="cc65_umul8x8r16" name="cc65_umul8x8r16"> -->
<!-- <item><ref id="cos" name="cos"> -->
<!-- <item><ref id="idiv32by16r16" name="idiv32by16r16"> -->
<!-- <item><ref id="imul16x16r32" name="imul16x16r32"> -->
<!-- <item><ref id="imul8x8r16" name="imul8x8r16"> -->
<!-- <item><ref id="sin" name="sin"> -->
<!-- <item><ref id="udiv32by16r16" name="udiv32by16r16"> -->
<!-- <item><ref id="umul16x16r32" name="umul16x16r32"> -->
<!-- <item><ref id="umul16x8r32" name="umul16x8r32"> -->
<!-- <item><ref id="umul8x8r16" name="umul8x8r16"> -->
<item><ref id="doesclrscrafterexit" name="doesclrscrafterexit">
<item><ref id="mul20" name="mul20">
<item><ref id="mul40" name="mul40">
</itemize>
(incomplete)
@ -578,13 +581,6 @@ communication, see also <tt>testcode/lib/ser-test.c</tt>.
<item><ref id="signal" name="signal">
</itemize>
<sect1><tt/specialmath.h/<label id="specialmath.h"><p>
<itemize>
<item><ref id="_mul20" name="_mul20">
<item><ref id="_mul40" name="_mul40">
</itemize>
<sect1><tt/stdarg.h/<label id="stdarg.h"><p>
(incomplete)
@ -1026,30 +1022,6 @@ It returns 1 if it does.
</descrip>
</quote>
<sect1>_mul20<label id="_mul20"><p>
<quote>
<descrip>
<tag/Function/Multiplies argument by 20.
<tag/Header/<tt/<ref id="specialmath.h" name="specialmath.h">/
<tag/Declaration/<tt/unsigned int __fastcall__ _mul20(unsigned char value);/
<tag/Description/Speed optimized function to multiply an 8 bit unsigned value by 20 to get a 16 bit result.
<tag/Availability/cc65
</descrip>
</quote>
<sect1>_mul40<label id="_mul40"><p>
<quote>
<descrip>
<tag/Function/Multiplies argument by 40.
<tag/Header/<tt/<ref id="specialmath.h" name="specialmath.h">/
<tag/Declaration/<tt/unsigned int __fastcall__ _mul40(unsigned char value);/
<tag/Description/Speed optimized function to multiply an 8 bit unsigned value by 40 to get a 16 bit result.
<tag/Availability/cc65
</descrip>
</quote>
<sect1>_poserror<label id="_poserror"><p>
<quote>
@ -5587,6 +5559,29 @@ memory allocated for the driver.
</descrip>
</quote>
<sect1>mul20<label id="mul20"><p>
<quote>
<descrip>
<tag/Function/Multiplies argument by 20.
<tag/Header/<tt/<ref id="cc65.h" name="cc65.h">/
<tag/Declaration/<tt/unsigned int __fastcall__ mul20(unsigned char value);/
<tag/Description/Speed optimized function to multiply an 8 bit unsigned value by 20 to get a 16 bit result.
<tag/Availability/cc65
</descrip>
</quote>
<sect1>mul40<label id="mul40"><p>
<quote>
<descrip>
<tag/Function/Multiplies argument by 40.
<tag/Header/<tt/<ref id="cc65.h" name="cc65.h">/
<tag/Declaration/<tt/unsigned int __fastcall__ mul40(unsigned char value);/
<tag/Description/Speed optimized function to multiply an 8 bit unsigned value by 40 to get a 16 bit result.
<tag/Availability/cc65
</descrip>
</quote>
<sect1>offsetof<label id="offsetof"><p>

28
include/cc65.h
View File

@ -44,43 +44,53 @@
long __fastcall__ cc65_idiv32by16r16 (long rhs, int lhs);
long __fastcall__ idiv32by16r16 (long rhs, int lhs);
/* Divide a 32 bit signed value by a 16 bit signed value yielding a 16
** bit result and a 16 bit remainder. The former is returned in the lower 16
** bit of the result, the latter in the upper. If you don't need the
** remainder, just assign (or cast) to an int.
*/
unsigned long __fastcall__ cc65_udiv32by16r16 (unsigned long rhs, unsigned lhs);
unsigned long __fastcall__ udiv32by16r16 (unsigned long rhs, unsigned lhs);
/* Divide a 32 bit unsigned value by a 16 bit unsigned value yielding a 16
** bit result and a 16 bit remainder. The former is returned in the lower 16
** bit of the result, the latter in the upper. If you don't need the
** remainder, just assign (or cast) to an unsigned.
*/
int __fastcall__ cc65_imul8x8r16 (signed char lhs, signed char rhs);
int __fastcall__ imul8x8r16 (signed char lhs, signed char rhs);
/* Multiplicate two signed 8 bit to yield an signed 16 bit result */
long __fastcall__ cc65_imul16x16r32 (int lhs, int rhs);
long __fastcall__ imul16x16r32 (int lhs, int rhs);
/* Multiplicate two signed 16 bit to yield a signed 32 bit result */
unsigned __fastcall__ cc65_umul8x8r16 (unsigned char lhs, unsigned char rhs);
unsigned __fastcall__ umul8x8r16 (unsigned char lhs, unsigned char rhs);
/* Multiplicate two unsigned 8 bit to yield an unsigned 16 bit result */
unsigned long __fastcall__ cc65_umul16x8r32 (unsigned lhs, unsigned char rhs);
unsigned long __fastcall__ umul16x8r32 (unsigned lhs, unsigned char rhs);
/* Multiplicate an unsigned 16 bit by an unsigned 8 bit number yielding a 24
** bit unsigned result that is extended to 32 bits for easier handling from C.
*/
unsigned long __fastcall__ cc65_umul16x16r32 (unsigned lhs, unsigned rhs);
unsigned long __fastcall__ umul16x16r32 (unsigned lhs, unsigned rhs);
/* Multiplicate two unsigned 16 bit to yield an unsigned 32 bit result */
int __fastcall__ cc65_sin (unsigned x);
unsigned int __fastcall__ mul20(unsigned char value);
/* Multiply an 8 bit unsigned value by 20 and return the 16 bit unsigned
** result
*/
unsigned int __fastcall__ mul40(unsigned char value);
/* Multiply an 8 bit unsigned value by 40 and return the 16 bit unsigned
** result
*/
int __fastcall__ sin (unsigned x);
/* Return the sine of the argument, which must be in range 0..360. The result
** is in 8.8 fixed point format, which means that 1.0 = $100 and -1.0 = $FF00.
*/
int __fastcall__ cc65_cos (unsigned x);
int __fastcall__ cos (unsigned x);
/* Return the cosine of the argument, which must be in range 0..360. The result
** is in 8.8 fixed point format, which means that 1.0 = $100 and -1.0 = $FF00.
*/

46
include/specialmath.h
View File

@ -1,46 +0,0 @@
/*****************************************************************************/
/* */
/* specialmath.h */
/* */
/* Optimized math routines for special usages */
/* */
/* */
/* */
/* (C) 2019 Christian 'Irgendwer' Krueger */
/* */
/* This software is provided 'as-is', without any expressed or implied */
/* warranty. In no event will the authors be held liable for any damages */
/* arising from the use of this software. */
/* */
/* Permission is granted to anyone to use this software for any purpose, */
/* including commercial applications, and to alter it and redistribute it */
/* freely, subject to the following restrictions: */
/* */
/* 1. The origin of this software must not be misrepresented; you must not */
/* claim that you wrote the original software. If you use this software */
/* in a product, an acknowledgment in the product documentation would be */
/* appreciated but is not required. */
/* 2. Altered source versions must be plainly marked as such, and must not */
/* be misrepresented as being the original software. */
/* 3. This notice may not be removed or altered from any source */
/* distribution. */
/* */
/*****************************************************************************/
#ifndef _SPECIALMATH_H
#define _SPECIALMATH_H
/* Multiply an 8 bit unsigned value by 20 and return the 16 bit unsigned result */
unsigned int __fastcall__ _mul20(unsigned char value);
/* Multiply an 8 bit unsigned value by 40 and return the 16 bit unsigned result */
unsigned int __fastcall__ _mul40(unsigned char value);
/* End of specialmath.h */
#endif

4
libsrc/atari/cputc.s
View File

@ -7,7 +7,7 @@
.export _cputcxy, _cputc
.export plot, cputdirect, putchar
.import gotoxy, __mul40
.import gotoxy, _mul40
.importzp tmp4,ptr4
.import _revflag,setcursor
@ -71,7 +71,7 @@ putchar:
sta (OLDADR),y
lda ROWCRS
jsr __mul40 ; destroys tmp4, carry is cleared
jsr _mul40 ; destroys tmp4, carry is cleared
adc SAVMSC ; add start of screen memory
sta ptr4
txa

4
libsrc/atari/mcbtxtchar.s
View File

@ -12,7 +12,7 @@
.export _mouse_txt_callbacks
.importzp tmp4
.import __mul40
.import _mul40
.importzp mouse_txt_char ; screen code of mouse cursor
.include "atari.inc"
@ -108,7 +108,7 @@ movey:
lsr a ; convert y position to character line
lsr a
lsr a
jsr __mul40 ; carry is cleared by _mul40
jsr _mul40 ; carry is cleared by _mul40
adc SAVMSC
sta scrptr
txa

6
libsrc/atari/scroll.s
View File

@ -8,7 +8,7 @@
.include "atari.inc"
.importzp tmp1,tmp4,ptr1,ptr2
.import __mul40,_clrscr
.import _mul40,_clrscr
.export __scroll
.proc __scroll
@ -40,7 +40,7 @@ down_ok:lda SAVMSC
sta ptr2+1
lda tmp1
jsr __mul40
jsr _mul40
sta tmp4
lda ptr2
sec
@ -103,7 +103,7 @@ up: sta tmp1 ; # of lines to scroll
jmp _clrscr
;multiply by 40 (xsize)
up_ok: jsr __mul40 ; carry is cleared by __mul40
up_ok: jsr _mul40 ; carry is cleared by _mul40
adc SAVMSC ; add start of screen mem
sta ptr2
txa

4
libsrc/atari/setcursor.s
View File

@ -4,7 +4,7 @@
; cursor handling, internal function
.include "atari.inc"
.import cursor,__mul40
.import cursor,_mul40
.export setcursor
.proc setcursor
@ -14,7 +14,7 @@
sta (OLDADR),y
lda ROWCRS
jsr __mul40 ; function leaves with carry clear!
jsr _mul40 ; function leaves with carry clear!
adc SAVMSC ; add start of screen memory
sta OLDADR
txa

4
libsrc/atari5200/cputc.s
View File

@ -10,7 +10,7 @@
.export _cputcxy, _cputc
.export plot, cputdirect, putchar
.import gotoxy, __mul20
.import gotoxy, _mul20
.importzp ptr4
.import setcursor
@ -75,7 +75,7 @@ putchar:
pha ; save char
lda ROWCRS_5200
jsr __mul20 ; destroys tmp4, carry is cleared
jsr _mul20 ; destroys tmp4, carry is cleared
adc SAVMSC ; add start of screen memory
sta ptr4
txa

4
libsrc/common/cc65_idiv32by16r16.s → libsrc/common/idiv32by16r16.s
View File

@ -4,7 +4,7 @@
; CC65 library: 32by16 => 16 signed division
;
.export _cc65_idiv32by16r16
.export _idiv32by16r16
.import idiv32by16r16, incsp4
.include "zeropage.inc"
@ -13,7 +13,7 @@
;---------------------------------------------------------------------------
; 32by16 division.
.proc _cc65_idiv32by16r16
.proc _idiv32by16r16
pha ; Save rhs

4
libsrc/common/cc65_imul16x16r32.s → libsrc/common/imul16x16r32.s
View File

@ -4,7 +4,7 @@
; CC65 library: 16x16 => 32 signed multiplication
;
.export _cc65_imul16x16r32
.export _imul16x16r32
.import imul16x16r32, popax
.include "zeropage.inc"
@ -14,7 +14,7 @@
; 16x16 => 32 signed multiplication routine.
.proc _cc65_imul16x16r32
.proc _imul16x16r32
sta ptr1
stx ptr1+1

4
libsrc/common/cc65_imul8x8r16.s → libsrc/common/imul8x8r16.s
View File

@ -5,7 +5,7 @@
; CC65 library: 8x8 => 16 signed multiplication
;
.export _cc65_imul8x8r16
.export _imul8x8r16
.import imul8x8r16, popa, ptr1:zp
@ -13,7 +13,7 @@
; 8x8 => 16 signed multiplication routine.
.proc _cc65_imul8x8r16
.proc _imul8x8r16
sta ptr1
jsr popa

12
libsrc/common/_mul20.s → libsrc/common/mul20.s
View File

@ -8,15 +8,15 @@
; See "LICENSE" file for legal information.
;
;
; unsigned int __fastcall__ _mul20(unsigned char value);
; unsigned int __fastcall__ mul20(unsigned char value);
;
; REMARKS: Function is defined to return with carry-flag cleared
.importzp tmp4
.export __mul20
.export _mul20
.proc __mul20 ; = 30 bytes, 41/46 cycles
.proc _mul20 ; = 30 bytes, 41/46 cycles
sta tmp4 ; remember value for later addition...
ldx #0 ; clear high-byte
@ -24,7 +24,7 @@
bcc mul4 ; high-byte affected?
ldx #2 ; this will be the 1st high-bit soon...
mul4: asl a ; * 4
mul4: asl a ; * 4
bcc mul5 ; high-byte affected?
inx ; => yes, apply to 0 high-bit
clc ; prepare addition
@ -36,9 +36,9 @@ mul5: adc tmp4 ; * 5
mul10: stx tmp4 ; continue with classic shifting...
asl a ; * 10
rol tmp4
rol tmp4
asl a ; * 20
asl a ; * 20
rol tmp4
ldx tmp4 ; deliver high-byte in X

12
libsrc/common/_mul40.s → libsrc/common/mul40.s
View File

@ -8,15 +8,15 @@
; See "LICENSE" file for legal information.
;
;
; unsigned int __fastcall__ _mul40(unsigned char value);
; unsigned int __fastcall__ mul40(unsigned char value);
;
; REMARKS: Function is defined to return with carry-flag cleared
.importzp tmp4
.export __mul40
.export _mul40
.proc __mul40 ; = 33 bytes, 48/53 cycles
.proc _mul40 ; = 33 bytes, 48/53 cycles
sta tmp4 ; remember value for later addition...
ldx #0 ; clear high-byte
@ -24,7 +24,7 @@
bcc mul4 ; high-byte affected?
ldx #2 ; this will be the 1st high-bit soon...
mul4: asl a ; * 4
mul4: asl a ; * 4
bcc mul5 ; high-byte affected?
inx ; => yes, apply to 0 high-bit
clc ; prepare addition
@ -36,9 +36,9 @@ mul5: adc tmp4 ; * 5
mul10: stx tmp4 ; continue with classic shifting...
asl a ; * 10
rol tmp4
rol tmp4
asl a ; * 20
asl a ; * 20
rol tmp4
asl a ; * 40

14
libsrc/common/cc65_sincos.s → libsrc/common/sincos.s
View File

@ -13,7 +13,7 @@
; Ullrich von Bassewitz, 2009-10-29
;
.export _cc65_cos, _cc65_sin
.export _cos, _sin
; ---------------------------------------------------------------------------
@ -23,7 +23,7 @@
.rodata
_cc65_sintab:
_sintab:
.byte $00, $04, $09, $0D, $12, $16, $1B, $1F, $24, $28
.byte $2C, $31, $35, $3A, $3E, $42, $47, $4B, $4F, $53
.byte $58, $5C, $60, $64, $68, $6C, $70, $74, $78, $7C
@ -41,7 +41,7 @@ _cc65_sintab:
.code
_cc65_cos:
_cos:
; cos(x) = sin(x+90)
@ -55,7 +55,7 @@ _cc65_cos:
@L1: cpx #>360
bne @L2
cmp #<360
@L2: bcc _cc65_sin
@L2: bcc _sin
sbc #<360
bcs @L3
@ -71,7 +71,7 @@ _cc65_cos:
;
; Plus special handling for the values missing in the table.
_cc65_sin:
_sin:
; If the high byte is non zero, argument is > 255
@ -114,7 +114,7 @@ L1: cmp #87
L2: tay
ldx #0
lda _cc65_sintab,y
lda _sintab,y
rts
; 180..360°. sin(x) = -sin(x-180). Since the argument is in range 0..180
@ -155,7 +155,7 @@ L5: ldx #$FF
L6: tay
txa ; A = $FF
eor _cc65_sintab,y
eor _sintab,y
adc #1
bcc L7
inx

4
libsrc/common/cc65_udiv32by16r16.s → libsrc/common/udiv32by16r16.s
View File

@ -4,7 +4,7 @@
; CC65 library: 32by16 => 16 unsigned division
;
.export _cc65_udiv32by16r16
.export _udiv32by16r16
.import udiv32by16r16m, incsp4
.include "zeropage.inc"
@ -13,7 +13,7 @@
;---------------------------------------------------------------------------
; 32by16 division.
.proc _cc65_udiv32by16r16
.proc _udiv32by16r16
sta ptr3
stx ptr3+1 ; Store rhs

4
libsrc/common/cc65_umul16x16r32.s → libsrc/common/umul16x16r32.s
View File

@ -4,7 +4,7 @@
; CC65 library: 16x16 => 32 unsigned multiplication
;
.export _cc65_umul16x16r32
.export _umul16x16r32
.import umul16x16r32, popax
.include "zeropage.inc"
@ -13,7 +13,7 @@
;---------------------------------------------------------------------------
; 16x16 => 32 unsigned multiplication routine.
.proc _cc65_umul16x16r32
.proc _umul16x16r32
sta ptr1
stx ptr1+1

4
libsrc/common/cc65_umul16x8r32.s → libsrc/common/umul16x8r32.s
View File

@ -4,7 +4,7 @@
; CC65 library: 16x8 => 32 unsigned multiplication
;
.export _cc65_umul16x8r32
.export _umul16x8r32
.import umul8x16r24, popax
.include "zeropage.inc"
@ -14,7 +14,7 @@
; 16x8 => 32 unsigned multiplication routine. We use 8x16 => 24 and clear
; the high byte of the result
.proc _cc65_umul16x8r32
.proc _umul16x8r32
sta ptr1
lda #0

4
libsrc/common/cc65_umul8x8r16.s → libsrc/common/umul8x8r16.s
View File

@ -4,7 +4,7 @@
; CC65 library: 8x8 => 16 unsigned multiplication
;
.export _cc65_umul8x8r16
.export _umul8x8r16
.import umul8x8r16, popa, ptr1:zp
@ -12,7 +12,7 @@
; 8x8 => 16 unsigned multiplication routine.
.proc _cc65_umul8x8r16
.proc _umul8x8r16
sta ptr1
jsr popa

8
libsrc/tgi/tgi_arc.c
View File

@ -70,16 +70,16 @@ void __fastcall__ tgi_arc (int x, int y, unsigned char rx, unsigned char ry,
}
/* Calculate the start coords */
x1 = x + tgi_imulround (rx, cc65_cos (sa));
y1 = y - tgi_imulround (ry, cc65_sin (sa));
x1 = x + tgi_imulround (rx, cos (sa));
y1 = y - tgi_imulround (ry, sin (sa));
do {
sa += inc;
if (sa >= ea) {
sa = ea;
done = 1;
}
x2 = x + tgi_imulround (rx, cc65_cos (sa));
y2 = y - tgi_imulround (ry, cc65_sin (sa));
x2 = x + tgi_imulround (rx, cos (sa));
y2 = y - tgi_imulround (ry, sin (sa));
tgi_line (x1, y1, x2, y2);
x1 = x2;
y1 = y2;

4
libsrc/tgi/tgi_pieslice.c
View File

@ -57,8 +57,8 @@ void __fastcall__ tgi_pieslice (int x, int y, unsigned char rx, unsigned char ry
tgi_arc (x, y, rx, ry, sa, ea);
/* ... and close it */
tgi_line (x, y, x + tgi_imulround (rx, cc65_cos (sa)), y - tgi_imulround (ry, cc65_sin (sa)));
tgi_line (x, y, x + tgi_imulround (rx, cc65_cos (ea)), y - tgi_imulround (ry, cc65_sin (ea)));
tgi_line (x, y, x + tgi_imulround (rx, cos (sa)), y - tgi_imulround (ry, sin (sa)));
tgi_line (x, y, x + tgi_imulround (rx, cos (ea)), y - tgi_imulround (ry, sin (ea)));
}

6
test/val/lib_common_mulxx.c
View File

@ -1,4 +1,4 @@
#include <specialmath.h>
#include <cc65.h>
#include "unittest.h"
TEST
@ -7,12 +7,12 @@ TEST
for (i=0; i < 256; ++i)
{
ASSERT_AreEqual(i*20, _mul20(i), "%u", "Invalid 'mul20(%u)' calculation!" COMMA i);
ASSERT_AreEqual(i*20, mul20(i), "%u", "Invalid 'mul20(%u)' calculation!" COMMA i);
}
for (i=0; i < 256; ++i)
{
ASSERT_AreEqual(i*40, _mul40(i), "%u", "Invalid 'mul40(%u)' calculation!" COMMA i);
ASSERT_AreEqual(i*40, mul40(i), "%u", "Invalid 'mul40(%u)' calculation!" COMMA i);
}
}
ENDTEST