OpenCores
URL https://opencores.org/ocsvn/thor/thor/trunk

Subversion Repositories thor

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /thor/trunk/software
    from Rev 20 to Rev 22
    ↔ Reverse comparison
  •

Rev 20 → Rev 22

/c64libc/source/stdlib.c
0,0 → 1,143
#include <stdlib.h>
 
int (abs)(int i)
{
return ((i < 0) ? -i : i);
}
 
div_t (div)(int numer, int denom)
{
div_t val;
 
val.quot = numer / denom;
val.rem = numer - denom * val.quot;
if (val.quot < 0 && 0 < val.rem) {
val.quot += 1;
val.rem -= denom;
}
return (val);
}
 
long (labs)(long i)
{
return ((i < 0) ? -i : i);
}
 
ldiv_t (ldiv)(long numer, long denom)
{
ldiv_t val;
 
val.quot = numer / denom;
val.rem = numer - denom * val.quot;
if (val.quot < 0 && 0 < val.rem) {
val.quot += 1;
val.rem -= denom;
}
return (val);
}
 
void *(bsearch)(const void *key, const void *base, size_t nelem, size_t size, _Cmpfun *cmp)
{
const char *p;
size_t n;
 
p = base;
for (p = base, n = nelem; 0 < n;) {
const size_t pivot = n >> 1;
const char *q = p + size * pivot;
const int val = (*cmp)(key,q);
 
if (val < 0)
n = pivot;
else if (val == 0)
return ((void *)q);
else {
p = q + size;
n -= pivot + 1;
}
}
return NULL;
}
 
void (qsort)(void *base, size_t n, size_t size, _Cmpfun *cmp)
{
size_t i;
size_t j;
char *qi;
char *qj;
char *qp;
char *q1;
char *q2;
char buf[256];
size_t m, ms;
 
while (1 < n) {
i = 0;
j = n - 1;
qi = base;
qj = qi + size * j;
qp = qj;
 
while (i < j) {
while (i < j && (*cmp)(qi,qp) <= 0)
++i, qi += size;
while (i < j && (*cmp)(qp,qj) <= 0)
--j, qj -= size;
if (i < j) {
for (ms = size; 0 < ms; ms -= m, q1 += m, q2 -= m) {
m = ms < sizeof(buf) ? ms : sizeof(buf);
memcpy(buf, q1, m);
memcpy(q1, q2, m);
memcpy(q2, buf, m);
}
++i, qi += size;
--j, qj -= size;
}
}
if (qi != qp) {
for (m = size; 0 < ms; ms -= m, q1 += m, q2 -= m) {
m = ms < sizeof(buf) ? ms : sizeof(buf);
memcpy(buf, q1, m);
memcpy(q1, q2, m);
memcpy(q2, buf, m);
}
}
j = n - i;
if (j < i) {
if (1 < j)
qsort(qi, j, size, cmp);
n = i;
}
else {
if (1 < i)
qsort(base, i, size, cmp);
base = qi;
n = j;
}
}
}
 
 
// seed the random number generator
void (srand)(unsigned int seed)
{
_Randseed = seed;
}
 
// generate a random number in the range 0 to max-1
int (rand)(void)
{
_Randseed = _Randseed * 1103515245 + 12345;
return ((unsigned int)(_Randseed >> 16) & RAND_MAX);
}
 
int (atoi)(const char *s)
{
return ((int)_Stoul(s, NULL, 10));
}
 
long (atol)(const char *s)
{
return ((long)_Stoul(s, NULL, 10));
}
 
/c64libc/source/stdio.c
0,0 → 1,245
//#include "c:\AtlysCores\RTF65000\trunk\software\stdio.h"
extern pascal int prtdbl(double,int,int,char E);
 
typedef union tagval {
__int64 i;
double d;
} uval;
 
pascal void putch(char ch)
{
asm {
addui sp,sp,#-8
sw r6,[sp]
lw r1,32[bp]
ldi r6,#14 ; Teletype output function
sys #10 ; Video BIOS call
lw r6,[sp]
addui sp,sp,#8
}
}
 
pascal void putnum(int num, int wid, char sep, char padchar)
{
int n, m10;
char sign;
static char numwka[200];
 
asm {
ldi r1,#80
sc r1,hs:LEDS
}
if (wid < 0 or wid > 200) // take care of nutty parameter
wid = 0;
sign = num < 0 ? '-' : '+';
if (num < 0) num = -num;
n = 0;
do {
if ((n % 4)==3 && sep) {
numwka[n]=sep;
n++;
}
m10 = num % 10;
numwka[n] = m10 + '0';
num = num / 10;
n++;
} until (num == 0 or n > 18);
if (sign=='-') {
numwka[n] = sign;
n++;
}
asm {
ldi r1,#88
sc r1,hs:LEDS
}
for (; n < wid; wid--)
putch(padchar);
asm {
ldi r1,#89
sc r1,hs:LEDS
}
while (n > 0) {
--n;
putch(numwka[n]);
}
asm {
ldi r1,#90
sc r1,hs:LEDS
}
}
 
pascal void puthexnum(int num, int wid, int ul, char padchar)
{
int n, m;
char sign;
char numwka[200];
 
if (wid < 0 or wid > 200) // take care of nutty parameter
wid = 0;
n = 0;
sign = num < 0 ? '-' : '+';
if (num < 0) num = -num;
do {
m = num & 15;
if (m < 10)
numwka[n] = m + '0';
else if (ul)
numwka[n] = m + 'A'-10;
else
numwka[n] = m + 'a'-10;
num = num >> 4;
n++;
}
while (num != 0 && n < 18);
if (sign=='-') {
numwka[n] = sign;
n++;
}
while (n < wid) {
putch(sign=='-' ? ' ' : padchar);
wid--;
}
while (n > 0) {
--n;
putch(numwka[n]);
}
}
 
pascal int putstr(char *p, int maxchars)
{
char *q;
 
for (q = p; *p && maxchars > 0; p++, maxchars--)
putch(*p);
return p-q;
}
 
pascal void putstr2(char *p)
{
asm {
addui sp,sp,#-8
sw r6,[sp]
lw r1,24[bp]
ldi r6,#$1B ; Video BIOS DisplayString16 function
sys #10
lw r6,[sp]
addui sp,sp,#8
}
}
 
int getcharNoWait()
{
return KeybdGetBufferedCharNoWait();
}
 
/*
naked int getcharNoWait()
{
asm {
push lr
bsr KeybdGetBufferedCharNoWait_
pop lr
rtl
push r6
ld r6,#3 ; KeybdGetCharNoWait
sys #10
pop r6
rtl
}
}
*/
 
int (getchar)()
{
int ch;
 
do {
ch = getcharNoWait();
}
while (ch==-1);
return ch & 255;
}
 
 
int printf(char *p, ...)
{
int *q;
int fmtwidth;
int maxwidth;
int wd;
uval v;
char padchar;
q = &p;
 
for (; *p; p++) {
padchar = ' ';
if (*p=='%') {
fmtwidth = 0;
maxwidth = 65535;
p++;
j1:
switch(*p) {
case '%':
putch('%');
break;
case 'c':
q++;
putch(*q);
break;
case 'd':
q++;
putnum(*q,fmtwidth,0,padchar);
break;
case 'e':
case 'E':
q++;
v.i = *q;
prtdbl(v.d,fmtwidth,maxwidth,*p);
break;
case 'x':
q++;
puthexnum(*q,fmtwidth,0,padchar);
break;
case 'X':
q++;
puthexnum(*q,fmtwidth,1,padchar);
break;
case 's':
q++;
wd = putstr(*q,maxwidth);
//while (wd < fmtwidth) {
// putch(' ');
// wd++;
//}
break;
// width specification
case '0':
padchar = '0';
case '1','2','3','4','5','6','7','8','9':
fmtwidth = *p - '0';
p++;
while (isdigit(*p)) {
fmtwidth *= 10;
fmtwidth += *p - '0';
p++;
}
if (*p != '.')
goto j1;
case '.':
p++;
if (!isdigit(*p))
goto j1;
maxwidth = *p - '0';
p++;
while (isdigit(*p)) {
maxwidth *= 10;
maxwidth += *p - '0';
p++;
}
goto j1;
}
}
else
putch(*p);
}
}
/c64libc/source/ctype.c
0,0 → 1,99
 
int isxdigit(char ch)
{
if (ch >= 'A' and ch <= 'F') return true;
if (ch >= 'a' and ch <= 'f') return true;
if (ch >= '0' and ch <= '9') return true;
return false;
}
 
int isdigit(char ch)
{
if (ch >= '0' and ch <= '9')
return true;
return false;
}
 
int isalpha(char ch)
{
if (ch >= 'a' and ch <= 'z')
return true;
if (ch >= 'A' and ch <= 'Z')
return true;
return false;
}
 
int isalnum(char ch)
{
if (ch >= '0' and ch <= '9')
return true;
if (ch >= 'a' and ch <= 'z')
return true;
if (ch >= 'A' and ch <= 'Z')
return true;
return false;
}
 
// ToDo: add vertical tab
int isspace(char ch)
{
if (ch==' ') return true;
if (ch=='\t') return true;
if (ch=='\n') return true;
if (ch=='\r') return true;
if (ch=='\f') return true;
return false;
}
 
int tolower(char ch)
{
if (ch >= 'A' and ch <= 'Z')
ch = ch - 'A' + 'a';
return ch;
}
 
int toupper(char ch)
{
if (ch >= 'a' and ch <= 'a')
ch = ch - 'a' + 'A';
return ch;
}
 
int isupper(char ch)
{
return ch >= 'A' and ch <= 'Z';
}
 
int islower(char ch)
{
return ch >= 'a' and ch <= 'z';
}
 
int ispunct(char ch)
{
switch(ch) {
case '!','"','#','%','&','\'','(',')',';','<','=','>','?',
'[','\\',']','*','+',',','-','.','/',':','^':
return true;
default: return false;
}
}
 
int isgraph(char ch)
{
return ispunct(ch) || isalnum(ch);
}
 
int isprint(char ch)
{
return isgraph(ch) || ch==' ';
}
 
int iscntrl(char ch)
{
switch(ch) {
// ToDo: add VT
case '\t','\f','\r','\n','\b','\007': return true;
default: return false;
}
}
/c64libc/source/stdlib.h
0,0 → 1,85
#ifndef _STDLIB
#define _STDLIB
#ifndef _YVALS
#include <yvals.h>
#endif
 
 
#define NULL _NULL
#define EXIT_FAILURE _EXFAIL
#define EXIT_SUCCESS 0
#define MB_CUR_MAX _Mbcurmax
#define RAND_MAX 32767
 
#ifndef _SIZET
#define _SIZET
typedef _Sizet size_t;
#endif
#ifndef _WCHART
#define _WCHART
// wchar_t is a type in C64
//typedef _Wchart wchar_t;
#endif
typedef struct {
int quot;
int rem;
} div_t;
typedef struct {
long quot;
long rem;
} ldiv_t;
typedef int _Cmpfun(const void *, const void *);
typedef struct {
unsigned char _State;
unsigned short _Wchar;
} _Mbsave;
 
 
void abort(void);
int abs(int);
int atexit(void (*)(void));
double atof(const char *);
int atoi(const char *);
long atol(const char *);
void bsearch(const void *, const void *, size_t, size_t, _Cmpfun *);
void *calloc(size_t, size_t);
div_t div(int, int);
void exit(int);
void free(void *);
char *getenv(const char *);
long labs(long);
ldiv_t ldiv(long, long);
void *malloc(size_t);
int mblen(const char *, size_t);
size_t mbstowcs(wchar_t *, const char *, size_t);
int mbtowc(wchar_t *, const char *, size_t);
 
//void qsort(void *, size_t, size_t, _Cmpfun *);
 
int rand(int);
void *realloc(void *, size_t);
void srand(unsigned int);
double strtod(const char *, char **);
long strtol(const char *, char **, int);
unsigned long strtoul(const char *, char **, int);
int system(const char *);
size_t wcstombs(char *, const wchar_t *, size_t);
int wctomb(char *, wchar_t);
int _Mbtowc(wchar_t *, const char *, size_t, _Mbsave *);
double _Stod(const char *, char **);
unsigned long _Stoul(const char *, char **, int);
int _Wctomb(char *, wchar_t, char *);
extern char _Mbcurmax, _Wcxtomb;
extern _Mbsave _Mbxlen, _Mbxtowc;
extern unsigned long _Randseed;
 
#define atof(s) _Stod(s, 0)
#define atoi(s) (int)_Stoul(s,0,10)
#define atol(s) (long)_Stoul(s,0,10)
#define mblen(s,n) _Mbtowc(0,s,n,&_Mbxlen)
#define mbtowc(pwc,s,n) _Mbtowc(pwc,s,n,&_Mbxtowc)
#define srand(seed) (void)(_Randseed = (seed))
#define strtod(s,endptr) _Stod(s, endptr)
#define strtoul(s, endptr, base) _Stoul(s,endptr,base)
#define wctomb(s,wchar) _Wctomb(s,wchar,&_Wcxtomb)
#endif
/c64libc/source/string.c
0,0 → 1,178
#define null 0
 
byte *memcpy(byte *d, byte *s, int size)
{
asm {
lw r1,40[bp]
lw r2,32[bp]
lw r3,48[bp]
tst p0,r3
p0.eq br .0002
subui r3,r3,#1
mtspr lc,r3
.0001:
lb r4,[r1]
sb r4,[r2]
addui r1,r1,#1
addui r2,r2,#1
loop .0001
.0002:
}
return d;
}
 
short int *memcpyH(short int *d, short int *s, int size)
{
asm {
lw r1,40[bp]
lw r2,32[bp]
lw r3,48[bp]
.0001:
lh r4,[r1]
sh r4,[r2]
addui r1,r1,#4
addui r2,r2,#4
subui r3,r3,#1
tst p0,r3
p0.gt br .0001
}
return d;
}
 
int *memcpyW(int *d, int *s, int size)
{
asm {
lw r1,40[bp]
lw r2,32[bp]
lw r3,48[bp]
.0001:
lw r4,[r1]
sw r4,[r2]
addui r1,r1,#8
addui r2,r2,#8
subui r3,r3,#1
tst p0,r3
p0.gt br .0001
}
return d;
}
 
byte *memset(byte *p, byte val, int size)
{
asm {
lw r1,32[bp]
lw r2,40[bp]
lw r3,48[bp]
.0001:
sb r2,[r1]
addui r1,r1,#1
subui r3,r3,#1
tst p0,r3
p0.gt br .0001
}
return p;
}
 
short int *memsetH(short int *p, short int val, int size)
{
asm {
lw r1,32[bp]
lw r2,40[bp]
lw r3,48[bp]
.0001:
sh r2,[r1]
addui r1,r1,#4
subui r3,r3,#1
tst p0,r3
p0.gt br .0001
}
return p;
}
 
int *memsetW(int *p, int val, int size)
{
asm {
lw r1,32[bp]
lw r2,40[bp]
lw r3,48[bp]
.0001:
sw r2,[r1]
addui r1,r1,#8
subui r3,r3,#1
tst p0,r3
p0.gt br .0001
}
return p;
}
 
byte *memchr(byte *p, byte val, int n)
{
byte *su;
 
for (su = p; n > 0; ++su, --n)
if (*su==val)
return su;
return null;
}
 
int strlen(char *p)
{
int n;
 
if (p==(char *)0) return 0;
for (n = 0; p[n]; n++)
;
return n;
}
 
char *strcpy(char *d, char *s)
{
int nn;
 
for (nn = 0; s[nn]; nn++)
d[nn] = s[nn];
d[nn] = '\0';
return d;
}
 
char *strncpy(char *d, char *s, int size)
{
int nn;
 
for (nn = 0; nn < size; nn++) {
d[nn] = s[nn];
if (s[nn]=='\0')
break;
}
for (; nn < size; nn++)
d[nn] = '\0';
return d;
}
 
int strncmp(unsigned char *a, unsigned char *b, int len)
{
unsigned char *ua;
unsigned char *ub;
 
ua = a;
ub = b;
if (ua==ub) // duh
return 0;
for (; len > 0; ua++, ub++, len--)
if (*ua != *ub)
return *ua < *ub ? -1 : 1;
else if (*ua == '\0')
return 0;
return 0;
}
 
char *strchr(char *p, char val, int n)
{
char *su;
 
for (su = p; n > 0; ++su, --n)
if (*su==val)
return su;
return null;
}
 
/c64libc/source/prtdbl.c
0,0 → 1,183
// ============================================================================
// __
// \\__/ o\ (C) 2015 Robert Finch, Stratford
// \ __ / All rights reserved.
// \/_// robfinch<remove>@finitron.ca
// ||
//
// prtdbl.c
// Print a string representation of a double.
//
// This source file is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published
// by the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This source file is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// ============================================================================
//
extern pascal void putchar(char ch);
extern pascal int putstr(char *p, int maxchars);
 
// Put a string representation of a double into a char buffer.
// Buffer must be at least 30 characters in size and at least width characters
// in size.
 
pascal int sprtdbl(char *buf, double dbl, int width, int precision, char E)
{
int ndx;
int exp, expcnt;
int digit;
int nn;
int digits_before_decpt;
 
ndx = 0;
if (dbl < 0.0) {
dbl = -dbl;
buf[0] = '-';
ndx++;
}
if (dbl==0.0) {
buf[ndx]='0';
ndx++;
buf[ndx]='\0';
return;
}
exp = 0;
while (dbl < 1.0) {
dbl *= 1000000.0;
exp -= 6;
}
while (dbl > 100000.0) {
dbl /= 10.0;
exp++;
}
while (dbl < 100000.0) {
dbl *= 10.0;
exp--;
}
digits_before_decpt = 1;
expcnt = exp+7;
if (exp+7 >= 0 && exp+7 < 8) {
digits_before_decpt = exp+7;
digits_before_decpt--;
expcnt = 2;
}
j1:;
expcnt -= 2;
exp = digits_before_decpt;
if (exp <= 0) {
buf[ndx] = '.';
ndx++;
if (exp < 0) {
buf[ndx] = '0';
ndx++;
}
}
for (nn = 0; nn < 16 && precision > 0; nn++) {
digit = 0;
while (dbl > 100000.0) {
dbl -= 100000.0;
digit++;
}
buf[ndx] = digit + '0';
ndx++;
exp--;
if (exp==0) {
buf[ndx] = '.';
ndx++;
}
else if (exp < 0)
precision--;
dbl *= 10.0;
}
do {
ndx--;
} while(buf[ndx]=='0');
ndx++;
if (expcnt==0) {
buf[ndx]='\0';
goto prt;
}
buf[ndx] = E;
ndx++;
if (expcnt < 0) {
buf[ndx]='-';
ndx++;
expcnt = -expcnt;
}
else {
buf[ndx]='+';
ndx++;
}
digit = 0;
while (expcnt > 1000) {
expcnt -= 1000;
digit++;
}
buf[ndx] = digit + '0';
ndx++;
digit = 0;
while (expcnt > 100) {
expcnt -= 100;
digit++;
}
buf[ndx] = digit + '0';
ndx++;
digit = 0;
while (expcnt > 10) {
expcnt -= 10;
digit++;
}
buf[ndx] = digit + '0';
ndx++;
digit = 0;
while (expcnt > 0) {
expcnt -= 1;
digit++;
}
buf[ndx] = digit + '0';
ndx++;
buf[ndx] = '\0';
prt:;
// pad left
if (width > 0) {
if (ndx < width) {
for (nn = 29; nn >= width-ndx; nn--)
buf[nn] = buf[nn-(width-ndx)];
for (; nn >= 0; nn--)
buf[nn] = ' ';
}
}
// pad right
if (width < 0) {
width = -width;
while (ndx < width) {
buf[ndx]=' ';
ndx++;
}
buf[ndx]='\0';
}
return ndx;
}
 
pascal int prtdbl(double dbl, int width, int precision, char E)
{
static char buf[200];
int nn;
 
if (width > 199)
width = 199;
if (width < -199)
width = -199;
nn = sprtdbl(buf, dbl, width, precision, E);
putstr(buf,width);
return nn;
}
/c64libc/source/stdio.h
0,0 → 1,105
#ifndef STDIO_H
#define STDIO_H
 
#ifndef YVALS_H
#include <yvals.h>
#endif
 
#define NULL _NULL
#define _IOFBF 0
#define _IOLBF 1
#define _IONBF 2
#define BUFSIZ 512
#define EOF -1
#define FILENAME_MAX _FNAMAX
#define FOPEN_MAX _FOPMAX
#define L_tmpnam _TNAMX
#define TMP_MAX 32
#define SEEK_SET 0
#define SEEK_CUR 1
#define SEEK_END 2
#define stdin _Files[0]
#define stdout _Files[1]
#define stderr _Files[2]
// type definitions
#ifndef _SIZET
#define _SIZET
typedef _Sizet size_t;
#endif
typedef struct {
unsigned long _Off;
} fpos_t;
typedef struct {
unsigned short _Mode;
short _Handle;
unsigned byte *_Buf, *_Bend, *_Next;
unsigned byte *_Rend, *_Rsave, *_Wend;
unsigned char _Back[2], _Cbuf, _Nback;
char *_Tmpnam;
} FILE;
// declarations
void clearerr(FILE *f);
int fclose(FILE *f);
int feof(FILE *f);
int ferror(FILE *f);
int fflush(FILE *f);
int fgetc(FILE *f);
int fgetpos(FILE *f, fpos_t *p);
char *fgets(char *p, int n, FILE *f);
FILE *fopen(char *p, char *q);
int fprintf(FILE *f, char *);
int fputc(int n, FILE *f);
int fputs(char *p, FILE *f);
size_t fread(void *p, size_t n, size_t m, FILE *f);
FILE *freopen(char *p, char *q, FILE *f);
int fscanf(FILE *f, char *);
int fseek(FILE *f, long p, int n);
int fsetpos(FILE *f, fpos_t *p);
long ftell(FILE *f);
size_t fwrite(void *v, size_t n, size_t m, FILE *f);
int getc(FILE *f);
int getchar(void);
char *gets(char *p);
void perror(char *p);
int printf(char *p);
int putc(int n, FILE *f);
int putchar(int ch);
int puts(char *p);
int remove(char *n);
int rename(char *n);
void rewind(FILE *f);
int scanf(char *);
void setbuf(FILE *f, char *p);
int setvbuf(FILE *, char *, int, size_t);
int sprintf(char *p, char *q);
int sscanf(char *p, char *q);
FILE *tmpfile(void);
char *tmpnam(char *p);
int ungetc(int n, FILE *f);
int vfprintf(FILE *f, char *p, char *q);
int vprintf(char *p, char *q);
long _Fgpos(FILE *f, fpos_t *p);
int _Fspos(FILE *f, fpos_t *p, long n, int m);
extern FILE *_Files[FOPEN_MAX];
 
// Macro overrides
#define fgetpos(str, ptr) (int)_Fgpos(str,ptr)
#define fseek(str,off,way) _Fspos(str, _NULL, off, way)
#define fsetpos(str, ptr) _Fspos(str, ptr, 0L, 0)
#define ftell(str) _Fgpos(str, _NULL)
#define getc(str) ((str)->_Next < (str)->_Rend ? *(str)->_Next++ : (getc)(str))
//#define getchar() (_Files[0]->_Next < _Files[0]->_Rend ? *_Files[0]->_Next++ : (getchar)())
#define putc(c,str) ((str)->_Next < (str)->_Wend ? (*(str)->_Next++ = c) : (putc)(c,str))
#define putchar(c) (_Files[1]->_Next < _Files[1]->_Wend ? (*_Files[1]->_Next++ = c) : (putchar)(c))
 
 
pascal void putch(char ch);
pascal void putnum(int num, int wid, char sep);
pascal void puthexnum(int num, int wid);
pascal int putstr(char *p, int max);
int getchar2( );
 
//int getchar( );
int printf(char *, ...);
 
#endif
/c64libc/source/ctype.h
0,0 → 1,18
#ifndef CTYPE_H
#define CTYPE_H
 
int isspace(char ch);
int isxdigit(char ch);
int isdigit(char ch);
int isalpha(char ch);
int isupper(char ch);
int islower(char ch);
int ispunct(char ch);
int isalnum(char ch);
int isgraph(char ch);
int isprint(char ch);
int iscntrl(char ch);
int tolower(char ch);
int toupper(char ch);
 
#endif
/c64libc/source/Thor/outw.c
0,0 → 1,9
 
void outw(unsigned int port, int value)
{
asm {
lw r1,32[bp]
lw r2,40[bp]
sw r2,zs:[r1]
}
}
/c64libc/source/Thor/outh.c
0,0 → 1,9
 
void outh(unsigned int port, int value)
{
asm {
lw r1,32[bp]
lw r2,40[bp]
sh r2,zs:[r1]
}
}
/c64libc/source/Thor/getCPU.c
0,0 → 1,9
// Return the which CPU is active.
 
naked int getCPU()
{
asm {
cpuid r1,r0,#0
rts
};
}
/c64libc/source/Thor/outb.c
0,0 → 1,9
 
void outb(unsigned int port, int value)
{
asm {
lw r1,32[bp]
lw r2,40[bp]
sb r2,zs:[r1]
}
}
/c64libc/source/Thor/outc.c
0,0 → 1,9
 
void outc(unsigned int port, int value)
{
asm {
lw r1,32[bp]
lw r2,40[bp]
sc r2,zs:[r1]
}
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.