Compare commits
No commits in common. "main" and "v1.31.259" have entirely different histories.
|
|
@ -4,7 +4,7 @@ Oscar64 is a C/C++ cross compiler running on a modern system (such as a Windows
|
|||
|
||||
The purpose of this compiler is to eliminate the need to write 6502 assembler code to achieve high code density and fast execution speed. It continues to improve with all the games, demos and tools written by it. It supports disk overlays and banked cartridges for larger projects.
|
||||
|
||||
The C64 executes 442 dhrystone V2.2 iteration per second, when compiled with Oscar64 and -O3 (which shows that the ancient dhrystone benchmark is no match to an optimizing compiler).
|
||||
The C64 executes 418 dhrystone V2.2 iteration per second, when compiled with Oscar64 and -O3 (which shows that the ancient dhrystone benchmark is no match to an optimizing compiler).
|
||||
|
||||
[Full reference manual](oscar64.md)
|
||||
[Additional samples and tutorials](https://github.com/drmortalwombat/OscarTutorials)
|
||||
|
|
|
|||
|
|
@ -1,8 +1,5 @@
|
|||
rem @echo off
|
||||
|
||||
@call :test rolrortest.cpp
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test bitfields.cpp
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
|
|
@ -18,9 +15,6 @@ rem @echo off
|
|||
@call :testh opp_vector.cpp
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :testh opp_static_vector.cpp
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :testh opp_vector_string.cpp
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
|
|
@ -39,7 +33,7 @@ rem @echo off
|
|||
@call :testh opp_list.cpp
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :testn opp_functional.cpp
|
||||
@call :testh opp_functional.cpp
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :testh operatoroverload.cpp
|
||||
|
|
@ -57,7 +51,7 @@ rem @echo off
|
|||
@call :testh constructortest.cpp
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :testn copyconstructor.cpp
|
||||
@call :testh copyconstructor.cpp
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :testh copyassign.cpp
|
||||
|
|
@ -280,15 +274,6 @@ exit /b %errorlevel%
|
|||
..\bin\oscar64 -e -O2 -n -dHEAPCHECK %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
..\bin\oscar64 -e -O2 -xz -Oz -n %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
..\bin\oscar64 -e -O2 -Oo -n %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
..\bin\oscar64 -e -O2 -Ox -n %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
..\bin\oscar64 -e -O0 -bc %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
|
|
@ -349,9 +334,6 @@ exit /b %errorlevel%
|
|||
..\bin\oscar64 -e -O2 -Oo -n %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
..\bin\oscar64 -e -O2 -Ox -n %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@exit /b 0
|
||||
|
||||
:testb
|
||||
|
|
@ -394,7 +376,4 @@ exit /b %errorlevel%
|
|||
..\bin\oscar64 -e -O2 -Oo -n %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
..\bin\oscar64 -e -O2 -Ox -n %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@exit /b 0
|
||||
|
|
|
|||
|
|
@ -1,5 +1,4 @@
|
|||
#include <assert.h>
|
||||
#include <stdio.h>
|
||||
|
||||
int t, n;
|
||||
|
||||
|
|
@ -162,7 +161,7 @@ void test_return_value(void)
|
|||
C2 c(test_ret_v());
|
||||
}
|
||||
|
||||
assert(n == 6 && t == 0);
|
||||
assert(n == 4 && t == 0);
|
||||
}
|
||||
|
||||
void test_return_reference(void)
|
||||
|
|
@ -185,7 +184,7 @@ void test_retparam_value(void)
|
|||
test_param_fv(test_ret_v());
|
||||
}
|
||||
|
||||
assert(n == 6 && t == 0);
|
||||
assert(n == 4 && t == 0);
|
||||
}
|
||||
|
||||
void test_retparam_reference(void)
|
||||
|
|
@ -201,6 +200,7 @@ void test_retparam_reference(void)
|
|||
|
||||
int main(void)
|
||||
{
|
||||
#if 0
|
||||
test_dcopy_init();
|
||||
test_copy_init();
|
||||
test_minit();
|
||||
|
|
@ -208,8 +208,9 @@ int main(void)
|
|||
test_param_value();
|
||||
test_param_ref();
|
||||
test_return_value();
|
||||
#endif
|
||||
test_retparam_value();
|
||||
test_retparam_reference();
|
||||
// test_retparam_reference();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -50,11 +50,5 @@ autorefreturn: autorefreturn.cpp
|
|||
$(OSCAR64_CC) -e -Os -n $<
|
||||
$(OSCAR64_CC) -e -O3 -n $<
|
||||
|
||||
copyconstructor: copyconstructor.cpp
|
||||
$(OSCAR64_CC) -e -O2 -n $<
|
||||
$(OSCAR64_CC) -e -O0 -n $<
|
||||
$(OSCAR64_CC) -e -Os -n $<
|
||||
$(OSCAR64_CC) -e -O3 -n $<
|
||||
|
||||
clean:
|
||||
@$(RM) *.asm *.bcs *.int *.lbl *.map *.prg
|
||||
|
|
|
|||
|
|
@ -1,78 +0,0 @@
|
|||
#include <opp/static_vector.h>
|
||||
#include <opp/algorithm.h>
|
||||
#include <assert.h>
|
||||
#include <opp/iostream.h>
|
||||
|
||||
int main(void)
|
||||
{
|
||||
opp::static_vector<int, 20> a;
|
||||
|
||||
for(int i=0; i<10; i++)
|
||||
a.push_back(i);
|
||||
|
||||
int s = 0;
|
||||
for(int i=0; i<a.size(); i++)
|
||||
s += a[i];
|
||||
|
||||
assert(s == 45);
|
||||
|
||||
for(int i=0; i<5; i++)
|
||||
a.erase(i);
|
||||
|
||||
s = 0;
|
||||
for(int i=0; i<a.size(); i++)
|
||||
s += a[i];
|
||||
|
||||
assert(s == 1 + 3 + 5 + 7 + 9);
|
||||
|
||||
opp::static_vector<int, 100> v;
|
||||
|
||||
for(int i=0; i<10; i++)
|
||||
v.push_back(i);
|
||||
|
||||
assert(v.size() == 10);
|
||||
v.insert(0, 20);
|
||||
assert(v.size() == 11);
|
||||
v.insert(6, 21);
|
||||
assert(v.size() == 12);
|
||||
v.insert(12, 22);
|
||||
|
||||
int * fi = opp::find(v.begin(), v.end(), 21);
|
||||
|
||||
fi = v.insert(fi, 30);
|
||||
fi = v.insert(fi, 31);
|
||||
fi = v.insert(fi, 32);
|
||||
|
||||
assert(v.size() == 16);
|
||||
assert(v[0] == 20);
|
||||
assert(v[15] == 22);
|
||||
assert(v[8] == 32);
|
||||
|
||||
fi = opp::find(v.begin(), v.end(), 32);
|
||||
|
||||
for(int i=0; i<30; i++)
|
||||
{
|
||||
fi = v.insert(fi, i + 40);
|
||||
}
|
||||
|
||||
assert(v.size() == 46);
|
||||
assert(v[28] == 60);
|
||||
|
||||
v.erase(10, 10);
|
||||
|
||||
for(int i : v)
|
||||
opp::cout << i << ", ";
|
||||
opp::cout << "\n";
|
||||
|
||||
assert(v.size() == 36);
|
||||
assert(v[18] == 60);
|
||||
|
||||
v.assign(42, 11);
|
||||
|
||||
assert(v.size() == 42);
|
||||
assert(v[0] == 11);
|
||||
assert(v[15] == 11);
|
||||
assert(v[41] == 11);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -64,15 +64,5 @@ int main(void)
|
|||
opp::cout << i << ", ";
|
||||
opp::cout << "\n";
|
||||
|
||||
assert(v.size() == 36);
|
||||
assert(v[18] == 60);
|
||||
|
||||
v.assign(42, 11);
|
||||
|
||||
assert(v.size() == 42);
|
||||
assert(v[0] == 11);
|
||||
assert(v[15] == 11);
|
||||
assert(v[41] == 11);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,76 +0,0 @@
|
|||
#include <assert.h>
|
||||
|
||||
__noinline unsigned long rollright32(unsigned long a) {
|
||||
unsigned long tmp = a & 1;
|
||||
return ( a >> 1) + (tmp << 31);
|
||||
}
|
||||
|
||||
__noinline unsigned rollright16(unsigned a) {
|
||||
unsigned tmp = a & 1;
|
||||
return ( a >> 1) + (tmp << 15);
|
||||
}
|
||||
|
||||
__noinline char rollright8(char a) {
|
||||
char tmp = a & 1;
|
||||
return ( a >> 1) + (tmp << 7);
|
||||
}
|
||||
|
||||
__noinline unsigned long rollleft32(unsigned long a) {
|
||||
unsigned long tmp = (a >> 31) & 1;
|
||||
return ( a << 1) + tmp;
|
||||
}
|
||||
|
||||
__noinline unsigned rollleft16(unsigned a) {
|
||||
unsigned tmp = (a >> 15) & 1;
|
||||
return ( a << 1) + tmp;
|
||||
}
|
||||
|
||||
__noinline char rollleft8(char a) {
|
||||
char tmp = (a >> 7) & 1;
|
||||
return ( a << 1) + tmp;
|
||||
}
|
||||
|
||||
int main() {
|
||||
unsigned long lv = 0x12345678ul;
|
||||
unsigned val = 0x1234;
|
||||
char c=0x12;
|
||||
|
||||
unsigned long lvt[33];
|
||||
unsigned valt[17];
|
||||
char ct[9];
|
||||
|
||||
lvt[0] = lv;
|
||||
valt[0] = val;
|
||||
ct[0] = c;
|
||||
|
||||
assert(rollleft8(rollright8(c)) == c);
|
||||
assert(rollleft16(rollright16(val)) == val);
|
||||
assert(rollleft32(rollright32(lv)) == lv);
|
||||
|
||||
for(int i=0; i<32; i++)
|
||||
lvt[i + 1] = rollright32(lvt[i]);
|
||||
for(int i=0; i<16; i++)
|
||||
valt[i + 1] = rollright16(valt[i]);
|
||||
for(int i=0; i<8; i++)
|
||||
ct[i + 1] = rollright8(ct[i]);
|
||||
|
||||
for(int i=0; i<=32; i++)
|
||||
{
|
||||
assert(lvt[32 - i] == lv);
|
||||
lv = rollleft32(lv);
|
||||
}
|
||||
|
||||
for(int i=0; i<=16; i++)
|
||||
{
|
||||
assert(valt[16 - i] == val);
|
||||
val = rollleft16(val);
|
||||
}
|
||||
|
||||
for(int i=0; i<=8; i++)
|
||||
{
|
||||
assert(ct[8 - i] == c);
|
||||
c = rollleft8(c);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -63,33 +63,6 @@ bool nge(long a, long b)
|
|||
|
||||
|
||||
|
||||
|
||||
inline bool ieq(long a, long b)
|
||||
{
|
||||
return a == b;
|
||||
}
|
||||
|
||||
inline bool ilt(long a, long b)
|
||||
{
|
||||
return a < b;
|
||||
}
|
||||
|
||||
inline bool igt(long a, long b)
|
||||
{
|
||||
return a > b;
|
||||
}
|
||||
|
||||
inline bool ile(long a, long b)
|
||||
{
|
||||
return a <= b;
|
||||
}
|
||||
|
||||
inline bool ige(long a, long b)
|
||||
{
|
||||
return a >= b;
|
||||
}
|
||||
|
||||
|
||||
bool beqz(long a)
|
||||
{
|
||||
return a == 0;
|
||||
|
|
@ -215,71 +188,7 @@ bool nge1(long a)
|
|||
|
||||
|
||||
|
||||
bool beqm(long a)
|
||||
{
|
||||
return a == -1;
|
||||
}
|
||||
|
||||
bool bltm(long a)
|
||||
{
|
||||
return a < -1;
|
||||
}
|
||||
|
||||
bool bgtm(long a)
|
||||
{
|
||||
return a > -1;
|
||||
}
|
||||
|
||||
bool blem(long a)
|
||||
{
|
||||
return a <= -1;
|
||||
}
|
||||
|
||||
bool bgem(long a)
|
||||
{
|
||||
return a >= -1;
|
||||
}
|
||||
|
||||
|
||||
|
||||
bool neqm(long a)
|
||||
{
|
||||
return a == -1;
|
||||
}
|
||||
|
||||
#pragma native(neqm)
|
||||
|
||||
bool nltm(long a)
|
||||
{
|
||||
return a < -1;
|
||||
}
|
||||
|
||||
#pragma native(nltm)
|
||||
|
||||
bool ngtm(long a)
|
||||
{
|
||||
return a > -1;
|
||||
}
|
||||
|
||||
#pragma native(ngtm)
|
||||
|
||||
bool nlem(long a)
|
||||
{
|
||||
return a <= -1;
|
||||
}
|
||||
|
||||
#pragma native(nlem)
|
||||
|
||||
bool ngem(long a)
|
||||
{
|
||||
return a >= -1;
|
||||
}
|
||||
|
||||
#pragma native(ngem)
|
||||
|
||||
|
||||
|
||||
void cmpc(long a, long b)
|
||||
void cmp(long a, long b)
|
||||
{
|
||||
bool beqf = beq(a, b), bltf = blt(a, b), bgtf = bgt(a, b), blef = ble(a, b), bgef = bge(a, b);
|
||||
bool neqf = neq(a, b), nltf = nlt(a, b), ngtf = ngt(a, b), nlef = nle(a, b), ngef = nge(a, b);
|
||||
|
|
@ -294,27 +203,6 @@ void cmpc(long a, long b)
|
|||
assert(bgef == ngef);
|
||||
}
|
||||
|
||||
void cmpi(long a, long b)
|
||||
{
|
||||
bool ieqf = ieq(a, b), iltf = ilt(a, b), igtf = igt(a, b), ilef = ile(a, b), igef = ige(a, b);
|
||||
bool neqf = neq(a, b), nltf = nlt(a, b), ngtf = ngt(a, b), nlef = nle(a, b), ngef = nge(a, b);
|
||||
|
||||
printf("INLINE %ld, %ld : EQ %d LT %d GT %d\r", a, b, ieqf, iltf, igtf);
|
||||
printf("NATIVE %ld, %ld : EQ %d LT %d GT %d\r", a, b, neqf, nltf, ngtf);
|
||||
|
||||
assert(ieqf == neqf);
|
||||
assert(iltf == nltf);
|
||||
assert(igtf == ngtf);
|
||||
assert(ilef == nlef);
|
||||
assert(igef == ngef);
|
||||
}
|
||||
|
||||
void cmp(long a, long b)
|
||||
{
|
||||
cmpc(a, b);
|
||||
cmpi(a, b);
|
||||
}
|
||||
|
||||
void cmpz(long a)
|
||||
{
|
||||
bool beqf = beqz(a), bltf = bltz(a), bgtf = bgtz(a), blef = blez(a), bgef = bgez(a);
|
||||
|
|
@ -345,21 +233,6 @@ void cmp1(long a)
|
|||
assert(bgef == ngef);
|
||||
}
|
||||
|
||||
void cmpm(long a)
|
||||
{
|
||||
bool beqf = beqm(a), bltf = bltm(a), bgtf = bgtm(a), blef = blem(a), bgef = bgem(a);
|
||||
bool neqf = neqm(a), nltf = nltm(a), ngtf = ngtm(a), nlef = nlem(a), ngef = ngem(a);
|
||||
|
||||
printf("BYTE %ld, 1 : EQ %d LT %d GT %d LE %d GE %d\r", a, beqf, bltf, bgtf, blef, bgef);
|
||||
printf("NATIVE %ld, 1 : EQ %d LT %d GT %d LE %d GE %d\r", a, neqf, nltf, ngtf, nlef, ngef);
|
||||
|
||||
assert(beqf == neqf);
|
||||
assert(bltf == nltf);
|
||||
assert(bgtf == ngtf);
|
||||
assert(blef == nlef);
|
||||
assert(bgef == ngef);
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
cmp( 0, 1);
|
||||
|
|
@ -454,10 +327,6 @@ int main(void)
|
|||
cmp1(256);
|
||||
cmp1(10000);
|
||||
cmp1(20000);
|
||||
cmp1(1000000l);
|
||||
cmp1(2000000l);
|
||||
cmp1(100000000l);
|
||||
cmp1(200000000l);
|
||||
cmp1(-1);
|
||||
cmp1(-2);
|
||||
cmp1(-3);
|
||||
|
|
@ -465,34 +334,6 @@ int main(void)
|
|||
cmp1(-256);
|
||||
cmp1(-10000);
|
||||
cmp1(-20000);
|
||||
cmp1(-1000000l);
|
||||
cmp1(-2000000l);
|
||||
cmp1(-100000000l);
|
||||
cmp1(-200000000l);
|
||||
|
||||
cmpm(0);
|
||||
cmpm(1);
|
||||
cmpm(2);
|
||||
cmpm(3);
|
||||
cmpm(255);
|
||||
cmpm(256);
|
||||
cmpm(10000);
|
||||
cmpm(20000);
|
||||
cmpm(1000000l);
|
||||
cmpm(2000000l);
|
||||
cmpm(100000000l);
|
||||
cmpm(200000000l);
|
||||
cmpm(-1);
|
||||
cmpm(-2);
|
||||
cmpm(-3);
|
||||
cmpm(-255);
|
||||
cmpm(-256);
|
||||
cmpm(-10000);
|
||||
cmpm(-20000);
|
||||
cmpm(-1000000l);
|
||||
cmpm(-2000000l);
|
||||
cmpm(-100000000l);
|
||||
cmpm(-200000000l);
|
||||
|
||||
return 0;
|
||||
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ enum SIDFXState
|
|||
SIDFX_WAIT
|
||||
};
|
||||
|
||||
__striped static struct SIDFXChannel
|
||||
static struct SIDFXChannel
|
||||
{
|
||||
const SIDFX * volatile com;
|
||||
byte delay, priority;
|
||||
|
|
@ -27,7 +27,6 @@ void sidfx_init(void)
|
|||
channels[i].com = nullptr;
|
||||
channels[i].state = SIDFX_IDLE;
|
||||
channels[i].priority = 0;
|
||||
channels[i].delay = 1;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -36,11 +35,6 @@ bool sidfx_idle(byte chn)
|
|||
return channels[chn].state == SIDFX_IDLE;
|
||||
}
|
||||
|
||||
char sidfx_cnt(byte chn)
|
||||
{
|
||||
return channels[chn].cnt;
|
||||
}
|
||||
|
||||
void sidfx_play(byte chn, const SIDFX * fx, byte cnt)
|
||||
{
|
||||
SIDFXState ns = channels[chn].state;
|
||||
|
|
@ -53,7 +47,6 @@ void sidfx_play(byte chn, const SIDFX * fx, byte cnt)
|
|||
return;
|
||||
|
||||
channels[chn].state = SIDFX_IDLE;
|
||||
channels[chn].delay = 1;
|
||||
|
||||
channels[chn].com = fx;
|
||||
channels[chn].cnt = cnt - 1;
|
||||
|
|
@ -66,21 +59,49 @@ void sidfx_stop(byte chn)
|
|||
{
|
||||
channels[chn].com = nullptr;
|
||||
if (channels[chn].state != SIDFX_IDLE)
|
||||
{
|
||||
channels[chn].state = SIDFX_RESET_0;
|
||||
channels[chn].delay = 1;
|
||||
}
|
||||
}
|
||||
|
||||
inline void sidfx_loop_ch(byte ch)
|
||||
{
|
||||
if (channels[ch].state)
|
||||
switch (channels[ch].state)
|
||||
{
|
||||
case SIDFX_IDLE:
|
||||
break;
|
||||
case SIDFX_RESET_0:
|
||||
sid.voices[ch].ctrl = 0;
|
||||
sid.voices[ch].attdec = 0;
|
||||
sid.voices[ch].susrel = 0;
|
||||
channels[ch].state = SIDFX_READY;
|
||||
break;
|
||||
case SIDFX_RESET_1:
|
||||
sid.voices[ch].ctrl = SID_CTRL_TEST;
|
||||
channels[ch].state = SIDFX_READY;
|
||||
break;
|
||||
case SIDFX_READY:
|
||||
{
|
||||
const SIDFX * com = channels[ch].com;
|
||||
|
||||
channels[ch].delay--;
|
||||
if (channels[ch].delay)
|
||||
if (com)
|
||||
{
|
||||
channels[ch].freq = com->freq;
|
||||
channels[ch].pwm = com->pwm;
|
||||
|
||||
sid.voices[ch].freq = com->freq;
|
||||
sid.voices[ch].pwm = com->pwm;
|
||||
sid.voices[ch].attdec = com->attdec;
|
||||
sid.voices[ch].susrel = com->susrel;
|
||||
sid.voices[ch].ctrl = com->ctrl;
|
||||
|
||||
channels[ch].delay = com->time1;
|
||||
channels[ch].state = SIDFX_PLAY;
|
||||
}
|
||||
else
|
||||
channels[ch].state = SIDFX_IDLE;
|
||||
}
|
||||
break;
|
||||
case SIDFX_PLAY:
|
||||
{
|
||||
const SIDFX * com = channels[ch].com;
|
||||
if (com->dfreq)
|
||||
{
|
||||
channels[ch].freq += com->dfreq;
|
||||
|
|
@ -91,70 +112,18 @@ inline void sidfx_loop_ch(byte ch)
|
|||
channels[ch].pwm += com->dpwm;
|
||||
sid.voices[ch].pwm = channels[ch].pwm;
|
||||
}
|
||||
}
|
||||
|
||||
while (!channels[ch].delay)
|
||||
{
|
||||
switch (channels[ch].state)
|
||||
{
|
||||
case SIDFX_IDLE:
|
||||
channels[ch].delay = 1;
|
||||
break;
|
||||
case SIDFX_RESET_0:
|
||||
sid.voices[ch].ctrl = 0;
|
||||
sid.voices[ch].attdec = 0;
|
||||
sid.voices[ch].susrel = 0;
|
||||
if (com)
|
||||
channels[ch].state = SIDFX_READY;
|
||||
else
|
||||
channels[ch].state = SIDFX_IDLE;
|
||||
channels[ch].delay = 1;
|
||||
break;
|
||||
case SIDFX_RESET_1:
|
||||
sid.voices[ch].ctrl = SID_CTRL_TEST;
|
||||
sid.voices[ch].ctrl = 0;
|
||||
sid.voices[ch].attdec = 0;
|
||||
sid.voices[ch].susrel = 0;
|
||||
channels[ch].state = SIDFX_READY;
|
||||
break;
|
||||
case SIDFX_READY:
|
||||
channels[ch].freq = com->freq;
|
||||
channels[ch].pwm = com->pwm;
|
||||
|
||||
sid.voices[ch].freq = com->freq;
|
||||
sid.voices[ch].pwm = com->pwm;
|
||||
sid.voices[ch].attdec = com->attdec;
|
||||
sid.voices[ch].susrel = com->susrel;
|
||||
sid.voices[ch].ctrl = com->ctrl;
|
||||
|
||||
if (com->ctrl & SID_CTRL_GATE)
|
||||
{
|
||||
channels[ch].delay = com->time1;
|
||||
channels[ch].state = SIDFX_PLAY;
|
||||
}
|
||||
else
|
||||
{
|
||||
channels[ch].delay = com->time0;
|
||||
channels[ch].state = SIDFX_PLAY;
|
||||
}
|
||||
break;
|
||||
case SIDFX_PLAY:
|
||||
if (com->time0)
|
||||
if (channels[ch].delay)
|
||||
channels[ch].delay--;
|
||||
else if (com->time0)
|
||||
{
|
||||
sid.voices[ch].ctrl = com->ctrl & ~SID_CTRL_GATE;
|
||||
channels[ch].delay = com->time0 - 1;
|
||||
channels[ch].delay = com->time0;
|
||||
channels[ch].state = SIDFX_WAIT;
|
||||
}
|
||||
else if (channels[ch].cnt)
|
||||
{
|
||||
char sr = com->susrel & 0xf0;
|
||||
com++;
|
||||
char ctrl = com->ctrl;
|
||||
if ((com->attdec & 0xef) == 0 && (ctrl & SID_CTRL_GATE) && (com->susrel & 0xf0) > sr)
|
||||
{
|
||||
sid.voices[ch].ctrl = ctrl & ~SID_CTRL_GATE;
|
||||
sid.voices[ch].ctrl = ctrl | SID_CTRL_GATE;
|
||||
}
|
||||
channels[ch].cnt--;
|
||||
channels[ch].com = com;
|
||||
channels[ch].priority = com->priority;
|
||||
|
|
@ -162,31 +131,46 @@ inline void sidfx_loop_ch(byte ch)
|
|||
}
|
||||
else
|
||||
{
|
||||
com = nullptr;
|
||||
channels[ch].com = nullptr;
|
||||
channels[ch].state = SIDFX_RESET_0;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case SIDFX_WAIT:
|
||||
if (channels[ch].cnt)
|
||||
{
|
||||
const SIDFX * com = channels[ch].com;
|
||||
if (com->dfreq)
|
||||
{
|
||||
channels[ch].freq += com->dfreq;
|
||||
sid.voices[ch].freq = channels[ch].freq;
|
||||
}
|
||||
if (com->dpwm)
|
||||
{
|
||||
channels[ch].pwm += com->dpwm;
|
||||
sid.voices[ch].pwm = channels[ch].pwm;
|
||||
}
|
||||
|
||||
if (channels[ch].delay)
|
||||
channels[ch].delay--;
|
||||
else if (channels[ch].cnt)
|
||||
{
|
||||
com++;
|
||||
channels[ch].cnt--;
|
||||
channels[ch].com = com;
|
||||
channels[ch].priority = com->priority;
|
||||
if (com->ctrl & SID_CTRL_GATE)
|
||||
if (com->time0)
|
||||
channels[ch].state = SIDFX_RESET_0;
|
||||
else
|
||||
channels[ch].state = SIDFX_READY;
|
||||
}
|
||||
else
|
||||
{
|
||||
com = nullptr;
|
||||
channels[ch].com = nullptr;
|
||||
channels[ch].state = SIDFX_RESET_0;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void sidfx_loop_2(void)
|
||||
|
|
|
|||
|
|
@ -20,8 +20,6 @@ inline void sidfx_play(byte chn, const SIDFX * fx, byte cnt);
|
|||
|
||||
void sidfx_stop(byte chn);
|
||||
|
||||
char sidfx_cnt(byte chn);
|
||||
|
||||
void sidfx_loop(void);
|
||||
|
||||
void sidfx_loop_2(void);
|
||||
|
|
|
|||
|
|
@ -69,7 +69,7 @@ BANKINLINE bool krnio_open(char fnum, char device, char channel)
|
|||
{
|
||||
krnio_pstatus[fnum] = KRNIO_OK;
|
||||
|
||||
return char(__asm
|
||||
return __asm
|
||||
{
|
||||
lda #0
|
||||
sta accu
|
||||
|
|
@ -94,7 +94,8 @@ BANKINLINE bool krnio_open(char fnum, char device, char channel)
|
|||
|
||||
BANKOUT
|
||||
E2:
|
||||
});
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#pragma native(krnio_open)
|
||||
|
|
@ -130,7 +131,7 @@ BANKINLINE krnioerr krnio_status(void)
|
|||
|
||||
BANKINLINE bool krnio_load(char fnum, char device, char channel)
|
||||
{
|
||||
return char(__asm
|
||||
return __asm
|
||||
{
|
||||
BANKIN
|
||||
lda fnum
|
||||
|
|
@ -148,14 +149,14 @@ BANKINLINE bool krnio_load(char fnum, char device, char channel)
|
|||
rol
|
||||
eor #1
|
||||
sta accu
|
||||
});
|
||||
};
|
||||
}
|
||||
|
||||
#pragma native(krnio_load)
|
||||
|
||||
BANKINLINE bool krnio_save(char device, const char* start, const char* end)
|
||||
{
|
||||
return char(__asm
|
||||
return __asm
|
||||
{
|
||||
BANKIN
|
||||
lda #0
|
||||
|
|
@ -174,14 +175,14 @@ BANKINLINE bool krnio_save(char device, const char* start, const char* end)
|
|||
rol
|
||||
eor #1
|
||||
sta accu
|
||||
});
|
||||
};
|
||||
}
|
||||
|
||||
#pragma native(krnio_save)
|
||||
|
||||
BANKINLINE bool krnio_chkout(char fnum)
|
||||
{
|
||||
return char(__asm
|
||||
return __asm
|
||||
{
|
||||
BANKIN
|
||||
ldx fnum
|
||||
|
|
@ -192,14 +193,14 @@ BANKINLINE bool krnio_chkout(char fnum)
|
|||
rol
|
||||
eor #1
|
||||
sta accu
|
||||
});
|
||||
};
|
||||
}
|
||||
|
||||
#pragma native(krnio_chkout)
|
||||
|
||||
BANKINLINE bool krnio_chkin(char fnum)
|
||||
{
|
||||
return char(__asm
|
||||
return __asm
|
||||
{
|
||||
BANKIN
|
||||
ldx fnum
|
||||
|
|
@ -210,7 +211,7 @@ BANKINLINE bool krnio_chkin(char fnum)
|
|||
rol
|
||||
eor #1
|
||||
sta accu
|
||||
});
|
||||
};
|
||||
}
|
||||
|
||||
#pragma native(krnio_chkin)
|
||||
|
|
@ -229,14 +230,14 @@ BANKINLINE void krnio_clrchn(void)
|
|||
|
||||
BANKINLINE bool krnio_chrout(char ch)
|
||||
{
|
||||
return char(__asm
|
||||
return __asm
|
||||
{
|
||||
BANKIN
|
||||
lda ch
|
||||
jsr $ffd2 // chrout
|
||||
sta accu
|
||||
BANKOUT
|
||||
});
|
||||
};
|
||||
}
|
||||
|
||||
#pragma native(krnio_chrout)
|
||||
|
|
@ -421,7 +422,7 @@ int krnio_gets(char fnum, char * data, int num)
|
|||
|
||||
if (krnio_chkin(fnum))
|
||||
{
|
||||
krnioerr err = KRNIO_OK;
|
||||
krnioerr err;
|
||||
int i = 0;
|
||||
int ch;
|
||||
while (i + 1 < num)
|
||||
|
|
|
|||
|
|
@ -5,16 +5,16 @@
|
|||
#include <c64/asm6502.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
volatile char npos = 1, tpos = 0;
|
||||
volatile byte rirq_count;
|
||||
static byte rirq_pcount;
|
||||
|
||||
byte rasterIRQRows[NUM_IRQS + 1];
|
||||
byte rasterIRQIndex[NUM_IRQS + 1]; // Sort order of interrupt index, offset by one
|
||||
byte rasterIRQIndex[NUM_IRQS + 1];
|
||||
#ifdef ZPAGE_IRQS
|
||||
__zeropage
|
||||
#endif
|
||||
byte rasterIRQNext[NUM_IRQS + 1]; // Rasterline of interrupt, terminated by 0xff
|
||||
byte rasterIRQLow[NUM_IRQS]; // Address of interrupt code
|
||||
byte rasterIRQNext[NUM_IRQS + 1];
|
||||
byte rasterIRQLow[NUM_IRQS];
|
||||
byte rasterIRQHigh[NUM_IRQS];
|
||||
|
||||
#ifdef ZPAGE_IRQS
|
||||
|
|
@ -22,87 +22,26 @@ __zeropage
|
|||
#endif
|
||||
byte nextIRQ;
|
||||
|
||||
// nextIRQ is the index of the next expected IRQ, or $ff if no IRQ is scheduled
|
||||
|
||||
__asm rirq_isr_ram_io
|
||||
__asm irq0
|
||||
{
|
||||
stx plrx + 1
|
||||
|
||||
ldx nextIRQ
|
||||
bmi exi
|
||||
|
||||
sta plra + 1
|
||||
stx plrx + 1
|
||||
sty plry + 1
|
||||
|
||||
l1:
|
||||
lda rasterIRQNext, x
|
||||
ldy rasterIRQIndex + 1, x
|
||||
ldx rasterIRQLow, y
|
||||
stx ji + 1
|
||||
ldx rasterIRQHigh, y
|
||||
stx ji + 2
|
||||
|
||||
ji:
|
||||
jsr $0000
|
||||
|
||||
inc nextIRQ
|
||||
ldx nextIRQ
|
||||
|
||||
ldy rasterIRQNext, x
|
||||
|
||||
asl $d019
|
||||
|
||||
cpy #$ff
|
||||
beq e2
|
||||
|
||||
dey
|
||||
sty $d012
|
||||
dey
|
||||
cpy $d012
|
||||
bcc l1
|
||||
|
||||
plry:
|
||||
ldy #0
|
||||
plra:
|
||||
lda #0
|
||||
plrx:
|
||||
ldx #0
|
||||
rti
|
||||
|
||||
exi:
|
||||
asl $d019
|
||||
jmp plrx
|
||||
|
||||
// No more interrupts to service
|
||||
e2:
|
||||
inc rirq_count
|
||||
|
||||
ldy rasterIRQNext
|
||||
dey
|
||||
sty $d012
|
||||
ldx #0
|
||||
stx nextIRQ
|
||||
beq plry
|
||||
}
|
||||
|
||||
__asm rirq_isr_io
|
||||
{
|
||||
pha
|
||||
txa
|
||||
pha
|
||||
tya
|
||||
pha
|
||||
kentry:
|
||||
asl $d019
|
||||
|
||||
ldx nextIRQ
|
||||
bmi exi
|
||||
l1:
|
||||
lda rasterIRQNext, x
|
||||
cmp #$ff
|
||||
beq e1
|
||||
|
||||
ldy rasterIRQIndex + 1, x
|
||||
ldx rasterIRQLow, y
|
||||
stx ji + 1
|
||||
ldx rasterIRQHigh, y
|
||||
stx ji + 2
|
||||
tax
|
||||
lda rasterIRQLow, y
|
||||
sta ji + 1
|
||||
lda rasterIRQHigh, y
|
||||
sta ji + 2
|
||||
|
||||
ji:
|
||||
jsr $0000
|
||||
|
|
@ -110,43 +49,48 @@ ji:
|
|||
inc nextIRQ
|
||||
ldx nextIRQ
|
||||
|
||||
ldy rasterIRQNext, x
|
||||
|
||||
asl $d019
|
||||
|
||||
cpy #$ff
|
||||
lda rasterIRQNext, x
|
||||
cmp #$ff
|
||||
beq e2
|
||||
// carry is cleared at this point
|
||||
|
||||
dey
|
||||
sty $d012
|
||||
dey
|
||||
cpy $d012
|
||||
tay
|
||||
sbc #2
|
||||
cmp $d012
|
||||
bcc l1
|
||||
|
||||
exd:
|
||||
pla
|
||||
tay
|
||||
pla
|
||||
tax
|
||||
pla
|
||||
dey
|
||||
ex:
|
||||
sty $d012
|
||||
|
||||
plry:
|
||||
ldy #0
|
||||
plrx:
|
||||
ldx #0
|
||||
plra:
|
||||
lda #0
|
||||
rti
|
||||
|
||||
exi:
|
||||
asl $d019
|
||||
jmp exd
|
||||
|
||||
e2:
|
||||
inc rirq_count
|
||||
|
||||
ldy rasterIRQNext
|
||||
dey
|
||||
sty $d012
|
||||
ldx npos
|
||||
stx tpos
|
||||
inc rirq_count
|
||||
tay
|
||||
|
||||
bit $d011
|
||||
bpl ex
|
||||
|
||||
e1:
|
||||
ldx #0
|
||||
stx nextIRQ
|
||||
beq exd
|
||||
ldy rasterIRQNext
|
||||
jmp exd
|
||||
|
||||
}
|
||||
|
||||
__asm rirq_isr_noio
|
||||
__asm irq2
|
||||
{
|
||||
pha
|
||||
txa
|
||||
|
|
@ -160,15 +104,20 @@ kentry:
|
|||
lda #$35
|
||||
sta $01
|
||||
|
||||
asl $d019
|
||||
|
||||
ldx nextIRQ
|
||||
bmi exi
|
||||
l1:
|
||||
lda rasterIRQNext, x
|
||||
cmp #$ff
|
||||
beq e1
|
||||
|
||||
ldy rasterIRQIndex + 1, x
|
||||
ldx rasterIRQLow, y
|
||||
stx ji + 1
|
||||
ldx rasterIRQHigh, y
|
||||
stx ji + 2
|
||||
tax
|
||||
lda rasterIRQLow, y
|
||||
sta ji + 1
|
||||
lda rasterIRQHigh, y
|
||||
sta ji + 2
|
||||
|
||||
ji:
|
||||
jsr $0000
|
||||
|
|
@ -176,20 +125,21 @@ ji:
|
|||
inc nextIRQ
|
||||
ldx nextIRQ
|
||||
|
||||
ldy rasterIRQNext, x
|
||||
|
||||
asl $d019
|
||||
|
||||
cpy #$ff
|
||||
lda rasterIRQNext, x
|
||||
cmp #$ff
|
||||
beq e2
|
||||
// carry is cleared at this point
|
||||
|
||||
tay
|
||||
dey
|
||||
sty $d012
|
||||
dey
|
||||
cpy $d012
|
||||
sbc #2
|
||||
cmp $d012
|
||||
bcc l1
|
||||
|
||||
exd:
|
||||
sty $d012
|
||||
|
||||
ex:
|
||||
|
||||
pla
|
||||
sta $01
|
||||
|
||||
|
|
@ -200,35 +150,45 @@ exd:
|
|||
pla
|
||||
rti
|
||||
|
||||
exi:
|
||||
asl $d019
|
||||
jmp exd
|
||||
|
||||
e2:
|
||||
|
||||
ldx npos
|
||||
stx tpos
|
||||
inc rirq_count
|
||||
|
||||
bit $d011
|
||||
bmi e1
|
||||
|
||||
sta $d012
|
||||
jmp ex
|
||||
|
||||
e1:
|
||||
ldx #0
|
||||
stx nextIRQ
|
||||
ldy rasterIRQNext
|
||||
dey
|
||||
sty $d012
|
||||
ldx #0
|
||||
stx nextIRQ
|
||||
beq exd
|
||||
jmp ex
|
||||
|
||||
}
|
||||
|
||||
__asm rirq_isr_kernal_io
|
||||
__asm irq1
|
||||
{
|
||||
lda $d019
|
||||
bpl ex2
|
||||
|
||||
ldx nextIRQ
|
||||
bmi exi
|
||||
l1:
|
||||
lda rasterIRQNext, x
|
||||
cmp #$ff
|
||||
beq e1
|
||||
|
||||
ldy rasterIRQIndex + 1, x
|
||||
ldx rasterIRQLow, y
|
||||
stx ji + 1
|
||||
ldx rasterIRQHigh, y
|
||||
stx ji + 2
|
||||
tax
|
||||
lda rasterIRQLow, y
|
||||
sta ji + 1
|
||||
lda rasterIRQHigh, y
|
||||
sta ji + 2
|
||||
|
||||
ji:
|
||||
jsr $0000
|
||||
|
|
@ -237,36 +197,45 @@ jx:
|
|||
inc nextIRQ
|
||||
ldx nextIRQ
|
||||
|
||||
ldy rasterIRQNext, x
|
||||
|
||||
asl $d019
|
||||
|
||||
cpy #$ff
|
||||
lda rasterIRQNext, x
|
||||
cmp #$ff
|
||||
beq e2
|
||||
|
||||
dey
|
||||
dey
|
||||
sty $d012
|
||||
dey
|
||||
cpy $d012
|
||||
tay
|
||||
|
||||
sec
|
||||
sbc #4
|
||||
cmp $d012
|
||||
bcc l1
|
||||
|
||||
exd:
|
||||
jmp $ea81
|
||||
|
||||
exi:
|
||||
asl $d019
|
||||
jmp $ea81
|
||||
|
||||
e2:
|
||||
inc rirq_count
|
||||
|
||||
ldy rasterIRQNext
|
||||
dey
|
||||
dey
|
||||
sty $d012
|
||||
w1:
|
||||
jmp ex
|
||||
|
||||
e2:
|
||||
ldx npos
|
||||
stx tpos
|
||||
inc rirq_count
|
||||
|
||||
bit $d011
|
||||
bmi e1
|
||||
|
||||
sta $d012
|
||||
|
||||
jmp ex
|
||||
|
||||
e1:
|
||||
ldx #0
|
||||
stx nextIRQ
|
||||
lda rasterIRQNext, x
|
||||
sec
|
||||
sbc #1
|
||||
sta $d012
|
||||
|
||||
ex:
|
||||
asl $d019
|
||||
|
||||
jmp $ea81
|
||||
|
||||
ex2:
|
||||
|
|
@ -275,7 +244,7 @@ ex2:
|
|||
jmp $ea31
|
||||
}
|
||||
|
||||
__asm rirq_isr_kernal_noio
|
||||
__asm irq3
|
||||
{
|
||||
lda $01
|
||||
pha
|
||||
|
|
@ -286,14 +255,17 @@ __asm rirq_isr_kernal_noio
|
|||
bpl ex2
|
||||
|
||||
ldx nextIRQ
|
||||
bmi exi
|
||||
l1:
|
||||
lda rasterIRQNext, x
|
||||
cmp #$ff
|
||||
beq e1
|
||||
|
||||
ldy rasterIRQIndex + 1, x
|
||||
ldx rasterIRQLow, y
|
||||
stx ji + 1
|
||||
ldx rasterIRQHigh, y
|
||||
stx ji + 2
|
||||
tax
|
||||
lda rasterIRQLow, y
|
||||
sta ji + 1
|
||||
lda rasterIRQHigh, y
|
||||
sta ji + 2
|
||||
|
||||
ji:
|
||||
jsr $0000
|
||||
|
|
@ -302,40 +274,49 @@ jx:
|
|||
inc nextIRQ
|
||||
ldx nextIRQ
|
||||
|
||||
ldy rasterIRQNext, x
|
||||
|
||||
asl $d019
|
||||
|
||||
cpy #$ff
|
||||
lda rasterIRQNext, x
|
||||
cmp #$ff
|
||||
beq e2
|
||||
|
||||
dey
|
||||
tay
|
||||
|
||||
sec
|
||||
sbc #4
|
||||
cmp $d012
|
||||
bcc l1
|
||||
|
||||
dey
|
||||
sty $d012
|
||||
dey
|
||||
cpy $d012
|
||||
bcc l1
|
||||
exd:
|
||||
w1:
|
||||
jmp ex
|
||||
|
||||
e2:
|
||||
ldx npos
|
||||
stx tpos
|
||||
inc rirq_count
|
||||
|
||||
bit $d011
|
||||
bmi e1
|
||||
|
||||
sta $d012
|
||||
|
||||
jmp ex
|
||||
|
||||
e1:
|
||||
ldx #0
|
||||
stx nextIRQ
|
||||
lda rasterIRQNext, x
|
||||
sec
|
||||
sbc #1
|
||||
sta $d012
|
||||
|
||||
ex:
|
||||
asl $d019
|
||||
pla
|
||||
sta $01
|
||||
|
||||
jmp $ea81
|
||||
|
||||
exi:
|
||||
asl $d019
|
||||
jmp exd
|
||||
|
||||
e2:
|
||||
inc rirq_count
|
||||
|
||||
ldy rasterIRQNext
|
||||
dey
|
||||
dey
|
||||
sty $d012
|
||||
ldx #0
|
||||
stx nextIRQ
|
||||
beq exd
|
||||
|
||||
ex2:
|
||||
LDA $DC0D
|
||||
cli
|
||||
|
|
@ -365,8 +346,8 @@ void rirq_build(RIRQCode * ic, byte size)
|
|||
ic->size = size;
|
||||
|
||||
asm_im(ic->code + 0, ASM_LDY, 0);
|
||||
asm_im(ic->code + 2, ASM_LDX, 0);
|
||||
asm_ab(ic->code + 4, ASM_CMP, 0xd012);
|
||||
asm_im(ic->code + 2, ASM_LDA, 0);
|
||||
asm_ab(ic->code + 4, ASM_CPX, 0xd012);
|
||||
asm_rl(ic->code + 7, ASM_BCS, -5);
|
||||
asm_ab(ic->code + 9, ASM_STY, 0x0000);
|
||||
|
||||
|
|
@ -380,7 +361,7 @@ void rirq_build(RIRQCode * ic, byte size)
|
|||
}
|
||||
else
|
||||
{
|
||||
asm_ab(ic->code + 12, ASM_STX, 0x0000);
|
||||
asm_ab(ic->code + 12, ASM_STA, 0x0000);
|
||||
|
||||
byte p = 15;
|
||||
for(byte i=2; i<size; i++)
|
||||
|
|
@ -500,7 +481,7 @@ void rirq_init_kernal(void)
|
|||
sei
|
||||
}
|
||||
|
||||
*(void **)0x0314 = rirq_isr_kernal_io;
|
||||
*(void **)0x0314 = irq1;
|
||||
|
||||
vic.intr_enable = 1;
|
||||
vic.ctrl1 &= 0x7f;
|
||||
|
|
@ -508,7 +489,7 @@ void rirq_init_kernal(void)
|
|||
|
||||
}
|
||||
|
||||
void rirq_init_kernal_noio(void)
|
||||
void rirq_init_kernal_io(void)
|
||||
{
|
||||
rirq_init_tables();
|
||||
|
||||
|
|
@ -517,7 +498,7 @@ void rirq_init_kernal_noio(void)
|
|||
sei
|
||||
}
|
||||
|
||||
*(void **)0x0314 = rirq_isr_kernal_noio;
|
||||
*(void **)0x0314 = irq3;
|
||||
|
||||
vic.intr_enable = 1;
|
||||
vic.ctrl1 &= 0x7f;
|
||||
|
|
@ -534,8 +515,8 @@ void rirq_init_crt(void)
|
|||
sei
|
||||
}
|
||||
|
||||
*(void **)0x0314 = rirq_isr_io.kentry;
|
||||
*(void **)0xfffe = rirq_isr_io;
|
||||
*(void **)0x0314 = irq0.kentry;
|
||||
*(void **)0xfffe = irq0;
|
||||
|
||||
vic.intr_enable = 1;
|
||||
vic.ctrl1 &= 0x7f;
|
||||
|
|
@ -543,7 +524,7 @@ void rirq_init_crt(void)
|
|||
|
||||
}
|
||||
|
||||
void rirq_init_crt_noio(void)
|
||||
void rirq_init_crt_io(void)
|
||||
{
|
||||
rirq_init_tables();
|
||||
|
||||
|
|
@ -552,8 +533,8 @@ void rirq_init_crt_noio(void)
|
|||
sei
|
||||
}
|
||||
|
||||
*(void **)0x0314 = rirq_isr_noio.kentry;
|
||||
*(void **)0xfffe = rirq_isr_noio;
|
||||
*(void **)0x0314 = irq2.kentry;
|
||||
*(void **)0xfffe = irq2;
|
||||
|
||||
vic.intr_enable = 1;
|
||||
vic.ctrl1 &= 0x7f;
|
||||
|
|
@ -570,7 +551,7 @@ void rirq_init_io(void)
|
|||
sei
|
||||
}
|
||||
|
||||
*(void **)0xfffe = rirq_isr_ram_io;
|
||||
*(void **)0xfffe = irq0;
|
||||
|
||||
vic.intr_enable = 1;
|
||||
vic.ctrl1 &= 0x7f;
|
||||
|
|
@ -587,7 +568,7 @@ void rirq_init_memmap(void)
|
|||
sei
|
||||
}
|
||||
|
||||
*(void **)0xfffe = rirq_isr_noio;
|
||||
*(void **)0xfffe = irq2;
|
||||
|
||||
vic.intr_enable = 1;
|
||||
vic.ctrl1 &= 0x7f;
|
||||
|
|
@ -605,18 +586,12 @@ void rirq_init(bool kernalIRQ)
|
|||
|
||||
void rirq_wait(void)
|
||||
{
|
||||
char i0 = rirq_pcount;
|
||||
char i1;
|
||||
do {
|
||||
i1 = rirq_count;
|
||||
} while (i0 == i1);
|
||||
rirq_pcount = i1;
|
||||
while (tpos != npos) ;
|
||||
npos++;
|
||||
}
|
||||
|
||||
void rirq_sort(bool inirq)
|
||||
{
|
||||
// disable raster interrupts while sorting
|
||||
nextIRQ = 0xff;
|
||||
#if 1
|
||||
byte maxr = rasterIRQRows[rasterIRQIndex[1]];
|
||||
for(byte i = 2; i<NUM_IRQS + 1; i++)
|
||||
|
|
@ -664,17 +639,15 @@ void rirq_sort(bool inirq)
|
|||
}
|
||||
#endif
|
||||
|
||||
rirq_pcount = rirq_count;
|
||||
npos++;
|
||||
if (inirq)
|
||||
nextIRQ = NUM_IRQS - 1;
|
||||
else
|
||||
{
|
||||
byte yp = rasterIRQNext[0];
|
||||
if (yp != 0xff)
|
||||
{
|
||||
vic.raster = yp - 1;
|
||||
nextIRQ = 0;
|
||||
}
|
||||
byte yp = rasterIRQNext[nextIRQ];
|
||||
if (yp != 0xff)
|
||||
vic.raster = yp - 1;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -689,7 +662,6 @@ void rirq_start(void)
|
|||
lda #100
|
||||
sta $d012
|
||||
|
||||
asl $d019
|
||||
cli
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -154,7 +154,7 @@ void rirq_init_kernal(void);
|
|||
|
||||
// Raster IRQ through kernal, with IO range not always enabled
|
||||
// calls kernal continuation
|
||||
void rirq_init_kernal_noio(void);
|
||||
void rirq_init_kernal_io(void);
|
||||
|
||||
// Raster IRQ through RAM and ROM vector, with ROM disabled or not and IO range always enabled
|
||||
// does not call kernal continuation
|
||||
|
|
@ -162,7 +162,7 @@ void rirq_init_crt(void);
|
|||
|
||||
// Raster IRQ through RAM and ROM vector, with ROM disabled or not and IO range not always enabled
|
||||
// does not call kernal continuation
|
||||
void rirq_init_crt_noio(void);
|
||||
void rirq_init_crt_io(void);
|
||||
|
||||
// Raster IRQ through RAM vector, with ROM disabled and IO range always enabled
|
||||
// does not call kernal continuation
|
||||
|
|
@ -179,7 +179,7 @@ void rirq_start(void);
|
|||
void rirq_stop(void);
|
||||
|
||||
// Sort the raster IRQ, must be performed at the end of the frame after changing
|
||||
// the vertical position of one of the interrupt operations.
|
||||
// the vertical position of one of the interrupt operatins.
|
||||
// Set the inirq flag to true when calling this from an interrupt
|
||||
void rirq_sort(bool inirq = false);
|
||||
|
||||
|
|
|
|||
|
|
@ -114,21 +114,4 @@ void vic_waitBelow(int line)
|
|||
}
|
||||
}
|
||||
|
||||
void vic_waitRange(char below, char above)
|
||||
{
|
||||
while (vic.ctrl1 & VIC_CTRL1_RST8)
|
||||
;
|
||||
|
||||
if (vic.raster >= above)
|
||||
{
|
||||
while (!(vic.ctrl1 & VIC_CTRL1_RST8))
|
||||
;
|
||||
while (vic.ctrl1 & VIC_CTRL1_RST8)
|
||||
;
|
||||
}
|
||||
|
||||
while (vic.raster < below)
|
||||
;
|
||||
}
|
||||
|
||||
#pragma native(vic_waitLine)
|
||||
|
|
|
|||
|
|
@ -118,9 +118,6 @@ void vic_waitLine(int line);
|
|||
// wait for beam to be below a line
|
||||
void vic_waitBelow(int line);
|
||||
|
||||
// wait for beam to be in a given range on screen
|
||||
void vic_waitRange(char below, char above);
|
||||
|
||||
// reference to the VIC chip
|
||||
#define vic (*((struct VIC *)0xd000))
|
||||
|
||||
|
|
|
|||
|
|
@ -224,10 +224,11 @@ void putpch(char c)
|
|||
c ^= 0xa0;
|
||||
c ^= 0x20;
|
||||
#else
|
||||
if (c >= 97)
|
||||
c ^= 0x20;
|
||||
#endif
|
||||
|
||||
if (giocharmap == IOCHM_PETSCII_1)
|
||||
if (giocharmap == IOCHM_PETSCII_2)
|
||||
c &= 0xdf;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -756,11 +756,6 @@ __asm mul32
|
|||
sta tmp + 6
|
||||
sta tmp + 7
|
||||
|
||||
lda tmp + 3
|
||||
ora tmp + 2
|
||||
ora tmp + 1
|
||||
beq WB
|
||||
|
||||
lda tmp + 0
|
||||
jsr WM
|
||||
lda tmp + 1
|
||||
|
|
@ -778,7 +773,6 @@ WM:
|
|||
stx accu + 1
|
||||
sta accu
|
||||
rts
|
||||
WB: lda tmp + 0
|
||||
W0:
|
||||
sec
|
||||
ror
|
||||
|
|
|
|||
|
|
@ -33,15 +33,10 @@ bool isfinite(float f);
|
|||
#pragma intrinsic(sin)
|
||||
#pragma intrinsic(cos)
|
||||
#pragma intrinsic(tan)
|
||||
#pragma intrinsic(atan)
|
||||
#pragma intrinsic(atan2)
|
||||
|
||||
#pragma intrinsic(log)
|
||||
#pragma intrinsic(exp)
|
||||
|
||||
#pragma intrinsic(pow)
|
||||
#pragma intrinsic(sqrt)
|
||||
|
||||
#pragma compile("math.c")
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -4,7 +4,6 @@
|
|||
#include <new>
|
||||
#include <stdlib.h>
|
||||
#include <opp/utility.h>
|
||||
#include <oscar.h>
|
||||
|
||||
namespace opp {
|
||||
|
||||
|
|
@ -12,8 +11,8 @@ template <class T, int N>
|
|||
class static_vector
|
||||
{
|
||||
protected:
|
||||
enum { m = N } _size;
|
||||
char _space[N * sizeof(T)];
|
||||
enum { m = N } _size;
|
||||
public:
|
||||
typedef T element_type;
|
||||
|
||||
|
|
@ -21,28 +20,23 @@ public:
|
|||
|
||||
static_vector(size_t n) : _size(n)
|
||||
{
|
||||
#ifdef CAPACITYCHECK
|
||||
if (n > N) debugcrash();
|
||||
#endif
|
||||
T * data = (T*)_space;
|
||||
for(size_t i=0; i<n; i++)
|
||||
new (data + i) T();
|
||||
new (data + i) T;
|
||||
}
|
||||
|
||||
static_vector(const static_vector & v)
|
||||
: _size(v._size)
|
||||
{
|
||||
size_t n = _size;
|
||||
T * data = (T*)_space, * vdata = (T*)(v._space);
|
||||
for(size_t i=0; i<n; i++)
|
||||
for(size_t i=0; i<_size; i++)
|
||||
new (data + i)T(vdata[i]);
|
||||
}
|
||||
|
||||
~static_vector(void)
|
||||
{
|
||||
T * data = (T*)_space;
|
||||
size_t n = _size;
|
||||
for(size_t i=0; i<n; i++)
|
||||
for(size_t i=0; i<_size; i++)
|
||||
data[i].~T();
|
||||
}
|
||||
|
||||
|
|
@ -51,12 +45,10 @@ public:
|
|||
if (this != &v)
|
||||
{
|
||||
T * data = (T*)_space, * vdata = (T*)(v._space);
|
||||
size_t n = _size;
|
||||
for(size_t i=0; i<n; i++)
|
||||
for(size_t i=0; i<_size; i++)
|
||||
data[i].~T();
|
||||
_size = v._size;
|
||||
n = _size;
|
||||
for(size_t i=0; i<n; i++)
|
||||
for(size_t i=0; i<_size; i++)
|
||||
new (data + i)T(vdata[i]);
|
||||
}
|
||||
return *this;
|
||||
|
|
@ -77,11 +69,6 @@ public:
|
|||
return _size == 0;
|
||||
}
|
||||
|
||||
bool full(void) const
|
||||
{
|
||||
return _size == N;
|
||||
}
|
||||
|
||||
size_t capacity(void) const
|
||||
{
|
||||
return N;
|
||||
|
|
@ -89,8 +76,6 @@ public:
|
|||
|
||||
void resize(size_t n);
|
||||
|
||||
void clear(void);
|
||||
|
||||
T & at(size_t at)
|
||||
{
|
||||
return ((T*)_space)[at];
|
||||
|
|
@ -181,8 +166,6 @@ public:
|
|||
((T*)_space)[_size].~T();
|
||||
}
|
||||
|
||||
void assign(size_t count, const T & t);
|
||||
|
||||
void insert(size_t at, const T & t);
|
||||
|
||||
void erase(size_t at, size_t n = 1);
|
||||
|
|
@ -194,50 +177,34 @@ public:
|
|||
};
|
||||
|
||||
|
||||
template <class T, int N>
|
||||
void static_vector<T, N>::clear(void)
|
||||
{
|
||||
T * data = (T*)_space;
|
||||
for(size_t i=0; i<_size; i++)
|
||||
data[i].~T();
|
||||
_size = 0;
|
||||
}
|
||||
|
||||
template <class T, int N>
|
||||
void static_vector<T, N>::resize(size_t n)
|
||||
{
|
||||
#ifdef CAPACITYCHECK
|
||||
if (n > N) debugcrash();
|
||||
#endif
|
||||
T * data = (T*)_space;
|
||||
if (n < _size)
|
||||
{
|
||||
for(size_t i=n; i<_size; i++)
|
||||
data[i].~T();
|
||||
_size = n;
|
||||
}
|
||||
else if (n > 0)
|
||||
else
|
||||
{
|
||||
for(size_t i=_size; i<n; i++)
|
||||
new(data + i)T();
|
||||
}
|
||||
new(data + i)T;
|
||||
_size = n;
|
||||
}
|
||||
}
|
||||
|
||||
template <class T, int N>
|
||||
void static_vector<T, N>::push_back(const T & t)
|
||||
{
|
||||
#ifdef CAPACITYCHECK
|
||||
if (_size >= N) debugcrash();
|
||||
#endif
|
||||
new ((T*)_space + _size++)T(t);
|
||||
}
|
||||
|
||||
template <class T, int N>
|
||||
void static_vector<T, N>::push_back(T && t)
|
||||
{
|
||||
#ifdef CAPACITYCHECK
|
||||
if (_size >= N) debugcrash();
|
||||
#endif
|
||||
new ((T*)_space + _size++)T(t);
|
||||
}
|
||||
|
||||
|
|
@ -245,28 +212,14 @@ template <class T, int N>
|
|||
template <typename ...P>
|
||||
void static_vector<T, N>::emplace_back(const P&... p)
|
||||
{
|
||||
#ifdef CAPACITYCHECK
|
||||
if (_size >= N) debugcrash();
|
||||
#endif
|
||||
new ((T*)_space + _size++)T(p...);
|
||||
}
|
||||
|
||||
template <class T, int N>
|
||||
void static_vector<T, N>::assign(size_t count, const T & t)
|
||||
{
|
||||
T * data = (T*)_space;
|
||||
for(size_t i=0; i<_size; i++)
|
||||
data[i].~T();
|
||||
for(size_t i=0; i<count; i++)
|
||||
new (data + i)T(t);
|
||||
_size = count;
|
||||
}
|
||||
|
||||
template <class T, int N>
|
||||
void static_vector<T, N>::insert(size_t at, const T & t)
|
||||
{
|
||||
T * data = (T*)_space;
|
||||
new (data + _size)T();
|
||||
new (data + _size)T;
|
||||
for(size_t i=_size; i>at; i--)
|
||||
data[i] = move(data[i - 1]);
|
||||
data[at] = t;
|
||||
|
|
@ -287,12 +240,9 @@ void static_vector<T, N>::erase(size_t at, size_t n)
|
|||
template <class T, int N>
|
||||
T * static_vector<T, N>::insert(T * at, const T & t)
|
||||
{
|
||||
#ifdef CAPACITYCHECK
|
||||
if (_size >= N) debugcrash();
|
||||
#endif
|
||||
T * data = (T*)_space;
|
||||
T * dp = data + _size;
|
||||
new (dp)T();
|
||||
new (dp)T;
|
||||
while (dp != at)
|
||||
{
|
||||
dp--;
|
||||
|
|
|
|||
|
|
@ -21,14 +21,13 @@ public:
|
|||
vector(size_t n) : _data((T*)malloc(n * sizeof(T))), _size(n), _capacity(n)
|
||||
{
|
||||
for(size_t i=0; i<n; i++)
|
||||
new (_data + i) T();
|
||||
new (_data + i) T;
|
||||
}
|
||||
|
||||
vector(const vector & v)
|
||||
: _data((T*)malloc(v._size * sizeof(T))), _size(v._size), _capacity(v._size)
|
||||
{
|
||||
size_t n = _size;
|
||||
for(size_t i=0; i<n; i++)
|
||||
for(size_t i=0; i<_size; i++)
|
||||
new (_data + i)T(v._data[i]);
|
||||
}
|
||||
|
||||
|
|
@ -51,16 +50,14 @@ public:
|
|||
{
|
||||
if (this != &v)
|
||||
{
|
||||
size_t n = _size;
|
||||
for(size_t i=0; i<n; i++)
|
||||
for(size_t i=0; i<_size; i++)
|
||||
_data[i].~T();
|
||||
free(_data);
|
||||
|
||||
_data = (T*)malloc(v._size * sizeof(T));
|
||||
_size = v._size;
|
||||
_capacity = v._size;
|
||||
n = _size;
|
||||
for(size_t i=0; i<n; i++)
|
||||
for(size_t i=0; i<_size; i++)
|
||||
new (_data + i)T(v._data[i]);
|
||||
}
|
||||
return *this;
|
||||
|
|
@ -97,8 +94,6 @@ public:
|
|||
return _capacity;
|
||||
}
|
||||
|
||||
void clear(void);
|
||||
|
||||
void resize(size_t n);
|
||||
|
||||
void reserve(size_t n);
|
||||
|
|
@ -195,8 +190,6 @@ public:
|
|||
_data[_size].~T();
|
||||
}
|
||||
|
||||
void assign(size_t count, const T & t);
|
||||
|
||||
void insert(size_t at, const T & t);
|
||||
|
||||
void erase(size_t at, size_t n = 1);
|
||||
|
|
@ -211,7 +204,7 @@ protected:
|
|||
|
||||
|
||||
template <class T>
|
||||
__noinline void vector<T>::reserve(size_t n)
|
||||
void vector<T>::reserve(size_t n)
|
||||
{
|
||||
if (n > _capacity)
|
||||
{
|
||||
|
|
@ -228,15 +221,7 @@ __noinline void vector<T>::reserve(size_t n)
|
|||
}
|
||||
|
||||
template <class T>
|
||||
void vector<T>::clear(void)
|
||||
{
|
||||
for(size_t i=0; i<_size; i++)
|
||||
_data[i].~T();
|
||||
_size = 0;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
__noinline void vector<T>::resize(size_t n)
|
||||
void vector<T>::resize(size_t n)
|
||||
{
|
||||
if (n < _size)
|
||||
{
|
||||
|
|
@ -247,7 +232,7 @@ __noinline void vector<T>::resize(size_t n)
|
|||
else if (n < _capacity)
|
||||
{
|
||||
for(size_t i=_size; i<n; i++)
|
||||
new(_data + i)T();
|
||||
new(_data + i)T;
|
||||
_size = n;
|
||||
}
|
||||
else
|
||||
|
|
@ -301,27 +286,12 @@ void vector<T>::emplace_back(const P&... p)
|
|||
new (add_back())T(p...);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void vector<T>::assign(size_t count, const T & t)
|
||||
{
|
||||
for(size_t i=0; i<_size; i++)
|
||||
_data[i].~T();
|
||||
if (count > _capacity)
|
||||
{
|
||||
_size = 0;
|
||||
reserve(count);
|
||||
}
|
||||
for(size_t i=0; i<count; i++)
|
||||
new (_data + i)T(t);
|
||||
_size = count;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void vector<T>::insert(size_t at, const T & t)
|
||||
{
|
||||
if (_size == _capacity)
|
||||
reserve(_size + 1 + (_size >> 1));
|
||||
new (_data + _size)T();
|
||||
new (_data + _size)T;
|
||||
for(size_t i=_size; i>at; i--)
|
||||
_data[i] = move(_data[i - 1]);
|
||||
_data[at] = t;
|
||||
|
|
@ -348,7 +318,7 @@ T * vector<T>::insert(T * at, const T & t)
|
|||
at = (T *)(f + unsigned(_data));
|
||||
}
|
||||
T * dp = _data + _size;
|
||||
new (dp)T();
|
||||
new (dp)T;
|
||||
while (dp != at)
|
||||
{
|
||||
dp--;
|
||||
|
|
|
|||
|
|
@ -129,10 +129,3 @@ __native const char * oscar_expand_lzo_buf(char * dp, const char * sp)
|
|||
|
||||
return sp + 1;
|
||||
}
|
||||
|
||||
void debugcrash(void)
|
||||
{
|
||||
__asm volatile {
|
||||
byt $02
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -18,8 +18,6 @@ void breakpoint(void);
|
|||
|
||||
#pragma intrinsic(breakpoint)
|
||||
|
||||
void debugcrash(void);
|
||||
|
||||
#pragma compile("oscar.c")
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -556,17 +556,6 @@ int sprintf(char * str, const char * fmt, ...)
|
|||
return d - str;
|
||||
}
|
||||
|
||||
void vprintf(const char * fmt, va_list vlist)
|
||||
{
|
||||
char buff[50];
|
||||
sformat(buff, fmt, (int *)vlist, true);
|
||||
}
|
||||
|
||||
int vsprintf(char * str, const char * fmt, va_list vlist)
|
||||
{
|
||||
char * d = sformat(str, fmt, (int *)vlist, false);
|
||||
return d - str;
|
||||
}
|
||||
|
||||
static inline bool isspace(char c)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -3,7 +3,6 @@
|
|||
|
||||
#include <stdlib.h>
|
||||
#include <stddef.h>
|
||||
#include <stdarg.h>
|
||||
|
||||
void putchar(char c);
|
||||
|
||||
|
|
@ -19,10 +18,6 @@ void printf(const char * fmt, ...);
|
|||
|
||||
int sprintf(char * str, const char * fmt, ...);
|
||||
|
||||
void vprintf(const char * fmt, va_list vlist);
|
||||
|
||||
int vsprintf(char * str, const char * fmt, va_list vlist);
|
||||
|
||||
int scanf(const char * fmt, ...);
|
||||
|
||||
int sscanf(const char * str, const char * fmt, ...);
|
||||
|
|
|
|||
|
|
@ -544,7 +544,7 @@ unsigned heapfree(void)
|
|||
}
|
||||
|
||||
#if 0
|
||||
struct Heap {q
|
||||
struct Heap {
|
||||
unsigned int size;
|
||||
Heap * next;
|
||||
} * freeHeap;
|
||||
|
|
@ -667,97 +667,6 @@ void * calloc(int num, int size)
|
|||
return p;
|
||||
}
|
||||
|
||||
void * realloc(void * ptr, unsigned size)
|
||||
{
|
||||
if (ptr)
|
||||
{
|
||||
#ifdef HEAPCHECK
|
||||
Heap * pheap = (Heap *)((char *)ptr - 6);
|
||||
Heap * eheap = pheap->next;
|
||||
|
||||
unsigned psize = (char *)eheap - (char *)pheap;
|
||||
|
||||
void * nptr = malloc(size);
|
||||
memcpy(nptr, ptr, psize - 6);
|
||||
free(ptr);
|
||||
return nptr;
|
||||
#else
|
||||
unsigned nsize = (size + 5) & ~3;
|
||||
|
||||
// Get heap info
|
||||
Heap * pheap = (Heap *)((char *)ptr - 2);
|
||||
Heap * eheap = pheap->next;
|
||||
|
||||
unsigned psize = (char *)eheap - (char *)pheap;
|
||||
|
||||
Heap * h = HeapNode.next;
|
||||
Heap * hp = &HeapNode;
|
||||
while (h && h < pheap)
|
||||
{
|
||||
hp = h;
|
||||
h = h->next;
|
||||
}
|
||||
|
||||
if (nsize <= psize)
|
||||
{
|
||||
// check if we should free some memory
|
||||
if (nsize + sizeof(HeapNode) < psize)
|
||||
{
|
||||
Heap * nheap = (Heap *)((char *)pheap + nsize);
|
||||
pheap->next = nheap;
|
||||
|
||||
if (h == eheap)
|
||||
{
|
||||
nheap->end = h->end;
|
||||
nheap->next = h->next;
|
||||
}
|
||||
else
|
||||
{
|
||||
nheap->end = eheap;
|
||||
nheap->next = h;
|
||||
}
|
||||
|
||||
hp->next = nheap;
|
||||
}
|
||||
|
||||
return ptr;
|
||||
}
|
||||
else if (h == eheap)
|
||||
{
|
||||
// Free space after this
|
||||
|
||||
// Check if enough space if extending
|
||||
unsigned xsize = (char *)h->end - (char *)pheap;
|
||||
if (xsize >= nsize)
|
||||
{
|
||||
if (xsize > nsize + sizeof(HeapNode))
|
||||
{
|
||||
Heap * nheap = (Heap *)((char *)pheap + nsize);
|
||||
pheap->next = nheap;
|
||||
nheap->end = h->end;
|
||||
nheap->next = h->next;
|
||||
hp->next = nheap;
|
||||
}
|
||||
else
|
||||
{
|
||||
pheap->next = h->end;
|
||||
hp->next = h->next;
|
||||
}
|
||||
|
||||
return ptr;
|
||||
}
|
||||
}
|
||||
|
||||
void * nptr = malloc(size);
|
||||
memcpy(nptr, ptr, psize - 2);
|
||||
free(ptr);
|
||||
return nptr;
|
||||
#endif
|
||||
}
|
||||
else
|
||||
return malloc(size);
|
||||
}
|
||||
|
||||
static unsigned seed = 31232;
|
||||
|
||||
unsigned int rand(void)
|
||||
|
|
|
|||
|
|
@ -45,8 +45,6 @@ void free(void * ptr);
|
|||
|
||||
void * calloc(int num, int size);
|
||||
|
||||
void * realloc(void * ptr, unsigned size);
|
||||
|
||||
unsigned heapfree(void);
|
||||
|
||||
unsigned int rand(void);
|
||||
|
|
|
|||
|
|
@ -38,7 +38,7 @@ else
|
|||
endif
|
||||
|
||||
|
||||
all: compiler samples check
|
||||
all: --prep-build-dir compiler samples tests
|
||||
|
||||
|
||||
$(srcdir)/%.o: $(project_dir)/oscar64/%.cpp
|
||||
|
|
@ -56,7 +56,7 @@ $(srcdir)/%.d: $(project_dir)/oscar64/%.cpp
|
|||
$(RM) $@.$$$$
|
||||
|
||||
|
||||
compiler: --prep-build-dir $(objects)
|
||||
compiler: $(objects)
|
||||
@$(MKDIR_PARENT) $(srcdir)
|
||||
@echo "Linking compiler..."
|
||||
$(CXX) $(CPPFLAGS) $(objects) $(linklibs) -o $(project_dir)/bin/oscar64
|
||||
|
|
@ -85,7 +85,7 @@ samples: compiler
|
|||
@$(MAKE) -C $(project_dir)/samples all
|
||||
|
||||
|
||||
check: compiler
|
||||
tests: compiler
|
||||
@$(MAKE) -C $(project_dir)/autotest all
|
||||
|
||||
install: compiler
|
||||
|
|
@ -93,16 +93,16 @@ install: compiler
|
|||
@$(MKDIR_PARENT) $(DESTDIR)$(bindir)
|
||||
$(INSTALL_PROGRAM) $(project_dir)/bin/oscar64 $(DESTDIR)$(bindir)
|
||||
@$(MKDIR_PARENT) $(DESTDIR)$(includedir)/oscar64/{audio,c64,c128,cx16,gfx,nes,opp,plus4,vic20}
|
||||
$(INSTALL_DATA) $(wildcard $(project_dir)/include/*.h $(project_dir)/include/*.c) $(DESTDIR)$(includedir)/oscar64
|
||||
$(INSTALL_DATA) $(wildcard $(project_dir)/include/audio/*.h $(project_dir)/include/audio/*.c) $(DESTDIR)$(includedir)/oscar64/audio
|
||||
$(INSTALL_DATA) $(wildcard $(project_dir)/include/c64/*.h $(project_dir)/include/c64/*.c) $(DESTDIR)$(includedir)/oscar64/c64
|
||||
$(INSTALL_DATA) $(wildcard $(project_dir)/include/c128/*.h $(project_dir)/include/c128/*.c) $(DESTDIR)$(includedir)/oscar64/c128
|
||||
$(INSTALL_DATA) $(wildcard $(project_dir)/include/cx16/*.h $(project_dir)/include/cx16/*.c) $(DESTDIR)$(includedir)/oscar64/cx16
|
||||
$(INSTALL_DATA) $(wildcard $(project_dir)/include/gfx/*.h $(project_dir)/include/gfx/*.c) $(DESTDIR)$(includedir)/oscar64/gfx
|
||||
$(INSTALL_DATA) $(wildcard $(project_dir)/include/nes/*.h $(project_dir)/include/nes/*.c) $(DESTDIR)$(includedir)/oscar64/nes
|
||||
$(INSTALL_DATA) $(wildcard $(project_dir)/include/opp/*.h $(project_dir)/include/opp/*.cpp) $(DESTDIR)$(includedir)/oscar64/opp
|
||||
$(INSTALL_DATA) $(wildcard $(project_dir)/include/plus4/*.h $(project_dir)/include/plus4/*.c) $(DESTDIR)$(includedir)/oscar64/plus4
|
||||
$(INSTALL_DATA) $(wildcard $(project_dir)/include/vic20/*.h $(project_dir)/include/vic20/*.c) $(DESTDIR)$(includedir)/oscar64/vic20
|
||||
$(INSTALL_DATA) $(project_dir)/include/*.{h,c} $(DESTDIR)$(includedir)/oscar64
|
||||
$(INSTALL_DATA) $(project_dir)/include/audio/*.{h,c} $(DESTDIR)$(includedir)/oscar64/audio
|
||||
$(INSTALL_DATA) $(project_dir)/include/c64/*.{h,c} $(DESTDIR)$(includedir)/oscar64/c64
|
||||
$(INSTALL_DATA) $(project_dir)/include/c128/*.{h,c} $(DESTDIR)$(includedir)/oscar64/c128
|
||||
$(INSTALL_DATA) $(project_dir)/include/cx16/*.{h,c} $(DESTDIR)$(includedir)/oscar64/cx16
|
||||
$(INSTALL_DATA) $(project_dir)/include/gfx/*.{h,c} $(DESTDIR)$(includedir)/oscar64/gfx
|
||||
$(INSTALL_DATA) $(project_dir)/include/nes/*.{h,c} $(DESTDIR)$(includedir)/oscar64/nes
|
||||
$(INSTALL_DATA) $(project_dir)/include/opp/*.{h,cpp} $(DESTDIR)$(includedir)/oscar64/opp
|
||||
$(INSTALL_DATA) $(project_dir)/include/plus4/*.{h,c} $(DESTDIR)$(includedir)/oscar64/plus4
|
||||
$(INSTALL_DATA) $(project_dir)/include/vic20/*.{h,c} $(DESTDIR)$(includedir)/oscar64/vic20
|
||||
|
||||
|
||||
uninstall:
|
||||
|
|
|
|||
21
oscar64.md
21
oscar64.md
|
|
@ -28,7 +28,7 @@ In the end, it turned out that the native code is not only significantly faster
|
|||
|
||||
## Limits and Errors
|
||||
|
||||
There are still several open areas, but most targets have been reached. The current Dhrystone performance is 94 iterations per second with byte code (10993) and 442 iterations with native code (8952 Bytes). This clearly shows that Dhrystone is not a valid benchmark for optimizing compilers, because it puts the 6502 on par with a 4MHz 8088 or 68k, which it clearly is not.
|
||||
There are still several open areas, but most targets have been reached. The current Dhrystone performance is 94 iterations per second with byte code (10993) and 405 iterations with native code (9173 Bytes). This clearly shows that Dhrystone is not a valid benchmark for optimizing compilers, because it puts the 6502 on par with a 4MHz 8088 or 68k, which it clearly is not.
|
||||
|
||||
### Language
|
||||
|
||||
|
|
@ -110,7 +110,6 @@ The compiler is command line driven, and creates an executable .prg file.
|
|||
* -v : verbose output for diagnostics
|
||||
* -v2 : more verbose output
|
||||
* -i : additional include paths
|
||||
* -ii : set default include path
|
||||
* -o : optional output file name
|
||||
* -rt : alternative runtime library, replaces the crt.c (or empty for none)
|
||||
* -e : execute the result in the integrated emulator
|
||||
|
|
@ -130,7 +129,6 @@ The compiler is command line driven, and creates an executable .prg file.
|
|||
* -Oz : enable auto placement of global variables in zero page (part of O3)
|
||||
* -Op : optimize constant parameters
|
||||
* -Oo : optimize size using "outliner" (extract repeated code sequences into functions)
|
||||
* -Ox : optimize pointer arithmetic by blocking shorter arrays to not cross page boundaries
|
||||
* -g : create source level debug info and add source line numbers to asm listing
|
||||
* -gp : create source level debug info and add source line numbers to asm listing and static profile data
|
||||
* -tf : target format, may be prg, crt or bin
|
||||
|
|
@ -177,7 +175,6 @@ A list of source files can be provided.
|
|||
* nes_mmc3 : Nintendo entertainment system, MMC3, 512K PROM, 256K CROM
|
||||
* atari : Atari 8bit systems, (0x2000..0xbc00)
|
||||
* x16 : Commander X16, (0x0800..0x9f00)
|
||||
* mega65 : Mega 65, (0x2000..0xc000)
|
||||
|
||||
### C64 Cartridge formats
|
||||
|
||||
|
|
@ -337,17 +334,6 @@ The .asm file is a great resource when debugging from within e.g. the VICE monit
|
|||
|
||||
The compiler has various extensions to simplify developing for the C64.
|
||||
|
||||
## Pragmas
|
||||
|
||||
Warnings can be turned on or off using the warning pragma. The scope of the pragma is currently global in most cases, so if it is turned off at some place, it is off everywhere.
|
||||
|
||||
#pragma warning(disable: 2000,2001)
|
||||
|
||||
A message can be displayed during compilation with the message pragma
|
||||
|
||||
#pragma message("Hello User")
|
||||
|
||||
|
||||
## Embedding binary data
|
||||
|
||||
The compiler supports the #embed preprocessor directive to import binary data. It converts a section of an external binary file into a sequence of numbers that can be placed into an initializer of an array.
|
||||
|
|
@ -751,11 +737,6 @@ Regions can also be used to place assets such as character sets at fixed locatio
|
|||
|
||||
The #pragma data(), #pragma code() and #pragma bss() control the placement of the generated objects into sections other than the default sections.
|
||||
|
||||
A global variable or function can be aligned on a given power of two start with the align pragma. This is most useful if a page crossing is problematic. The compiler may also be able to generate more efficient code, if a larger variable is page aligned.
|
||||
|
||||
#pragma align(myvar, 8)
|
||||
#pragma align(myfunc, 256)
|
||||
|
||||
### Additional BSS sections
|
||||
|
||||
Additional bss sections can be defined on request.
|
||||
|
|
|
|||
|
|
@ -421,13 +421,11 @@ protected:
|
|||
array = a2;
|
||||
}
|
||||
|
||||
for (int i = size; i < to; i++) array[i] = T{};
|
||||
|
||||
size = to;
|
||||
}
|
||||
|
||||
template<typename F>
|
||||
void Partition(const F & f, int l, int r)
|
||||
void Parition(const F & f, int l, int r)
|
||||
{
|
||||
if (r > l + 1)
|
||||
{
|
||||
|
|
@ -444,8 +442,8 @@ protected:
|
|||
}
|
||||
array[pi] = p;
|
||||
|
||||
Partition(f, l, pi);
|
||||
Partition(f, pi + 1, r);
|
||||
Parition(f, l, pi);
|
||||
Parition(f, pi + 1, r);
|
||||
}
|
||||
}
|
||||
public:
|
||||
|
|
@ -620,22 +618,10 @@ public:
|
|||
return false;
|
||||
}
|
||||
|
||||
void Fill(const T& t)
|
||||
{
|
||||
for (int i = 0; i < size; i++)
|
||||
array[i] = t;
|
||||
}
|
||||
|
||||
void Clear(void)
|
||||
{
|
||||
for (int i = 0; i < size; i++)
|
||||
array[i] = T{};
|
||||
}
|
||||
|
||||
template<typename F>
|
||||
void Sort(const F & f)
|
||||
{
|
||||
Partition(f, 0, size);
|
||||
Parition(f, 0, size);
|
||||
}
|
||||
|
||||
__forceinline T& operator[](int n)
|
||||
|
|
|
|||
|
|
@ -3,7 +3,6 @@
|
|||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <assert.h>
|
||||
|
||||
class BitVector
|
||||
{
|
||||
|
|
|
|||
|
|
@ -3461,14 +3461,11 @@ ByteCode ByteCodeBasicBlock::RelationalOperator(InterCodeProcedure* proc, const
|
|||
else
|
||||
{
|
||||
if (ins->mSrc[1].mTemp < 0)
|
||||
{
|
||||
if (ins->mSrc[1].mType == IT_INT16 || ins->mSrc[1].mMemory == IM_ABSOLUTE)
|
||||
{
|
||||
ByteCodeInstruction lins(BC_LOAD_REG_16);
|
||||
lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSrc[0].mTemp];
|
||||
lins.mRegisterFinal = ins->mSrc[0].mFinal;
|
||||
mIns.Push(lins);
|
||||
|
||||
if (csigned)
|
||||
{
|
||||
ByteCodeInstruction cins(BC_BINOP_CMPSI_16);
|
||||
|
|
@ -3482,36 +3479,7 @@ ByteCode ByteCodeBasicBlock::RelationalOperator(InterCodeProcedure* proc, const
|
|||
mIns.Push(cins);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
ByteCodeInstruction bins(BC_LEA_ABS);
|
||||
bins.mRegister = BC_REG_ACCU;
|
||||
bins.mLinkerObject = ins->mSrc[1].mLinkerObject;
|
||||
bins.mValue = int(ins->mSrc[1].mIntConst);
|
||||
bins.mRelocate = true;
|
||||
mIns.Push(bins);
|
||||
|
||||
if (csigned)
|
||||
{
|
||||
ByteCodeInstruction cins(BC_BINOP_CMPSR_16);
|
||||
cins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSrc[0].mTemp];
|
||||
cins.mRegisterFinal = ins->mSrc[0].mFinal;
|
||||
mIns.Push(cins);
|
||||
}
|
||||
else
|
||||
{
|
||||
ByteCodeInstruction cins(BC_BINOP_CMPUR_16);
|
||||
cins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSrc[0].mTemp];
|
||||
cins.mRegisterFinal = ins->mSrc[0].mFinal;
|
||||
mIns.Push(cins);
|
||||
}
|
||||
|
||||
code = TransposeBranchCondition(code);
|
||||
}
|
||||
}
|
||||
else if (ins->mSrc[0].mTemp < 0)
|
||||
{
|
||||
if (ins->mSrc[0].mType == IT_INT16 || ins->mSrc[0].mMemory == IM_ABSOLUTE)
|
||||
{
|
||||
ByteCodeInstruction lins(BC_LOAD_REG_16);
|
||||
lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSrc[1].mTemp];
|
||||
|
|
@ -3584,31 +3552,6 @@ ByteCode ByteCodeBasicBlock::RelationalOperator(InterCodeProcedure* proc, const
|
|||
code = TransposeBranchCondition(code);
|
||||
}
|
||||
else
|
||||
{
|
||||
ByteCodeInstruction bins(BC_LEA_ABS);
|
||||
bins.mRegister = BC_REG_ACCU;
|
||||
bins.mLinkerObject = ins->mSrc[0].mLinkerObject;
|
||||
bins.mValue = int(ins->mSrc[0].mIntConst);
|
||||
bins.mRelocate = true;
|
||||
mIns.Push(bins);
|
||||
|
||||
if (csigned)
|
||||
{
|
||||
ByteCodeInstruction cins(BC_BINOP_CMPSR_16);
|
||||
cins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSrc[1].mTemp];
|
||||
cins.mRegisterFinal = ins->mSrc[1].mFinal;
|
||||
mIns.Push(cins);
|
||||
}
|
||||
else
|
||||
{
|
||||
ByteCodeInstruction cins(BC_BINOP_CMPUR_16);
|
||||
cins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSrc[1].mTemp];
|
||||
cins.mRegisterFinal = ins->mSrc[1].mFinal;
|
||||
mIns.Push(cins);
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
ByteCodeInstruction lins(BC_LOAD_REG_16);
|
||||
lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSrc[0].mTemp];
|
||||
|
|
|
|||
|
|
@ -523,12 +523,6 @@ bool Compiler::GenerateCode(void)
|
|||
{
|
||||
switch (mTargetMachine)
|
||||
{
|
||||
case TMACH_MEGA65:
|
||||
if (mCompilerOptions & COPT_NATIVE)
|
||||
regionStartup = mLinker->AddRegion(identStartup, 0x2001, 0x2080);
|
||||
else
|
||||
regionStartup = mLinker->AddRegion(identStartup, 0x2001, 0x2100);
|
||||
break;
|
||||
case TMACH_C64:
|
||||
case TMACH_X16:
|
||||
if (mCompilerOptions & COPT_NATIVE)
|
||||
|
|
@ -631,9 +625,6 @@ bool Compiler::GenerateCode(void)
|
|||
{
|
||||
switch (mTargetMachine)
|
||||
{
|
||||
case TMACH_MEGA65:
|
||||
regionBytecode = mLinker->AddRegion(identBytecode, 0x2100, 0x2200);
|
||||
break;
|
||||
case TMACH_C64:
|
||||
case TMACH_X16:
|
||||
regionBytecode = mLinker->AddRegion(identBytecode, 0x0900, 0x0a00);
|
||||
|
|
@ -695,9 +686,6 @@ bool Compiler::GenerateCode(void)
|
|||
{
|
||||
switch (mTargetMachine)
|
||||
{
|
||||
case TMACH_MEGA65:
|
||||
regionMain = mLinker->AddRegion(identMain, 0x2300, 0xc000);
|
||||
break;
|
||||
case TMACH_C64:
|
||||
regionMain = mLinker->AddRegion(identMain, 0x0a00, 0xa000);
|
||||
break;
|
||||
|
|
@ -749,14 +737,6 @@ bool Compiler::GenerateCode(void)
|
|||
{
|
||||
switch (mTargetMachine)
|
||||
{
|
||||
case TMACH_MEGA65:
|
||||
// TODO: Disable M65 cartridges for now.
|
||||
//
|
||||
// if (mCompilerOptions & (COPT_TARGET_CRT8 | COPT_TARGET_CRT16))
|
||||
// regionMain = mLinker->AddRegion(identMain, 0x2666, 0xff00);
|
||||
// else
|
||||
regionMain = mLinker->AddRegion(identMain, 0x2080, 0xc000);
|
||||
break;
|
||||
case TMACH_C64:
|
||||
|
||||
if (mCompilerOptions & (COPT_TARGET_CRT8 | COPT_TARGET_CRT16))
|
||||
|
|
@ -1065,10 +1045,7 @@ bool Compiler::GenerateCode(void)
|
|||
for (int i = 0; i < mNativeCodeGenerator->mProcedures.Size(); i++)
|
||||
{
|
||||
if (mCompilerOptions & COPT_VERBOSE2)
|
||||
{
|
||||
if (mNativeCodeGenerator->mProcedures[i]->mInterProc)
|
||||
printf("Assemble native code <%s>\n", mNativeCodeGenerator->mProcedures[i]->mInterProc->mIdent->mString);
|
||||
}
|
||||
mNativeCodeGenerator->mProcedures[i]->Assemble();
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -15,7 +15,6 @@ static const uint64 COPT_OPTIMIZE_CONST_PARAMS = 1ULL << 9;
|
|||
static const uint64 COPT_OPTIMIZE_MERGE_CALLS = 1ULL << 10;
|
||||
static const uint64 COPT_OPTIMIZE_GLOBAL = 1ULL << 11;
|
||||
static const uint64 COPT_OPTIMIZE_OUTLINE = 1ULL << 12;
|
||||
static const uint64 COPT_OPTIMIZE_PAGE_CROSSING = 1ULL << 13;
|
||||
|
||||
static const uint64 COPT_OPTIMIZE_CODE_SIZE = 1ULL << 16;
|
||||
static const uint64 COPT_NATIVE = 1ULL << 17;
|
||||
|
|
@ -79,8 +78,7 @@ enum TargetMachine
|
|||
TMACH_NES_MMC1,
|
||||
TMACH_NES_MMC3,
|
||||
TMACH_ATARI,
|
||||
TMACH_X16,
|
||||
TMACH_MEGA65
|
||||
TMACH_X16
|
||||
};
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -651,7 +651,6 @@ Expression* ConstexprInterpreter::EvalConstructor(Expression* exp)
|
|||
{
|
||||
mProcType = exp->mLeft->mDecType;
|
||||
|
||||
Expression* pex = exp->mRight;
|
||||
Declaration* cdec = exp->mLeft->mDecType->mParams;
|
||||
|
||||
int pos = 0;
|
||||
|
|
@ -660,28 +659,6 @@ Expression* ConstexprInterpreter::EvalConstructor(Expression* exp)
|
|||
mParams[pos].PutPtr(Value(&mResult));
|
||||
pos = 2;
|
||||
|
||||
if (pex->mType == EX_LIST)
|
||||
pex = pex->mRight;
|
||||
else
|
||||
pex = nullptr;
|
||||
cdec = cdec->mNext;
|
||||
|
||||
while (pex && pex->mType == EX_LIST)
|
||||
{
|
||||
if (!AddParam(pos, pex->mLeft, cdec))
|
||||
return exp;
|
||||
|
||||
pex = pex->mRight;
|
||||
if (cdec)
|
||||
cdec = cdec->mNext;
|
||||
}
|
||||
|
||||
if (pex)
|
||||
{
|
||||
if (!AddParam(pos, pex, cdec))
|
||||
return exp;
|
||||
}
|
||||
|
||||
mHeap = new ExpandingArray<Value*>();
|
||||
|
||||
Execute(exp->mLeft->mDecValue->mValue);
|
||||
|
|
@ -1197,26 +1174,6 @@ ConstexprInterpreter::Value ConstexprInterpreter::EvalCall(Expression* exp, Cons
|
|||
mResult = Value(exp->mLocation, TheFloatTypeDeclaration);
|
||||
mResult.PutFloat(::exp(mParams[0].GetFloat()));
|
||||
}
|
||||
else if (!strcmp(iname->mString, "sqrt"))
|
||||
{
|
||||
mResult = Value(exp->mLocation, TheFloatTypeDeclaration);
|
||||
mResult.PutFloat(::sqrt(mParams[0].GetFloat()));
|
||||
}
|
||||
else if (!strcmp(iname->mString, "atan"))
|
||||
{
|
||||
mResult = Value(exp->mLocation, TheFloatTypeDeclaration);
|
||||
mResult.PutFloat(::atan(mParams[0].GetFloat()));
|
||||
}
|
||||
else if (!strcmp(iname->mString, "atan2"))
|
||||
{
|
||||
mResult = Value(exp->mLocation, TheFloatTypeDeclaration);
|
||||
mResult.PutFloat(::atan2(mParams[0].GetFloat(), mParams[1].GetFloat()));
|
||||
}
|
||||
else if (!strcmp(iname->mString, "pow"))
|
||||
{
|
||||
mResult = Value(exp->mLocation, TheFloatTypeDeclaration);
|
||||
mResult.PutFloat(::pow(mParams[0].GetFloat(), mParams[1].GetFloat()));
|
||||
}
|
||||
else
|
||||
mErrors->Error(exp->mLeft->mDecValue->mLocation, EERR_OBJECT_NOT_FOUND, "Unknown intrinsic function", iname);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -31,17 +31,6 @@ DeclarationScope::~DeclarationScope(void)
|
|||
delete[] mHash;
|
||||
}
|
||||
|
||||
DeclarationScope* DeclarationScope::Clone(void) const
|
||||
{
|
||||
DeclarationScope* scope = new DeclarationScope(mParent, mLevel, mName);
|
||||
for (int i = 0; i < mHashSize; i++)
|
||||
{
|
||||
if (mHash[i].mIdent)
|
||||
scope->Insert(mHash[i].mIdent, mHash[i].mDec);
|
||||
}
|
||||
return scope;
|
||||
}
|
||||
|
||||
const Ident* DeclarationScope::Mangle(const Ident* ident) const
|
||||
{
|
||||
if (mName && ident)
|
||||
|
|
@ -156,7 +145,7 @@ void DeclarationScope::End(const Location& loc)
|
|||
}
|
||||
|
||||
Expression::Expression(const Location& loc, ExpressionType type)
|
||||
: mLocation(loc), mEndLocation(loc), mType(type), mLeft(nullptr), mRight(nullptr), mConst(false), mDecType(nullptr), mDecValue(nullptr), mToken(TK_NONE), mFlags(0)
|
||||
: mLocation(loc), mEndLocation(loc), mType(type), mLeft(nullptr), mRight(nullptr), mConst(false), mDecType(nullptr), mDecValue(nullptr), mToken(TK_NONE)
|
||||
{
|
||||
static uint32 gUID = 0;
|
||||
mUID = gUID++;
|
||||
|
|
@ -274,9 +263,6 @@ void Expression::Dump(int ident) const
|
|||
case EX_FOR:
|
||||
printf("FOR");
|
||||
break;
|
||||
case EX_FORBODY:
|
||||
printf("FORBODY");
|
||||
break;
|
||||
case EX_DO:
|
||||
printf("DO");
|
||||
break;
|
||||
|
|
@ -505,15 +491,6 @@ Expression* Expression::LogicInvertExpression(void)
|
|||
}
|
||||
}
|
||||
|
||||
void Expression::ReplaceVariable(Declaration* pvar, Declaration* nvar)
|
||||
{
|
||||
if (mLeft) mLeft->ReplaceVariable(pvar, nvar);
|
||||
if (mRight) mRight->ReplaceVariable(pvar, nvar);
|
||||
|
||||
if (mType == EX_VARIABLE && mDecValue == pvar)
|
||||
mDecValue = nvar;
|
||||
}
|
||||
|
||||
Expression* Expression::ToAlternateThis(Declaration* pthis, Declaration* nthis)
|
||||
{
|
||||
Expression* left = mLeft ? mLeft->ToAlternateThis(pthis, nthis) : nullptr;
|
||||
|
|
@ -1044,20 +1021,6 @@ Expression* Expression::ConstantFold(Errors * errors, LinkerSection * dataSectio
|
|||
ex->mDecType = dec->mBase;
|
||||
return ex;
|
||||
}
|
||||
else if (mLeft->mDecValue->mType == DT_CONST_ADDRESS && mRight->mDecValue->mType == DT_CONST_ADDRESS && mToken == TK_SUB)
|
||||
{
|
||||
if (mLeft->mDecType->mType == DT_TYPE_POINTER && mRight->mDecType->mType == DT_TYPE_POINTER &&
|
||||
mLeft->mDecType->mBase->IsConstSame(mRight->mDecType->mBase))
|
||||
{
|
||||
Expression* ex = new Expression(mLocation, EX_CONSTANT);
|
||||
Declaration* dec = new Declaration(mLocation, DT_CONST_INTEGER);
|
||||
dec->mBase = TheSignedIntTypeDeclaration;
|
||||
dec->mInteger = (mLeft->mDecValue->mInteger - mRight->mDecValue->mInteger) / mLeft->mDecType->mBase->mSize;
|
||||
ex->mDecValue = dec;
|
||||
ex->mDecType = dec->mBase;
|
||||
return ex;
|
||||
}
|
||||
}
|
||||
#if 0
|
||||
else if (mLeft->mDecValue->mType == DT_CONST_POINTER && mRight->mDecValue->mType == DT_CONST_INTEGER && (mToken == TK_ADD || mToken == TK_SUB))
|
||||
{
|
||||
|
|
@ -1193,7 +1156,7 @@ Expression* Expression::ConstantFold(Errors * errors, LinkerSection * dataSectio
|
|||
return ex;
|
||||
}
|
||||
else if (mType == EX_BINARY && mToken == TK_ADD && mLeft->mType == EX_VARIABLE && mLeft->mDecValue->mType == DT_VARIABLE && (mLeft->mDecValue->mFlags & DTF_CONST) &&
|
||||
mLeft->mDecValue && mRight->mDecValue && mLeft->mDecValue->mValue && mLeft->mDecValue->mValue->mType == EX_CONSTANT &&
|
||||
mLeft->mDecValue && mRight->mDecValue && mLeft->mDecValue->mValue->mType == EX_CONSTANT &&
|
||||
mLeft->mDecType->mType == DT_TYPE_POINTER && mRight->mType == EX_CONSTANT && mRight->mDecValue->mType == DT_CONST_INTEGER)
|
||||
{
|
||||
mLeft = mLeft->mDecValue->mValue;
|
||||
|
|
@ -1259,10 +1222,6 @@ Expression* Expression::ConstantFold(Errors * errors, LinkerSection * dataSectio
|
|||
ex->mDecType = mDecType;
|
||||
return ex;
|
||||
}
|
||||
else if (mType == EX_VARIABLE && mDecType->IsSimpleType() && (mDecValue->mFlags & DTF_CONST) && mDecValue->mValue && mDecValue->mValue->mType == EX_INITIALIZATION && mDecValue->mValue->mRight->mType == EX_CONSTANT)
|
||||
{
|
||||
return mDecValue->mValue->mRight;
|
||||
}
|
||||
else if (mType == EX_CALL && mLeft->mType == EX_CONSTANT && (mLeft->mDecValue->mFlags & DTF_INTRINSIC) && mRight && mRight->mType == EX_CONSTANT)
|
||||
{
|
||||
Declaration* decf = mLeft->mDecValue, * decp = mRight->mDecValue;
|
||||
|
|
@ -1271,7 +1230,6 @@ Expression* Expression::ConstantFold(Errors * errors, LinkerSection * dataSectio
|
|||
if (decp->mType == DT_CONST_FLOAT || decp->mType == DT_CONST_INTEGER)
|
||||
{
|
||||
double d = decp->mType == DT_CONST_FLOAT ? decp->mNumber : decp->mInteger;
|
||||
double e = 0.0;
|
||||
|
||||
bool check = false;
|
||||
|
||||
|
|
@ -1291,10 +1249,6 @@ Expression* Expression::ConstantFold(Errors * errors, LinkerSection * dataSectio
|
|||
d = log(d);
|
||||
else if (!strcmp(iname->mString, "exp"))
|
||||
d = exp(d);
|
||||
else if (!strcmp(iname->mString, "sqrt"))
|
||||
d = sqrt(d);
|
||||
else if (!strcmp(iname->mString, "atan"))
|
||||
d = atan(d);
|
||||
else
|
||||
return this;
|
||||
|
||||
|
|
@ -1307,36 +1261,6 @@ Expression* Expression::ConstantFold(Errors * errors, LinkerSection * dataSectio
|
|||
return ex;
|
||||
}
|
||||
}
|
||||
else if (mType == EX_CALL && mLeft->mType == EX_CONSTANT && (mLeft->mDecValue->mFlags & DTF_INTRINSIC) && mRight &&
|
||||
mRight->mType == EX_LIST && mRight->mLeft->mType == EX_CONSTANT && mRight->mRight->mType == EX_CONSTANT)
|
||||
{
|
||||
Declaration* decf = mLeft->mDecValue, * decp1 = mRight->mLeft->mDecValue, * decp2 = mRight->mRight->mDecValue;
|
||||
const Ident* iname = decf->mQualIdent;
|
||||
|
||||
if ((decp1->mType == DT_CONST_FLOAT || decp1->mType == DT_CONST_INTEGER) &&
|
||||
(decp2->mType == DT_CONST_FLOAT || decp2->mType == DT_CONST_INTEGER))
|
||||
{
|
||||
double d1 = decp1->mType == DT_CONST_FLOAT ? decp1->mNumber : decp1->mInteger;
|
||||
double d2 = decp2->mType == DT_CONST_FLOAT ? decp2->mNumber : decp2->mInteger;
|
||||
|
||||
bool check = false;
|
||||
|
||||
if (!strcmp(iname->mString, "pow"))
|
||||
d1 = pow(d1, d2);
|
||||
else if (!strcmp(iname->mString, "atan2"))
|
||||
d1 = atan2(d1, d2);
|
||||
else
|
||||
return this;
|
||||
|
||||
Expression* ex = new Expression(mLocation, EX_CONSTANT);
|
||||
Declaration* dec = new Declaration(mLocation, DT_CONST_FLOAT);
|
||||
dec->mBase = TheFloatTypeDeclaration;
|
||||
dec->mNumber = d1;
|
||||
ex->mDecValue = dec;
|
||||
ex->mDecType = dec->mBase;
|
||||
return ex;
|
||||
}
|
||||
}
|
||||
else if (mType == EX_CALL && mLeft->mType == EX_CONSTANT && (mLeft->mDecValue->mFlags & DTF_CONSTEXPR) && dataSection)
|
||||
{
|
||||
ConstexprInterpreter cinter(mLocation, errors, dataSection);
|
||||
|
|
@ -1361,7 +1285,6 @@ Declaration::Declaration(const Location& loc, DecType type)
|
|||
mConst(nullptr), mMutable(nullptr), mVolatile(nullptr),
|
||||
mDefaultConstructor(nullptr), mDestructor(nullptr), mCopyConstructor(nullptr), mCopyAssignment(nullptr), mMoveConstructor(nullptr), mMoveAssignment(nullptr),
|
||||
mVectorConstructor(nullptr), mVectorDestructor(nullptr), mVectorCopyConstructor(nullptr), mVectorCopyAssignment(nullptr),
|
||||
mVectorMoveConstructor(nullptr), mVectorMoveAssignment(nullptr),
|
||||
mVTable(nullptr), mTemplate(nullptr), mForwardParam(nullptr), mForwardCall(nullptr),
|
||||
mVarIndex(-1), mLinkerObject(nullptr), mCallers(nullptr), mCalled(nullptr), mAlignment(1), mFriends(nullptr),
|
||||
mInteger(0), mNumber(0), mMinValue(-0x80000000LL), mMaxValue(0x7fffffffLL), mFastCallBase(0), mFastCallSize(0), mStride(0), mStripe(1),
|
||||
|
|
@ -1486,51 +1409,6 @@ Declaration* Declaration::ConstCast(Declaration* ntype)
|
|||
pdec->mSize = 2;
|
||||
return pdec;
|
||||
}
|
||||
else if (mType == DT_VARIABLE && mBase->mType == DT_TYPE_ARRAY)
|
||||
{
|
||||
Expression* ex = new Expression(mLocation, EX_VARIABLE);
|
||||
ex->mDecType = mBase;
|
||||
ex->mDecValue = this;
|
||||
|
||||
Declaration* pdec = this->Clone();
|
||||
pdec->mType = DT_CONST_POINTER;
|
||||
pdec->mValue = ex;
|
||||
pdec->mBase = ntype;
|
||||
pdec->mSize = 2;
|
||||
|
||||
return pdec;
|
||||
}
|
||||
else if (mType == DT_VARIABLE_REF)
|
||||
{
|
||||
Declaration* vtype = mBase->mBase;
|
||||
while (vtype && vtype->mType == DT_TYPE_STRUCT)
|
||||
{
|
||||
Declaration* dec = vtype->mParams;
|
||||
while (dec && dec->mOffset != mOffset)
|
||||
dec = dec->mNext;
|
||||
if (dec)
|
||||
vtype = dec->mBase;
|
||||
else
|
||||
vtype = nullptr;
|
||||
}
|
||||
|
||||
if (vtype && vtype->mType == DT_TYPE_ARRAY)
|
||||
{
|
||||
Expression* ex = new Expression(mLocation, EX_VARIABLE);
|
||||
ex->mDecType = mBase->mBase;
|
||||
ex->mDecValue = this;
|
||||
|
||||
Declaration* pdec = this->Clone();
|
||||
pdec->mType = DT_CONST_POINTER;
|
||||
pdec->mValue = ex;
|
||||
pdec->mBase = ntype;
|
||||
pdec->mSize = 2;
|
||||
|
||||
return pdec;
|
||||
}
|
||||
else
|
||||
return this;
|
||||
}
|
||||
else
|
||||
return this;
|
||||
}
|
||||
|
|
@ -1676,9 +1554,7 @@ const Ident* Declaration::FullIdent(void)
|
|||
Declaration* dec = mBase->mParams;
|
||||
while (dec)
|
||||
{
|
||||
const Ident* mident = dec->mBase->MangleIdent();
|
||||
if (mident)
|
||||
tident = tident->Mangle(mident->mString);
|
||||
tident = tident->Mangle(dec->mBase->MangleIdent()->mString);
|
||||
dec = dec->mNext;
|
||||
if (dec)
|
||||
tident = tident->Mangle(",");
|
||||
|
|
@ -1814,31 +1690,26 @@ const Ident* Declaration::MangleIdent(void)
|
|||
}
|
||||
|
||||
dec = dec->mNext;
|
||||
if (mMangleIdent && dec)
|
||||
if (dec)
|
||||
mMangleIdent = mMangleIdent->Mangle(",");
|
||||
}
|
||||
}
|
||||
else
|
||||
mMangleIdent = Ident::Unique("void");
|
||||
}
|
||||
else if (mQualIdent)
|
||||
mMangleIdent = mQualIdent;
|
||||
else
|
||||
mMangleIdent = mIdent;
|
||||
mMangleIdent = mQualIdent;
|
||||
|
||||
if (mTemplate)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
if (mMangleIdent)
|
||||
{
|
||||
if (mFlags & DTF_CONST)
|
||||
mMangleIdent = mMangleIdent->PreMangle("const ");
|
||||
if (mFlags & DTF_VOLATILE)
|
||||
mMangleIdent = mMangleIdent->PreMangle("volatile ");
|
||||
}
|
||||
}
|
||||
|
||||
return mMangleIdent;
|
||||
}
|
||||
|
|
@ -1898,8 +1769,19 @@ Declaration* Declaration::ExpandTemplate(DeclarationScope* scope)
|
|||
return this;
|
||||
}
|
||||
|
||||
bool Declaration::ResolveTemplateParameterList(Expression* pexp, Declaration* pdec, bool preliminary)
|
||||
bool Declaration::ResolveTemplate(Expression* pexp, Declaration* tdec)
|
||||
{
|
||||
Declaration* pdec = tdec->mBase->mParams;
|
||||
|
||||
// Insert partially resolved templates
|
||||
Declaration* ptdec = tdec->mTemplate->mParams;
|
||||
while (ptdec)
|
||||
{
|
||||
if (ptdec->mBase)
|
||||
mScope->Insert(ptdec->mIdent, ptdec->mBase);
|
||||
ptdec = ptdec->mNext;
|
||||
}
|
||||
|
||||
Declaration* phead = nullptr, * ptail = nullptr;
|
||||
int pcnt = 0;
|
||||
|
||||
|
|
@ -1935,7 +1817,7 @@ bool Declaration::ResolveTemplateParameterList(Expression* pexp, Declaration* pd
|
|||
}
|
||||
else
|
||||
{
|
||||
if (!ResolveTemplate(ex->mDecType, pdec->mBase, false, preliminary))
|
||||
if (!ResolveTemplate(ex->mDecType, pdec->mBase))
|
||||
return false;
|
||||
|
||||
pdec = pdec->mNext;
|
||||
|
|
@ -1949,9 +1831,6 @@ bool Declaration::ResolveTemplateParameterList(Expression* pexp, Declaration* pd
|
|||
{
|
||||
if (pdec->mType == DT_PACK_ARGUMENT)
|
||||
{
|
||||
if (preliminary)
|
||||
return true;
|
||||
|
||||
Declaration* tpdec = new Declaration(pdec->mLocation, DT_PACK_TYPE);
|
||||
if (pdec->mBase->mType == DT_TYPE_REFERENCE)
|
||||
tpdec->mIdent = pdec->mBase->mBase->mIdent;
|
||||
|
|
@ -1965,25 +1844,6 @@ bool Declaration::ResolveTemplateParameterList(Expression* pexp, Declaration* pd
|
|||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Declaration::ResolveTemplate(Expression* pexp, Declaration* tdec)
|
||||
{
|
||||
Declaration* pdec = tdec->mBase->mParams;
|
||||
|
||||
// Insert partially resolved templates
|
||||
Declaration* ptdec = tdec->mTemplate->mParams;
|
||||
while (ptdec)
|
||||
{
|
||||
if (ptdec->mBase)
|
||||
mScope->Insert(ptdec->mIdent, ptdec->mBase);
|
||||
ptdec = ptdec->mNext;
|
||||
}
|
||||
|
||||
if (!ResolveTemplateParameterList(pexp, pdec, true) || !ResolveTemplateParameterList(pexp, pdec, false))
|
||||
return false;
|
||||
|
||||
Declaration* ppdec = nullptr;
|
||||
ptdec = tdec->mTemplate->mParams;
|
||||
while (ptdec)
|
||||
|
|
@ -2026,7 +1886,7 @@ bool Declaration::CanResolveTemplate(Expression* pexp, Declaration* tdec)
|
|||
|
||||
if (pdec)
|
||||
{
|
||||
if (!ResolveTemplate(ex->mDecType, pdec->mBase, false, false))
|
||||
if (!ResolveTemplate(ex->mDecType, pdec->mBase))
|
||||
return false;
|
||||
|
||||
if (pdec->mType != DT_PACK_ARGUMENT)
|
||||
|
|
@ -2042,19 +1902,19 @@ bool Declaration::CanResolveTemplate(Expression* pexp, Declaration* tdec)
|
|||
return true;
|
||||
}
|
||||
|
||||
bool Declaration::ResolveTemplate(Declaration* fdec, Declaration* tdec, bool same, bool preliminary)
|
||||
bool Declaration::ResolveTemplate(Declaration* fdec, Declaration* tdec)
|
||||
{
|
||||
if (tdec->IsSame(fdec))
|
||||
return true;
|
||||
else if (fdec->IsReference())
|
||||
return ResolveTemplate(fdec->mBase, tdec, same, preliminary);
|
||||
return ResolveTemplate(fdec->mBase, tdec);
|
||||
else if (tdec->mType == DT_TYPE_FUNCTION)
|
||||
{
|
||||
if (fdec->mType == DT_TYPE_FUNCTION)
|
||||
{
|
||||
if (fdec->mBase)
|
||||
{
|
||||
if (!tdec->mBase || !ResolveTemplate(fdec->mBase, tdec->mBase, true, preliminary))
|
||||
if (!tdec->mBase || !ResolveTemplate(fdec->mBase, tdec->mBase))
|
||||
return false;
|
||||
}
|
||||
else if (tdec->mBase)
|
||||
|
|
@ -2093,7 +1953,7 @@ bool Declaration::ResolveTemplate(Declaration* fdec, Declaration* tdec, bool sam
|
|||
if (!fpdec)
|
||||
return false;
|
||||
|
||||
if (!ResolveTemplate(fpdec->mBase, tpdec->mBase, true, preliminary))
|
||||
if (!ResolveTemplate(fpdec->mBase, tpdec->mBase))
|
||||
return false;
|
||||
|
||||
fpdec = fpdec->mNext;
|
||||
|
|
@ -2109,16 +1969,16 @@ bool Declaration::ResolveTemplate(Declaration* fdec, Declaration* tdec, bool sam
|
|||
}
|
||||
else if (tdec->mType == DT_TYPE_REFERENCE)
|
||||
{
|
||||
return ResolveTemplate(fdec, tdec->mBase, true, preliminary);
|
||||
return ResolveTemplate(fdec, tdec->mBase);
|
||||
}
|
||||
else if (tdec->mType == DT_TYPE_RVALUEREF)
|
||||
{
|
||||
return ResolveTemplate(fdec, tdec->mBase, true, preliminary);
|
||||
return ResolveTemplate(fdec, tdec->mBase);
|
||||
}
|
||||
else if (tdec->mType == DT_TYPE_POINTER)
|
||||
{
|
||||
if (fdec->mType == DT_TYPE_POINTER || fdec->mType == DT_TYPE_ARRAY)
|
||||
return ResolveTemplate(fdec->mBase, tdec->mBase, true, preliminary);
|
||||
return ResolveTemplate(fdec->mBase, tdec->mBase);
|
||||
else
|
||||
return false;
|
||||
}
|
||||
|
|
@ -2138,12 +1998,10 @@ bool Declaration::ResolveTemplate(Declaration* fdec, Declaration* tdec, bool sam
|
|||
if (pdec->mType == DT_TYPE_STRUCT)
|
||||
pdec = pdec->mScope->Lookup(tdec->mIdent);
|
||||
}
|
||||
else if (preliminary && !same)
|
||||
return true;
|
||||
else
|
||||
pdec = mScope->Insert(tdec->mIdent, fdec);
|
||||
|
||||
if (pdec && !(same ? pdec->IsSame(fdec) : pdec->CanAssign(fdec)))
|
||||
if (pdec && !pdec->IsSame(fdec))
|
||||
return false;
|
||||
|
||||
return true;
|
||||
|
|
@ -2184,21 +2042,6 @@ bool Declaration::ResolveTemplate(Declaration* fdec, Declaration* tdec, bool sam
|
|||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
else if (tdec->mType == DT_TYPE_ARRAY && fdec->mType == DT_TYPE_ARRAY && tdec->mTemplate && tdec->mBase->IsConstSame(fdec->mBase))
|
||||
{
|
||||
Declaration* ifdec = new Declaration(fdec->mLocation, DT_CONST_INTEGER);
|
||||
ifdec->mBase = TheSignedIntTypeDeclaration;
|
||||
ifdec->mSize = 2;
|
||||
ifdec->mInteger = fdec->mSize / fdec->mBase->mSize;
|
||||
|
||||
Declaration * ipdec = mScope->Insert(tdec->mTemplate->mIdent, ifdec);
|
||||
if (ipdec && !ipdec->IsSame(ifdec))
|
||||
return false;
|
||||
|
||||
return true;
|
||||
|
||||
|
||||
}
|
||||
else if (tdec->mType == DT_TYPE_STRUCT && fdec->mType == DT_TYPE_STRUCT && tdec->mTemplate)
|
||||
{
|
||||
|
|
@ -2264,27 +2107,13 @@ bool Declaration::ResolveTemplate(Declaration* fdec, Declaration* tdec, bool sam
|
|||
tpdec = tpdec->mNext;
|
||||
}
|
||||
|
||||
if (fpdec)
|
||||
return false;
|
||||
else if (!tpdec)
|
||||
return true;
|
||||
else if (tpdec->mBase->mType == DT_PACK_TEMPLATE)
|
||||
{
|
||||
Declaration*tppack = new Declaration(tpdec->mLocation, DT_PACK_TYPE);
|
||||
Declaration* pdec = mScope->Insert(tpdec->mBase->mIdent, tppack);
|
||||
|
||||
return true;
|
||||
}
|
||||
else
|
||||
return false;
|
||||
return !fpdec && !tpdec;
|
||||
}
|
||||
|
||||
ftdec = ftdec->mNext;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
else if (!same && tdec->CanAssign(fdec))
|
||||
return true;
|
||||
else
|
||||
return tdec->IsSame(fdec);
|
||||
}
|
||||
|
|
@ -2416,7 +2245,6 @@ Declaration* Declaration::ToStriped(int stripe)
|
|||
ndec->mVectorConstructor = mVectorConstructor ? mVectorConstructor->ToAlternateThis(pndec, 2) : nullptr;
|
||||
ndec->mVectorDestructor = mVectorDestructor ? mVectorDestructor->ToAlternateThis(pndec, 2) : nullptr;
|
||||
ndec->mVectorCopyConstructor = mVectorCopyConstructor ? mVectorCopyConstructor->ToAlternateThis(pndec, 2) : nullptr;
|
||||
ndec->mVectorMoveConstructor = mVectorMoveConstructor ? mVectorMoveConstructor->ToAlternateThis(pndec, 2) : nullptr;
|
||||
}
|
||||
else if (mType == DT_TYPE_FUNCTION)
|
||||
{
|
||||
|
|
@ -2484,7 +2312,6 @@ Declaration* Declaration::ToVolatileType(void)
|
|||
ndec->mVectorConstructor = mVectorConstructor;
|
||||
ndec->mVectorDestructor = mVectorDestructor;
|
||||
ndec->mVectorCopyConstructor = mVectorCopyConstructor;
|
||||
ndec->mVectorMoveConstructor = mVectorMoveConstructor;
|
||||
ndec->mVTable = mVTable;
|
||||
|
||||
mVolatile = ndec;
|
||||
|
|
@ -2504,9 +2331,6 @@ Declaration* Declaration::ToConstType(void)
|
|||
ndec->mSize = mSize;
|
||||
ndec->mStride = mStride;
|
||||
ndec->mStripe = mStripe;
|
||||
if (mType == DT_TYPE_ARRAY)
|
||||
ndec->mBase = mBase->ToConstType();
|
||||
else
|
||||
ndec->mBase = mBase;
|
||||
ndec->mBits = mBits;
|
||||
ndec->mShift = mShift;
|
||||
|
|
@ -2524,7 +2348,6 @@ Declaration* Declaration::ToConstType(void)
|
|||
ndec->mVectorConstructor = mVectorConstructor;
|
||||
ndec->mVectorDestructor = mVectorDestructor;
|
||||
ndec->mVectorCopyConstructor = mVectorCopyConstructor;
|
||||
ndec->mVectorMoveConstructor = mVectorMoveConstructor;
|
||||
ndec->mVTable = mVTable;
|
||||
|
||||
ndec->mMutable = this;
|
||||
|
|
@ -2577,7 +2400,7 @@ Declaration* Declaration::ToMutableType(void)
|
|||
ndec->mBase = mBase;
|
||||
ndec->mBits = mBits;
|
||||
ndec->mShift = mShift;
|
||||
ndec->mFlags = mFlags & ~DTF_CONST;
|
||||
ndec->mFlags = mFlags | DTF_CONST;
|
||||
ndec->mScope = mScope;
|
||||
ndec->mParams = mParams;
|
||||
ndec->mIdent = mIdent;
|
||||
|
|
@ -2591,7 +2414,6 @@ Declaration* Declaration::ToMutableType(void)
|
|||
ndec->mVectorConstructor = mVectorConstructor;
|
||||
ndec->mVectorDestructor = mVectorDestructor;
|
||||
ndec->mVectorCopyConstructor = mVectorCopyConstructor;
|
||||
ndec->mVectorMoveConstructor = mVectorMoveConstructor;
|
||||
ndec->mVTable = mVTable;
|
||||
|
||||
ndec->mConst = this;
|
||||
|
|
@ -2921,9 +2743,6 @@ bool Declaration::IsSame(const Declaration* dec) const
|
|||
if (mType != dec->mType)
|
||||
return false;
|
||||
|
||||
if ((mFlags & (DTF_SIGNED | DTF_CONST | DTF_VOLATILE)) != (dec->mFlags & (DTF_SIGNED | DTF_CONST | DTF_VOLATILE)))
|
||||
return false;
|
||||
|
||||
if (!(mFlags & dec->mFlags & DTF_DEFINED) && mType == DT_TYPE_STRUCT)
|
||||
return mIdent == dec->mIdent;
|
||||
|
||||
|
|
@ -2932,6 +2751,9 @@ bool Declaration::IsSame(const Declaration* dec) const
|
|||
if (mStripe != dec->mStripe)
|
||||
return false;
|
||||
|
||||
if ((mFlags & (DTF_SIGNED | DTF_CONST | DTF_VOLATILE)) != (dec->mFlags & (DTF_SIGNED | DTF_CONST | DTF_VOLATILE)))
|
||||
return false;
|
||||
|
||||
if (mType == DT_CONST_INTEGER)
|
||||
return mInteger == dec->mInteger;
|
||||
else if (mType == DT_TYPE_INTEGER)
|
||||
|
|
@ -2978,7 +2800,7 @@ bool Declaration::IsSame(const Declaration* dec) const
|
|||
|
||||
return true;
|
||||
}
|
||||
else if (mType == DT_TYPE_TEMPLATE || mType == DT_PACK_TEMPLATE)
|
||||
else if (mType == DT_TYPE_TEMPLATE)
|
||||
{
|
||||
return mIdent == dec->mIdent;
|
||||
}
|
||||
|
|
@ -3111,7 +2933,7 @@ bool Declaration::CanAssign(const Declaration* fromType) const
|
|||
if (mScope == fromType->mScope || (mIdent == fromType->mIdent && mSize == fromType->mSize))
|
||||
return true;
|
||||
if (fromType->mBase)
|
||||
return this->CanAssign(fromType->mBase->mBase);
|
||||
return this->CanAssign(fromType->mBase);
|
||||
return false;
|
||||
}
|
||||
else if (mType == DT_TYPE_ARRAY && fromType->mType == DT_TYPE_ARRAY)
|
||||
|
|
@ -3178,52 +3000,6 @@ bool Declaration::IsIndexed(void) const
|
|||
return mType == DT_TYPE_ARRAY || mType == DT_TYPE_POINTER;
|
||||
}
|
||||
|
||||
bool Declaration::ContainsArray(void) const
|
||||
{
|
||||
if (mType == DT_TYPE_ARRAY)
|
||||
return true;
|
||||
else if (mType == DT_TYPE_STRUCT)
|
||||
{
|
||||
Declaration* p = mParams;
|
||||
while (p)
|
||||
{
|
||||
if (p->mType == DT_ELEMENT && p->mBase->ContainsArray())
|
||||
return true;
|
||||
p = p->mNext;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool Declaration::IsShortIntStruct(void) const
|
||||
{
|
||||
if (mType == DT_TYPE_STRUCT && mSize <= 4 && !mDestructor && !mCopyConstructor)
|
||||
{
|
||||
Declaration* em = mParams;
|
||||
while (em)
|
||||
{
|
||||
if (em->mType == DT_ELEMENT && em->mBase->IsIntegerType() && em->mBits == 0)
|
||||
em = em->mNext;
|
||||
else
|
||||
return false;
|
||||
}
|
||||
|
||||
// if (strcmp(mIdent->mString, "connection")) return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool Declaration::HasConstructor(void) const
|
||||
{
|
||||
return mType == DT_TYPE_STRUCT && mScope && mScope->Lookup(mIdent->PreMangle("+"));
|
||||
}
|
||||
|
||||
bool Declaration::IsComplexStruct(void) const
|
||||
{
|
||||
return mType == DT_TYPE_STRUCT && !IsShortIntStruct();
|
||||
}
|
||||
|
||||
bool Declaration::IsSimpleType(void) const
|
||||
{
|
||||
|
|
@ -3243,7 +3019,6 @@ Declaration* TheVoidFunctionTypeDeclaration, * TheConstVoidValueDeclaration;
|
|||
Declaration* TheCharPointerTypeDeclaration, * TheConstCharPointerTypeDeclaration;
|
||||
Expression* TheVoidExpression;
|
||||
Declaration* TheNullptrConstDeclaration, * TheZeroIntegerConstDeclaration, * TheZeroFloatConstDeclaration, * TheNullPointerTypeDeclaration;
|
||||
Declaration* TheTrueConstDeclaration, * TheFalseConstDeclaration;
|
||||
|
||||
void InitDeclarations(void)
|
||||
{
|
||||
|
|
@ -3345,13 +3120,4 @@ void InitDeclarations(void)
|
|||
TheZeroFloatConstDeclaration->mBase = TheFloatTypeDeclaration;
|
||||
TheZeroFloatConstDeclaration->mSize = 4;
|
||||
|
||||
TheTrueConstDeclaration = new Declaration(noloc, DT_CONST_INTEGER);
|
||||
TheTrueConstDeclaration->mBase = TheBoolTypeDeclaration;
|
||||
TheTrueConstDeclaration->mSize = 1;
|
||||
TheTrueConstDeclaration->mInteger = 1;
|
||||
|
||||
TheFalseConstDeclaration = new Declaration(noloc, DT_CONST_INTEGER);
|
||||
TheFalseConstDeclaration->mBase = TheBoolTypeDeclaration;
|
||||
TheFalseConstDeclaration->mSize = 1;
|
||||
TheFalseConstDeclaration->mInteger = 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -127,7 +127,6 @@ static const uint64 DTF_FPARAM_UNUSED = (1ULL << 49);
|
|||
static const uint64 DTF_DEPRECATED = (1ULL << 50);
|
||||
static const uint64 DTF_FUNC_NO_RETURN = (1ULL << 51);
|
||||
static const uint64 DTF_PLACED = (1ULL << 52);
|
||||
static const uint64 DTF_NO_PAGE_CROSS = (1ULL << 53);
|
||||
|
||||
|
||||
|
||||
|
|
@ -167,8 +166,6 @@ public:
|
|||
ScopeLevel mLevel;
|
||||
const Ident * mName;
|
||||
|
||||
DeclarationScope* Clone(void) const;
|
||||
|
||||
DeclarationScope* mParent;
|
||||
protected:
|
||||
struct Entry
|
||||
|
|
@ -218,7 +215,6 @@ enum ExpressionType
|
|||
EX_IF,
|
||||
EX_ELSE,
|
||||
EX_FOR,
|
||||
EX_FORBODY,
|
||||
EX_DO,
|
||||
EX_SCOPE,
|
||||
EX_BREAK,
|
||||
|
|
@ -246,12 +242,6 @@ enum ExpressionType
|
|||
EX_AGGREGATE
|
||||
};
|
||||
|
||||
static const uint32 ANAFL_LHS = (1U << 0);
|
||||
static const uint32 ANAFL_RHS = (1U << 1);
|
||||
static const uint32 ANAFL_ASSIGN = (1U << 2);
|
||||
static const uint32 ANAFL_ALIAS = (1U << 3);
|
||||
|
||||
|
||||
class Expression
|
||||
{
|
||||
public:
|
||||
|
|
@ -268,7 +258,6 @@ public:
|
|||
AsmInsType mAsmInsType;
|
||||
AsmInsMode mAsmInsMode;
|
||||
bool mConst;
|
||||
uint32 mFlags;
|
||||
|
||||
Expression* LogicInvertExpression(void);
|
||||
Expression* ConstantFold(Errors * errors, LinkerSection* dataSection, Linker * linker = nullptr);
|
||||
|
|
@ -277,8 +266,6 @@ public:
|
|||
Expression* ListAppend(Expression* lexp);
|
||||
Expression* ToAlternateThis(Declaration* pthis, Declaration* nthis);
|
||||
|
||||
void ReplaceVariable(Declaration* pvar, Declaration* nvar);
|
||||
|
||||
bool IsSame(const Expression* exp) const;
|
||||
bool IsRValue(void) const;
|
||||
bool IsLValue(void) const;
|
||||
|
|
@ -302,7 +289,7 @@ public:
|
|||
Token mToken;
|
||||
Declaration * mBase, * mParams, * mParamPack, * mNext, * mPrev, * mConst, * mMutable, * mVolatile;
|
||||
Declaration * mDefaultConstructor, * mDestructor, * mCopyConstructor, * mCopyAssignment, * mMoveConstructor, * mMoveAssignment;
|
||||
Declaration * mVectorConstructor, * mVectorDestructor, * mVectorCopyConstructor, * mVectorCopyAssignment, * mVectorMoveConstructor, * mVectorMoveAssignment;
|
||||
Declaration * mVectorConstructor, * mVectorDestructor, * mVectorCopyConstructor, * mVectorCopyAssignment;
|
||||
Declaration * mVTable, * mClass, * mTemplate;
|
||||
Declaration * mForwardParam, * mForwardCall;
|
||||
|
||||
|
|
@ -344,10 +331,6 @@ public:
|
|||
bool IsSimpleType(void) const;
|
||||
bool IsReference(void) const;
|
||||
bool IsIndexed(void) const;
|
||||
bool ContainsArray(void) const;
|
||||
bool IsShortIntStruct(void) const;
|
||||
bool IsComplexStruct(void) const;
|
||||
bool HasConstructor(void) const;
|
||||
|
||||
void SetDefined(void);
|
||||
|
||||
|
|
@ -378,9 +361,8 @@ public:
|
|||
DecType ValueType(void) const;
|
||||
|
||||
bool CanResolveTemplate(Expression* pexp, Declaration* tdec);
|
||||
bool ResolveTemplate(Declaration* fdec, Declaration * tdec, bool same, bool preliminary);
|
||||
bool ResolveTemplate(Declaration* fdec, Declaration * tdec);
|
||||
bool ResolveTemplate(Expression* pexp, Declaration* tdec);
|
||||
bool ResolveTemplateParameterList(Expression* pexp, Declaration* pdec, bool preliminary);
|
||||
|
||||
Declaration* ExpandTemplate(DeclarationScope* scope);
|
||||
|
||||
|
|
@ -398,6 +380,5 @@ extern Declaration* TheBoolTypeDeclaration, * TheFloatTypeDeclaration, * TheVoid
|
|||
extern Declaration* TheVoidFunctionTypeDeclaration, * TheConstVoidValueDeclaration;
|
||||
extern Declaration* TheCharPointerTypeDeclaration, * TheConstCharPointerTypeDeclaration;
|
||||
extern Declaration* TheNullptrConstDeclaration, * TheZeroIntegerConstDeclaration, * TheZeroFloatConstDeclaration, * TheNullPointerTypeDeclaration;
|
||||
extern Declaration* TheTrueConstDeclaration, * TheFalseConstDeclaration;
|
||||
extern Expression* TheVoidExpression;
|
||||
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
#include <stdlib.h>
|
||||
|
||||
Errors::Errors(void)
|
||||
: mErrorCount(0), mMinLevel(EINFO_GENERIC), mDisabled(EERR_GENERIC)
|
||||
: mErrorCount(0), mMinLevel(EINFO_GENERIC)
|
||||
{
|
||||
|
||||
}
|
||||
|
|
@ -29,7 +29,7 @@ void Errors::Error(const Location& loc, ErrorID eid, const char* msg, const Iden
|
|||
|
||||
void Errors::Error(const Location& loc, ErrorID eid, const char* msg, const char* info1, const char * info2)
|
||||
{
|
||||
if (eid >= mMinLevel && !(eid < EERR_GENERIC && mDisabled[eid]))
|
||||
if (eid >= mMinLevel)
|
||||
{
|
||||
const char* level = "info";
|
||||
if (eid >= EERR_GENERIC)
|
||||
|
|
|
|||
|
|
@ -1,8 +1,5 @@
|
|||
#pragma once
|
||||
|
||||
#include "NumberSet.h"
|
||||
|
||||
|
||||
class Location
|
||||
{
|
||||
public:
|
||||
|
|
@ -13,11 +10,7 @@ public:
|
|||
Location() : mFileName(nullptr), mLine(0), mColumn(0), mFrom(nullptr) {}
|
||||
Location(const Location& loc, const Location* from)
|
||||
: mFileName(loc.mFileName), mLine(loc.mLine), mColumn(loc.mColumn), mFrom(from)
|
||||
{
|
||||
static volatile int k;
|
||||
if (from)
|
||||
k = from->mLine;
|
||||
}
|
||||
{}
|
||||
};
|
||||
|
||||
class Ident;
|
||||
|
|
@ -127,13 +120,9 @@ enum ErrorID
|
|||
EERR_INVALID_CLASS_INITIALIZER,
|
||||
EERR_CALL_OF_DELETED_FUNCTION,
|
||||
|
||||
EERR_STATIC_ASSERT,
|
||||
|
||||
EFATAL_GENERIC = 4000,
|
||||
EFATAL_OUT_OF_MEMORY,
|
||||
EFATAL_MACRO_EXPANSION_DEPTH,
|
||||
|
||||
ERROR_MAX = 5000
|
||||
};
|
||||
|
||||
class Errors
|
||||
|
|
@ -146,7 +135,6 @@ public:
|
|||
int mErrorCount;
|
||||
ErrorID mMinLevel;
|
||||
|
||||
NumberSet mDisabled;
|
||||
|
||||
void Error(const Location& loc, ErrorID eid, const char* msg, const Ident* info1, const Ident* info2 = nullptr);
|
||||
void Error(const Location& loc, ErrorID eid, const char* msg, const char* info1 = nullptr, const char* info2 = nullptr);
|
||||
|
|
|
|||
|
|
@ -393,7 +393,7 @@ void GlobalAnalyzer::CheckFastcall(Declaration* procDec, bool head)
|
|||
|
||||
if (procDec->mValue && procDec->mValue->mType == EX_DISPATCH)
|
||||
{
|
||||
Declaration* maxf = nullptr, * reff = nullptr;
|
||||
Declaration* maxf = nullptr;
|
||||
|
||||
bool stackCall = false;
|
||||
|
||||
|
|
@ -402,10 +402,7 @@ void GlobalAnalyzer::CheckFastcall(Declaration* procDec, bool head)
|
|||
Declaration* cf = procDec->mCalled[i];
|
||||
|
||||
if (cf->mBase->mFlags & DTF_STACKCALL)
|
||||
{
|
||||
stackCall = true;
|
||||
reff = cf;
|
||||
}
|
||||
|
||||
if (!maxf)
|
||||
maxf = cf;
|
||||
|
|
@ -413,9 +410,6 @@ void GlobalAnalyzer::CheckFastcall(Declaration* procDec, bool head)
|
|||
maxf = cf;
|
||||
}
|
||||
|
||||
if (!reff)
|
||||
reff = maxf;
|
||||
|
||||
for (int i = 0; i < procDec->mCalled.Size(); i++)
|
||||
{
|
||||
Declaration* cf = procDec->mCalled[i];
|
||||
|
|
@ -426,9 +420,9 @@ void GlobalAnalyzer::CheckFastcall(Declaration* procDec, bool head)
|
|||
cf->mBase->mFlags |= DTF_STACKCALL;
|
||||
}
|
||||
|
||||
if (cf != reff)
|
||||
if (cf != maxf)
|
||||
{
|
||||
Declaration* fp = cf->mBase->mParams, * mp = reff->mBase->mParams;
|
||||
Declaration* fp = cf->mBase->mParams, * mp = maxf->mBase->mParams;
|
||||
while (fp)
|
||||
{
|
||||
fp->mVarIndex = mp->mVarIndex;
|
||||
|
|
@ -437,11 +431,10 @@ void GlobalAnalyzer::CheckFastcall(Declaration* procDec, bool head)
|
|||
}
|
||||
|
||||
assert(!mp);
|
||||
|
||||
cf->mBase->mFastCallBase = cf->mFastCallBase = maxf->mBase->mFastCallBase;
|
||||
cf->mBase->mFastCallSize = cf->mFastCallSize = maxf->mBase->mFastCallSize;
|
||||
}
|
||||
|
||||
if (cf != maxf)
|
||||
cf->mBase->mFastCallBase = cf->mFastCallBase = maxf->mBase->mFastCallBase;
|
||||
}
|
||||
|
||||
procDec->mFastCallBase = procDec->mBase->mFastCallBase;
|
||||
|
|
@ -481,7 +474,7 @@ void GlobalAnalyzer::CheckFastcall(Declaration* procDec, bool head)
|
|||
fplimit += 256;
|
||||
}
|
||||
|
||||
if (procDec->mBase->mBase->IsComplexStruct())
|
||||
if (procDec->mBase->mBase->mType == DT_TYPE_STRUCT)
|
||||
{
|
||||
if (nbase < numfpzero && nbase + 2 > numfpzero)
|
||||
nbase = numfpzero;
|
||||
|
|
@ -665,7 +658,7 @@ void GlobalAnalyzer::AnalyzeProcedure(Expression* cexp, Expression* exp, Declara
|
|||
if (mCompilerOptions & COPT_OPTIMIZE_CONST_EXPRESSIONS)
|
||||
dec->mFlags |= DTF_FUNC_CONSTEXPR;
|
||||
dec->mFlags |= DTF_FUNC_PURE;
|
||||
Analyze(exp, dec, 0);
|
||||
Analyze(exp, dec, false, false);
|
||||
|
||||
Declaration* pdec = dec->mBase->mParams;
|
||||
int vi = 0;
|
||||
|
|
@ -685,7 +678,7 @@ void GlobalAnalyzer::AnalyzeProcedure(Expression* cexp, Expression* exp, Declara
|
|||
}
|
||||
else
|
||||
{
|
||||
mErrors->Error(dec->mLocation, EERR_UNDEFINED_OBJECT, "Calling undefined function", dec->FullIdent());
|
||||
mErrors->Error(dec->mLocation, EERR_UNDEFINED_OBJECT, "Calling undefined function", dec->mQualIdent);
|
||||
if (cexp)
|
||||
mErrors->Error(cexp->mLocation, EINFO_CALLED_FROM, "Called from here");
|
||||
|
||||
|
|
@ -761,7 +754,7 @@ void GlobalAnalyzer::AnalyzeGlobalVariable(Declaration* dec)
|
|||
|
||||
if (dec->mValue)
|
||||
{
|
||||
Analyze(dec->mValue, dec, 0);
|
||||
Analyze(dec->mValue, dec, false, false);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -771,19 +764,17 @@ void GlobalAnalyzer::AnalyzeInit(Declaration* mdec)
|
|||
while (mdec)
|
||||
{
|
||||
if (mdec->mValue)
|
||||
RegisterProc(Analyze(mdec->mValue, mdec, 0));
|
||||
RegisterProc(Analyze(mdec->mValue, mdec, false, false));
|
||||
else if (mdec->mParams)
|
||||
AnalyzeInit(mdec->mParams);
|
||||
mdec = mdec->mNext;
|
||||
}
|
||||
}
|
||||
|
||||
Declaration * GlobalAnalyzer::Analyze(Expression* exp, Declaration* procDec, uint32 flags)
|
||||
Declaration * GlobalAnalyzer::Analyze(Expression* exp, Declaration* procDec, bool lhs, bool aliasing)
|
||||
{
|
||||
Declaration* ldec, * rdec;
|
||||
|
||||
exp->mFlags = flags;
|
||||
|
||||
switch (exp->mType)
|
||||
{
|
||||
case EX_ERROR:
|
||||
|
|
@ -801,7 +792,7 @@ Declaration * GlobalAnalyzer::Analyze(Expression* exp, Declaration* procDec, uin
|
|||
}
|
||||
else if (exp->mDecValue->mType == DT_CONST_POINTER)
|
||||
{
|
||||
ldec = Analyze(exp->mDecValue->mValue, procDec, ANAFL_LHS | ANAFL_ALIAS);
|
||||
ldec = Analyze(exp->mDecValue->mValue, procDec, true, true);
|
||||
if (ldec->mType == DT_VARIABLE)
|
||||
ldec->mFlags |= DTF_VAR_ALIASING;
|
||||
RegisterProc(ldec);
|
||||
|
|
@ -825,7 +816,7 @@ Declaration * GlobalAnalyzer::Analyze(Expression* exp, Declaration* procDec, uin
|
|||
if (mCompilerOptions & COPT_DEBUGINFO)
|
||||
exp->mDecValue->mReferences.Push(exp);
|
||||
|
||||
if (flags & ANAFL_ALIAS)
|
||||
if (aliasing)
|
||||
{
|
||||
Declaration* dec = exp->mDecValue;
|
||||
while (dec->mType == DT_VARIABLE_REF)
|
||||
|
|
@ -842,14 +833,14 @@ Declaration * GlobalAnalyzer::Analyze(Expression* exp, Declaration* procDec, uin
|
|||
if (!(type->mFlags & DTF_CONST))
|
||||
procDec->mFlags &= ~DTF_FUNC_CONSTEXPR;
|
||||
|
||||
if (flags & ANAFL_LHS)
|
||||
if (lhs)
|
||||
procDec->mFlags &= ~DTF_FUNC_PURE;
|
||||
|
||||
AnalyzeGlobalVariable(exp->mDecValue);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (flags & ANAFL_LHS)
|
||||
if (lhs)
|
||||
exp->mDecValue->mFlags |= DTF_VAR_ADDRESS;
|
||||
|
||||
if (!(exp->mDecValue->mFlags & DTF_ANALYZED))
|
||||
|
|
@ -863,8 +854,8 @@ Declaration * GlobalAnalyzer::Analyze(Expression* exp, Declaration* procDec, uin
|
|||
case EX_ASSIGNMENT:
|
||||
procDec->mComplexity += 5 * exp->mLeft->mDecType->mSize;
|
||||
|
||||
ldec = Analyze(exp->mLeft, procDec, ANAFL_LHS | ANAFL_RHS);
|
||||
rdec = Analyze(exp->mRight, procDec, ANAFL_RHS);
|
||||
ldec = Analyze(exp->mLeft, procDec, true, false);
|
||||
rdec = Analyze(exp->mRight, procDec, false, false);
|
||||
if (exp->mLeft->mType == EX_VARIABLE && exp->mRight->mType == EX_CALL && exp->mLeft->mDecType->mType == DT_TYPE_STRUCT)
|
||||
exp->mLeft->mDecValue->mFlags |= DTF_VAR_ALIASING;
|
||||
RegisterProc(rdec);
|
||||
|
|
@ -873,33 +864,33 @@ Declaration * GlobalAnalyzer::Analyze(Expression* exp, Declaration* procDec, uin
|
|||
case EX_BINARY:
|
||||
procDec->mComplexity += 10 * exp->mDecType->mSize;
|
||||
|
||||
ldec = Analyze(exp->mLeft, procDec, flags & ~ANAFL_ALIAS);
|
||||
rdec = Analyze(exp->mRight, procDec, flags & ~ANAFL_ALIAS);
|
||||
ldec = Analyze(exp->mLeft, procDec, lhs, false);
|
||||
rdec = Analyze(exp->mRight, procDec, lhs, false);
|
||||
return ldec;
|
||||
|
||||
case EX_RELATIONAL:
|
||||
procDec->mComplexity += 10 * exp->mLeft->mDecType->mSize;
|
||||
|
||||
ldec = Analyze(exp->mLeft, procDec, ANAFL_RHS);
|
||||
rdec = Analyze(exp->mRight, procDec, ANAFL_RHS);
|
||||
ldec = Analyze(exp->mLeft, procDec, false, false);
|
||||
rdec = Analyze(exp->mRight, procDec, false, false);
|
||||
return TheBoolTypeDeclaration;
|
||||
|
||||
case EX_PREINCDEC:
|
||||
procDec->mComplexity += 10 * exp->mLeft->mDecType->mSize;
|
||||
|
||||
return Analyze(exp->mLeft, procDec, ANAFL_LHS | ANAFL_RHS);
|
||||
return Analyze(exp->mLeft, procDec, true, false);
|
||||
case EX_PREFIX:
|
||||
if (exp->mToken == TK_BINARY_AND)
|
||||
{
|
||||
ldec = Analyze(exp->mLeft, procDec, ANAFL_LHS | ANAFL_ALIAS);
|
||||
ldec = Analyze(exp->mLeft, procDec, true, true);
|
||||
if (ldec->mType == DT_VARIABLE)
|
||||
ldec->mFlags |= DTF_VAR_ALIASING;
|
||||
}
|
||||
else if (exp->mToken == TK_MUL)
|
||||
{
|
||||
ldec = Analyze(exp->mLeft, procDec, 0);
|
||||
ldec = Analyze(exp->mLeft, procDec, false, false);
|
||||
procDec->mFlags &= ~DTF_FUNC_CONSTEXPR;
|
||||
if (flags & ANAFL_LHS)
|
||||
if (lhs)
|
||||
procDec->mFlags &= ~DTF_FUNC_PURE;
|
||||
|
||||
return exp->mDecType;
|
||||
|
|
@ -915,7 +906,7 @@ Declaration * GlobalAnalyzer::Analyze(Expression* exp, Declaration* procDec, uin
|
|||
else
|
||||
{
|
||||
procDec->mComplexity += 10 * exp->mLeft->mDecType->mSize;
|
||||
return Analyze(exp->mLeft, procDec, 0);
|
||||
return Analyze(exp->mLeft, procDec, false, false);
|
||||
}
|
||||
break;
|
||||
case EX_POSTFIX:
|
||||
|
|
@ -924,31 +915,31 @@ Declaration * GlobalAnalyzer::Analyze(Expression* exp, Declaration* procDec, uin
|
|||
case EX_POSTINCDEC:
|
||||
procDec->mComplexity += 10 * exp->mLeft->mDecType->mSize;
|
||||
|
||||
return Analyze(exp->mLeft, procDec, ANAFL_LHS | ANAFL_RHS);
|
||||
return Analyze(exp->mLeft, procDec, true, false);
|
||||
case EX_INDEX:
|
||||
procDec->mComplexity += 10 * exp->mRight->mDecType->mSize;
|
||||
|
||||
ldec = Analyze(exp->mLeft, procDec, flags & ~ANAFL_ALIAS);
|
||||
ldec = Analyze(exp->mLeft, procDec, lhs, false);
|
||||
if (ldec->mType == DT_VARIABLE || ldec->mType == DT_ARGUMENT)
|
||||
{
|
||||
ldec = ldec->mBase;
|
||||
if (ldec->mType == DT_TYPE_POINTER)
|
||||
{
|
||||
if (flags & ANAFL_LHS)
|
||||
if (lhs)
|
||||
procDec->mFlags &= ~DTF_FUNC_PURE;
|
||||
procDec->mFlags &= ~DTF_FUNC_CONSTEXPR;
|
||||
}
|
||||
}
|
||||
rdec = Analyze(exp->mRight, procDec, 0);
|
||||
rdec = Analyze(exp->mRight, procDec, false, false);
|
||||
if (ldec->mBase)
|
||||
return ldec->mBase;
|
||||
break;
|
||||
case EX_QUALIFY:
|
||||
Analyze(exp->mLeft, procDec, flags);
|
||||
Analyze(exp->mLeft, procDec, lhs, aliasing);
|
||||
return exp->mDecValue->mBase;
|
||||
case EX_DISPATCH:
|
||||
procDec->mFlags |= DTF_PREVENT_INLINE;
|
||||
Analyze(exp->mLeft, procDec, flags & ~ANAFL_ALIAS);
|
||||
Analyze(exp->mLeft, procDec, lhs, false);
|
||||
// RegisterCall(procDec, exp->mLeft->mDecType);
|
||||
break;
|
||||
case EX_VCALL:
|
||||
|
|
@ -959,7 +950,7 @@ Declaration * GlobalAnalyzer::Analyze(Expression* exp, Declaration* procDec, uin
|
|||
case EX_INLINE:
|
||||
procDec->mComplexity += 10;
|
||||
|
||||
ldec = Analyze(exp->mLeft, procDec, 0);
|
||||
ldec = Analyze(exp->mLeft, procDec, false, false);
|
||||
if ((ldec->mFlags & DTF_INTRINSIC) && !ldec->mValue)
|
||||
{
|
||||
|
||||
|
|
@ -1046,7 +1037,7 @@ Declaration * GlobalAnalyzer::Analyze(Expression* exp, Declaration* procDec, uin
|
|||
if (pex->mType == EX_CALL && IsStackParam(pex->mDecType) && !(pdec && (pdec->mBase->mType == DT_TYPE_REFERENCE || pdec->mBase->mType == DT_TYPE_RVALUEREF)))
|
||||
ldec->mBase->mFlags |= DTF_STACKCALL;
|
||||
|
||||
RegisterProc(Analyze(pex, procDec, (pdec && pdec->mBase->IsReference()) ? ANAFL_LHS : 0));
|
||||
RegisterProc(Analyze(pex, procDec, pdec && pdec->mBase->IsReference(), false));
|
||||
|
||||
if (pdec)
|
||||
pdec = pdec->mNext;
|
||||
|
|
@ -1060,12 +1051,12 @@ Declaration * GlobalAnalyzer::Analyze(Expression* exp, Declaration* procDec, uin
|
|||
break;
|
||||
case EX_LIST:
|
||||
case EX_COMMA:
|
||||
RegisterProc(Analyze(exp->mLeft, procDec, 0));
|
||||
return Analyze(exp->mRight, procDec, 0);
|
||||
RegisterProc(Analyze(exp->mLeft, procDec, false, false));
|
||||
return Analyze(exp->mRight, procDec, false, false);
|
||||
case EX_RETURN:
|
||||
if (exp->mLeft)
|
||||
{
|
||||
RegisterProc(Analyze(exp->mLeft, procDec, procDec->mBase->mBase->IsReference() ? ANAFL_LHS : 0));
|
||||
RegisterProc(Analyze(exp->mLeft, procDec, procDec->mBase->mBase->IsReference(), false));
|
||||
if (procDec->mBase->mBase && procDec->mBase->mBase->mType == DT_TYPE_STRUCT && procDec->mBase->mBase->mCopyConstructor)
|
||||
{
|
||||
if (procDec->mBase->mBase->mMoveConstructor)
|
||||
|
|
@ -1086,47 +1077,47 @@ Declaration * GlobalAnalyzer::Analyze(Expression* exp, Declaration* procDec, uin
|
|||
if (exp->mType == EX_SEQUENCE)
|
||||
{
|
||||
if (exp->mLeft)
|
||||
ldec = Analyze(exp->mLeft, procDec, 0);
|
||||
ldec = Analyze(exp->mLeft, procDec, false, false);
|
||||
exp = exp->mRight;
|
||||
}
|
||||
else
|
||||
return Analyze(exp, procDec, 0);
|
||||
return Analyze(exp, procDec, false, false);
|
||||
|
||||
} while (exp);
|
||||
break;
|
||||
|
||||
case EX_SCOPE:
|
||||
Analyze(exp->mLeft, procDec, 0);
|
||||
Analyze(exp->mLeft, procDec, false, false);
|
||||
break;
|
||||
|
||||
case EX_CONSTRUCT:
|
||||
if (exp->mLeft->mLeft)
|
||||
Analyze(exp->mLeft->mLeft, procDec, 0);
|
||||
Analyze(exp->mLeft->mLeft, procDec, false, false);
|
||||
if (exp->mLeft->mRight)
|
||||
Analyze(exp->mLeft->mRight, procDec, 0);
|
||||
Analyze(exp->mLeft->mRight, procDec, false, false);
|
||||
if (exp->mRight)
|
||||
return Analyze(exp->mRight, procDec, 0);
|
||||
return Analyze(exp->mRight, procDec, false, false);
|
||||
break;
|
||||
|
||||
case EX_CLEANUP:
|
||||
Analyze(exp->mRight, procDec, 0);
|
||||
return Analyze(exp->mLeft, procDec, flags & ~ANAFL_ALIAS);
|
||||
Analyze(exp->mRight, procDec, false, false);
|
||||
return Analyze(exp->mLeft, procDec, lhs, false);
|
||||
|
||||
case EX_WHILE:
|
||||
procDec->mFlags &= ~DTF_FUNC_CONSTEXPR;
|
||||
|
||||
procDec->mComplexity += 20;
|
||||
|
||||
ldec = Analyze(exp->mLeft, procDec, 0);
|
||||
rdec = Analyze(exp->mRight, procDec, 0);
|
||||
ldec = Analyze(exp->mLeft, procDec, false, false);
|
||||
rdec = Analyze(exp->mRight, procDec, false, false);
|
||||
break;
|
||||
case EX_IF:
|
||||
procDec->mComplexity += 20;
|
||||
|
||||
ldec = Analyze(exp->mLeft, procDec, 0);
|
||||
rdec = Analyze(exp->mRight->mLeft, procDec, 0);
|
||||
ldec = Analyze(exp->mLeft, procDec, false, false);
|
||||
rdec = Analyze(exp->mRight->mLeft, procDec, false, false);
|
||||
if (exp->mRight->mRight)
|
||||
rdec = Analyze(exp->mRight->mRight, procDec, 0);
|
||||
rdec = Analyze(exp->mRight->mRight, procDec, false, false);
|
||||
break;
|
||||
case EX_ELSE:
|
||||
break;
|
||||
|
|
@ -1136,23 +1127,18 @@ Declaration * GlobalAnalyzer::Analyze(Expression* exp, Declaration* procDec, uin
|
|||
procDec->mComplexity += 30;
|
||||
|
||||
if (exp->mLeft->mRight)
|
||||
ldec = Analyze(exp->mLeft->mRight, procDec, 0);
|
||||
ldec = Analyze(exp->mLeft->mRight, procDec, false, false);
|
||||
if (exp->mLeft->mLeft->mLeft)
|
||||
ldec = Analyze(exp->mLeft->mLeft->mLeft, procDec, 0);
|
||||
rdec = Analyze(exp->mRight, procDec, 0);
|
||||
ldec = Analyze(exp->mLeft->mLeft->mLeft, procDec, false, false);
|
||||
rdec = Analyze(exp->mRight, procDec, false, false);
|
||||
if (exp->mLeft->mLeft->mRight)
|
||||
ldec = Analyze(exp->mLeft->mLeft->mRight, procDec, 0);
|
||||
break;
|
||||
case EX_FORBODY:
|
||||
ldec = Analyze(exp->mLeft, procDec, 0);
|
||||
if (exp->mRight)
|
||||
Analyze(exp->mRight, procDec, 0);
|
||||
ldec = Analyze(exp->mLeft->mLeft->mRight, procDec, false, false);
|
||||
break;
|
||||
case EX_DO:
|
||||
procDec->mComplexity += 20;
|
||||
|
||||
ldec = Analyze(exp->mLeft, procDec, 0);
|
||||
rdec = Analyze(exp->mRight, procDec, 0);
|
||||
ldec = Analyze(exp->mLeft, procDec, false, false);
|
||||
rdec = Analyze(exp->mRight, procDec, false, false);
|
||||
break;
|
||||
case EX_BREAK:
|
||||
case EX_CONTINUE:
|
||||
|
|
@ -1161,18 +1147,18 @@ Declaration * GlobalAnalyzer::Analyze(Expression* exp, Declaration* procDec, uin
|
|||
case EX_TYPE:
|
||||
break;
|
||||
case EX_TYPECAST:
|
||||
return Analyze(exp->mLeft, procDec, 0);
|
||||
return Analyze(exp->mLeft, procDec, false, false);
|
||||
break;
|
||||
case EX_LOGICAL_AND:
|
||||
ldec = Analyze(exp->mLeft, procDec, 0);
|
||||
rdec = Analyze(exp->mRight, procDec, 0);
|
||||
ldec = Analyze(exp->mLeft, procDec, false, false);
|
||||
rdec = Analyze(exp->mRight, procDec, false, false);
|
||||
break;
|
||||
case EX_LOGICAL_OR:
|
||||
ldec = Analyze(exp->mLeft, procDec, 0);
|
||||
rdec = Analyze(exp->mRight, procDec, 0);
|
||||
ldec = Analyze(exp->mLeft, procDec, false, false);
|
||||
rdec = Analyze(exp->mRight, procDec, false, false);
|
||||
break;
|
||||
case EX_LOGICAL_NOT:
|
||||
ldec = Analyze(exp->mLeft, procDec, 0);
|
||||
ldec = Analyze(exp->mLeft, procDec, false, false);
|
||||
break;
|
||||
case EX_ASSEMBLER:
|
||||
procDec->mFlags |= DTF_FUNC_ASSEMBLER;
|
||||
|
|
@ -1183,14 +1169,14 @@ Declaration * GlobalAnalyzer::Analyze(Expression* exp, Declaration* procDec, uin
|
|||
case EX_UNDEFINED:
|
||||
break;
|
||||
case EX_SWITCH:
|
||||
ldec = Analyze(exp->mLeft, procDec, 0);
|
||||
ldec = Analyze(exp->mLeft, procDec, false, false);
|
||||
exp = exp->mRight;
|
||||
while (exp)
|
||||
{
|
||||
procDec->mComplexity += 10;
|
||||
|
||||
if (exp->mLeft->mRight)
|
||||
rdec = Analyze(exp->mLeft->mRight, procDec, 0);
|
||||
rdec = Analyze(exp->mLeft->mRight, procDec, false, false);
|
||||
exp = exp->mRight;
|
||||
}
|
||||
break;
|
||||
|
|
@ -1201,9 +1187,9 @@ Declaration * GlobalAnalyzer::Analyze(Expression* exp, Declaration* procDec, uin
|
|||
case EX_CONDITIONAL:
|
||||
procDec->mComplexity += exp->mDecType->mSize * 10;
|
||||
|
||||
ldec = Analyze(exp->mLeft, procDec, 0);
|
||||
RegisterProc(Analyze(exp->mRight->mLeft, procDec, flags));
|
||||
RegisterProc(Analyze(exp->mRight->mRight, procDec, flags));
|
||||
ldec = Analyze(exp->mLeft, procDec, false, false);
|
||||
RegisterProc(Analyze(exp->mRight->mLeft, procDec, lhs, aliasing));
|
||||
RegisterProc(Analyze(exp->mRight->mRight, procDec, lhs, aliasing));
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -35,7 +35,7 @@ protected:
|
|||
int CallerInvokes(Declaration* called);
|
||||
int CallerInvokes(Declaration* caller, Declaration* called);
|
||||
|
||||
Declaration* Analyze(Expression* exp, Declaration* procDec, uint32 flags);
|
||||
Declaration* Analyze(Expression* exp, Declaration* procDec, bool lhs, bool aliasing);
|
||||
|
||||
bool IsStackParam(const Declaration* pdec) const;
|
||||
bool MarkCycle(Declaration* rootDec, Declaration* procDec);
|
||||
|
|
|
|||
|
|
@ -60,7 +60,7 @@ void GlobalOptimizer::Reset(void)
|
|||
mFunctions.SetSize(0);
|
||||
mGlobalVariables.SetSize(0);
|
||||
mCalledFunctions.SetSize(0);
|
||||
mCallingFunctions.SetSize(0);
|
||||
mCalledFunctions.SetSize(0);
|
||||
}
|
||||
|
||||
void GlobalOptimizer::PropagateParamCommas(Expression*& fexp, Expression*& exp)
|
||||
|
|
@ -275,23 +275,15 @@ bool GlobalOptimizer::ReplaceGlobalConst(Expression* exp)
|
|||
{
|
||||
if (exp->mType == EX_VARIABLE && (exp->mDecValue->mFlags & (DTF_GLOBAL | DTF_STATIC)) && !(exp->mDecValue->mOptFlags & (OPTF_VAR_MODIFIED | OPTF_VAR_ADDRESS)) && exp->mDecValue->mValue)
|
||||
{
|
||||
|
||||
Expression* cexp = exp->mDecValue->mValue;
|
||||
if (cexp->mType == EX_CONSTANT)
|
||||
{
|
||||
|
||||
if (cexp->mDecValue->mType == DT_CONST_ADDRESS || cexp->mDecValue->mType == DT_CONST_INTEGER ||
|
||||
cexp->mDecValue->mType == DT_CONST_POINTER || cexp->mDecValue->mType == DT_CONST_FLOAT)
|
||||
if (cexp->mType == EX_CONSTANT &&
|
||||
(cexp->mDecValue->mType == DT_CONST_ADDRESS || cexp->mDecValue->mType == DT_CONST_INTEGER ||
|
||||
cexp->mDecValue->mType == DT_CONST_POINTER || cexp->mDecValue->mType == DT_CONST_FLOAT))
|
||||
{
|
||||
exp->mType = EX_CONSTANT;
|
||||
exp->mDecValue = cexp->mDecValue->ConstCast(exp->mDecType);
|
||||
changed = true;
|
||||
}
|
||||
else if (exp->mDecValue->mBase->mType == DT_TYPE_STRUCT)
|
||||
{
|
||||
exp->mDecValue->mBase = exp->mDecValue->mBase->ToConstType();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (ReplaceGlobalConst(exp->mLeft))
|
||||
|
|
@ -341,7 +333,7 @@ bool GlobalOptimizer::Optimize(void)
|
|||
|
||||
if (!(func->mOptFlags & OPTF_FUNC_VARIABLE) && !(func->mBase->mFlags & DTF_VIRTUAL))
|
||||
{
|
||||
if (!(func->mOptFlags & (OPTF_VAR_USED | OPTF_VAR_ADDRESS)) && func->mBase->mBase && (func->mBase->mBase->IsSimpleType() || func->mBase->mBase->IsReference()))
|
||||
if (!(func->mOptFlags & OPTF_VAR_USED) && func->mBase->mBase && (func->mBase->mBase->IsSimpleType() || func->mBase->mBase->IsReference()))
|
||||
{
|
||||
#if DUMP_OPTS
|
||||
printf("Remove return value\n");
|
||||
|
|
@ -462,7 +454,7 @@ void GlobalOptimizer::AnalyzeProcedure(Expression* exp, Declaration* procDec)
|
|||
Analyze(exp, procDec, false);
|
||||
}
|
||||
else
|
||||
mErrors->Error(procDec->mLocation, EERR_UNDEFINED_OBJECT, "Calling undefined function", procDec->FullIdent());
|
||||
mErrors->Error(procDec->mLocation, EERR_UNDEFINED_OBJECT, "Calling undefined function", procDec->mQualIdent);
|
||||
|
||||
procDec->mOptFlags &= ~OPTF_ANALYZING;
|
||||
}
|
||||
|
|
@ -614,6 +606,9 @@ void GlobalOptimizer::RegisterProc(Declaration* to)
|
|||
}
|
||||
}
|
||||
|
||||
static const uint32 ANAFL_LHS = (1U << 0);
|
||||
static const uint32 ANAFL_RHS = (1U << 1);
|
||||
|
||||
Declaration* GlobalOptimizer::Analyze(Expression* exp, Declaration* procDec, uint32 flags)
|
||||
{
|
||||
Declaration* ldec, * rdec;
|
||||
|
|
@ -659,8 +654,6 @@ Declaration* GlobalOptimizer::Analyze(Expression* exp, Declaration* procDec, uin
|
|||
exp->mDecValue->mOptFlags |= OPTF_VAR_USED;
|
||||
if (flags & ANAFL_LHS)
|
||||
exp->mDecValue->mOptFlags |= OPTF_VAR_ADDRESS;
|
||||
if (exp->mDecValue->mBase->IsReference() && (flags & ANAFL_ASSIGN))
|
||||
exp->mDecValue->mOptFlags |= OPTF_VAR_USED;
|
||||
|
||||
if (exp->mDecValue->mType == DT_ARGUMENT && (flags & ANAFL_LHS))
|
||||
{
|
||||
|
|
@ -672,12 +665,7 @@ Declaration* GlobalOptimizer::Analyze(Expression* exp, Declaration* procDec, uin
|
|||
case EX_INITIALIZATION:
|
||||
case EX_ASSIGNMENT:
|
||||
if (exp->mToken == TK_ASSIGN)
|
||||
{
|
||||
if (exp->mType == EX_ASSIGNMENT)
|
||||
ldec = Analyze(exp->mLeft, procDec, ANAFL_LHS | ANAFL_ASSIGN | flags);
|
||||
else
|
||||
ldec = Analyze(exp->mLeft, procDec, ANAFL_LHS | flags);
|
||||
}
|
||||
else
|
||||
ldec = Analyze(exp->mLeft, procDec, ANAFL_LHS | ANAFL_RHS | flags);
|
||||
|
||||
|
|
@ -825,22 +813,6 @@ Declaration* GlobalOptimizer::Analyze(Expression* exp, Declaration* procDec, uin
|
|||
pdec->mOptFlags |= OPTF_VAR_CONST;
|
||||
}
|
||||
}
|
||||
else if (pex->mType == EX_VARIABLE && pdec->mBase->mType == DT_TYPE_POINTER && pex->mDecType->mType == DT_TYPE_ARRAY && (pex->mDecValue->mFlags & (DTF_GLOBAL | DTF_STATIC)) && pdec->mBase->CanAssign(pex->mDecType))
|
||||
{
|
||||
if (pdec->mOptFlags & OPTF_VAR_CONST)
|
||||
{
|
||||
if (pdec->mValue->mType != EX_VARIABLE || pdec->mValue->mDecValue != pex->mDecValue)
|
||||
{
|
||||
pdec->mOptFlags |= OPTF_VAR_NOCONST;
|
||||
pdec->mOptFlags &= ~OPTF_VAR_CONST;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
pdec->mValue = pex;
|
||||
pdec->mOptFlags |= OPTF_VAR_CONST;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
pdec->mOptFlags |= OPTF_VAR_NOCONST;
|
||||
|
|
@ -986,11 +958,6 @@ Declaration* GlobalOptimizer::Analyze(Expression* exp, Declaration* procDec, uin
|
|||
if (exp->mLeft->mLeft->mRight)
|
||||
ldec = Analyze(exp->mLeft->mLeft->mRight, procDec, 0);
|
||||
break;
|
||||
case EX_FORBODY:
|
||||
ldec = Analyze(exp->mLeft, procDec, 0);
|
||||
if (exp->mRight)
|
||||
rdec = Analyze(exp->mRight, procDec, 0);
|
||||
break;
|
||||
case EX_DO:
|
||||
ldec = Analyze(exp->mRight, procDec, 0);
|
||||
rdec = Analyze(exp->mLeft, procDec, ANAFL_RHS);
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ const Ident* Ident::Unique(const char* str)
|
|||
|
||||
const Ident* Ident::PreMangle(const char* str) const
|
||||
{
|
||||
char buffer[1000];
|
||||
char buffer[200];
|
||||
strcpy_s(buffer, str);
|
||||
strcat_s(buffer, mString);
|
||||
return Unique(buffer);
|
||||
|
|
@ -55,14 +55,14 @@ const Ident* Ident::PreMangle(const char* str) const
|
|||
|
||||
const Ident* Ident::Unique(const char* str, int id)
|
||||
{
|
||||
char buffer[1000];
|
||||
char buffer[200];
|
||||
sprintf_s(buffer, "%s#%d", str, id);
|
||||
return Unique(buffer);
|
||||
}
|
||||
|
||||
const Ident* Ident::Mangle(const char* str) const
|
||||
{
|
||||
char buffer[1000];
|
||||
char buffer[200];
|
||||
strcpy_s(buffer, mString);
|
||||
strcat_s(buffer, str);
|
||||
return Unique(buffer);
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -169,7 +169,6 @@ public:
|
|||
} mMinState, mMaxState;
|
||||
|
||||
bool Same(const IntegerValueRange& range) const;
|
||||
bool Weaker(const IntegerValueRange& range) const;
|
||||
bool Merge(const IntegerValueRange& range, bool head, bool initial);
|
||||
void Expand(const IntegerValueRange& range);
|
||||
void Union(const IntegerValueRange& range);
|
||||
|
|
@ -199,7 +198,7 @@ public:
|
|||
|
||||
|
||||
|
||||
typedef ExpandingArray<IntegerValueRange> GrowingIntegerValueRangeArray;
|
||||
typedef GrowingArray<IntegerValueRange> GrowingIntegerValueRangeArray;
|
||||
|
||||
class ValueSet
|
||||
{
|
||||
|
|
@ -381,7 +380,7 @@ public:
|
|||
InterCodeBasicBlock * mTrueJump, * mFalseJump, * mLoopPrefix, * mDominator;
|
||||
GrowingInstructionArray mInstructions;
|
||||
|
||||
bool mVisited, mInPath, mLoopHead, mChecked, mConditionBlockTrue, mUnreachable, mLoopPath, mValueRangeValid, mPatched, mLoopDebug;
|
||||
bool mVisited, mInPath, mLoopHead, mChecked, mConditionBlockTrue, mUnreachable, mLoopPath, mValueRangeValid;
|
||||
mutable int mMark;
|
||||
|
||||
NumberSet mLocalUsedTemps, mLocalModifiedTemps;
|
||||
|
|
@ -430,9 +429,8 @@ public:
|
|||
|
||||
void CollectEntries(void);
|
||||
void CollectEntryBlocks(InterCodeBasicBlock* from);
|
||||
void GenerateTraces(int expand, bool compact);
|
||||
void GenerateTraces(bool expand, bool compact);
|
||||
void BuildDominatorTree(InterCodeBasicBlock * from);
|
||||
bool StripLoopHead(void);
|
||||
|
||||
bool MergeSameConditionTraces(void);
|
||||
|
||||
|
|
@ -450,7 +448,6 @@ public:
|
|||
void CollectConstTemps(GrowingInstructionPtrArray& ctemps, NumberSet& assignedTemps);
|
||||
bool PropagateConstTemps(const GrowingInstructionPtrArray& ctemps);
|
||||
bool ForwardConstTemps(const GrowingInstructionPtrArray& ctemps);
|
||||
bool PropagateConstCompareResults(void);
|
||||
|
||||
bool EarlyBranchElimination(const GrowingInstructionPtrArray& ctemps);
|
||||
|
||||
|
|
@ -520,8 +517,6 @@ public:
|
|||
void PerformMachineSpecificValueUsageCheck(const GrowingInstructionPtrArray& tvalue, FastNumberSet& tvalid, const GrowingVariableArray& staticVars, const GrowingInterCodeProcedurePtrArray& staticProcs, FastNumberSet& fsingle);
|
||||
bool EliminateDeadBranches(void);
|
||||
|
||||
bool EliminateIntegerSumAliasTemps(const GrowingInstructionPtrArray& tvalue);
|
||||
|
||||
bool MergeIndexedLoadStore(const GrowingInstructionPtrArray& tvalue);
|
||||
bool SimplifyIntegerNumeric(const GrowingInstructionPtrArray& tvalue, int& spareTemps);
|
||||
bool SimplifyPointerOffsets(void);
|
||||
|
|
@ -641,20 +636,14 @@ public:
|
|||
void PushMoveOutOfLoop(void);
|
||||
bool MoveConditionOutOfLoop(void);
|
||||
void SingleLoopCountZeroCheck(void);
|
||||
void InnerLoopCountZeroCheck(void);
|
||||
bool PostDecLoopOptimization(void);
|
||||
bool Flatten2DLoop(void);
|
||||
|
||||
void PropagateMemoryAliasingInfo(const GrowingInstructionPtrArray& tvalue, bool loops);
|
||||
void PropagateMemoryAliasingInfo(const GrowingInstructionPtrArray& tvalue);
|
||||
void RemoveUnusedMallocs(void);
|
||||
|
||||
bool PullStoreUpToConstAddress(void);
|
||||
|
||||
bool CollectSingleHeadLoopBody(InterCodeBasicBlock* head, InterCodeBasicBlock* tail, ExpandingArray<InterCodeBasicBlock*>& body);
|
||||
|
||||
bool CollectGenericLoop(ExpandingArray<InterCodeBasicBlock*>& lblocks);
|
||||
bool CollectSingleEntryGenericLoop(ExpandingArray<InterCodeBasicBlock*>& lblocks);
|
||||
void CollectReachable(ExpandingArray<InterCodeBasicBlock*>& lblock);
|
||||
bool CollectSingleHeadLoopBody(InterCodeBasicBlock* head, InterCodeBasicBlock* tail, GrowingArray<InterCodeBasicBlock*>& body);
|
||||
|
||||
bool SingleTailLoopOptimization(const NumberSet& aliasedParams, const GrowingVariableArray& staticVars);
|
||||
bool MergeLoopTails(void);
|
||||
|
|
@ -662,7 +651,6 @@ public:
|
|||
bool ChangeTrueJump(InterCodeBasicBlock* block);
|
||||
bool ChangeFalseJump(InterCodeBasicBlock* block);
|
||||
|
||||
InterCodeBasicBlock* CheckIsSimpleIntRangeBranch(const GrowingIntegerValueRangeArray & irange);
|
||||
InterCodeBasicBlock* CheckIsConstBranch(const GrowingInstructionPtrArray& cins);
|
||||
bool ShortcutConstBranches(const GrowingInstructionPtrArray& cins);
|
||||
bool ShortcutDuplicateBranches(void);
|
||||
|
|
@ -713,7 +701,6 @@ protected:
|
|||
GrowingIntegerValueRangeArray mLocalValueRange, mReverseValueRange;
|
||||
|
||||
void ResetVisited(void);
|
||||
void ResetPatched(void);
|
||||
void ResetEntryBlocks(void);
|
||||
public:
|
||||
InterCodeBasicBlock * mEntryBlock;
|
||||
|
|
@ -775,7 +762,7 @@ public:
|
|||
void Disassemble(const char* name, bool dumpSets = false);
|
||||
protected:
|
||||
void BuildLocalAliasTable(void);
|
||||
void BuildTraces(int expand, bool dominators = true, bool compact = false);
|
||||
void BuildTraces(bool expand, bool dominators = true, bool compact = false);
|
||||
void TrimBlocks(void);
|
||||
void EarlyBranchElimination(void);
|
||||
void BuildDataFlowSets(void);
|
||||
|
|
@ -798,7 +785,6 @@ protected:
|
|||
void SingleBlockLoopPointerToByte(FastNumberSet& activeSet);
|
||||
void SingleBlockLoopSinking(FastNumberSet& activeSet);
|
||||
void MergeIndexedLoadStore(void);
|
||||
void EliminateIntegerSumAliasTemps(void);
|
||||
void EliminateAliasValues();
|
||||
void LoadStoreForwarding(InterMemory paramMemory);
|
||||
void ReduceRecursionTempSpilling(InterMemory paramMemory);
|
||||
|
|
@ -818,7 +804,7 @@ protected:
|
|||
void CheckUsedDefinedTemps(void);
|
||||
void WarnUsedUndefinedVariables(void);
|
||||
void WarnInvalidValueRanges(void);
|
||||
void PropagateMemoryAliasingInfo(bool loops);
|
||||
void PropagateMemoryAliasingInfo(void);
|
||||
void MoveConditionsOutOfLoop(void);
|
||||
void ShortcutConstBranches(void);
|
||||
void ShortcutDuplicateBranches(void);
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
InterCodeGenerator::InterCodeGenerator(Errors* errors, Linker* linker)
|
||||
: mErrors(errors), mLinker(linker), mCompilerOptions(COPT_DEFAULT)
|
||||
{
|
||||
mMainInitBlock = nullptr;
|
||||
|
||||
}
|
||||
|
||||
InterCodeGenerator::~InterCodeGenerator(void)
|
||||
|
|
@ -12,16 +12,6 @@ InterCodeGenerator::~InterCodeGenerator(void)
|
|||
|
||||
}
|
||||
|
||||
static inline InterType InterTypeOfSize(int size)
|
||||
{
|
||||
if (size <= 1)
|
||||
return IT_INT8;
|
||||
else if (size <= 2)
|
||||
return IT_INT16;
|
||||
else
|
||||
return IT_INT32;
|
||||
}
|
||||
|
||||
static inline InterType InterTypeOf(const Declaration* dec)
|
||||
{
|
||||
switch (dec->mType)
|
||||
|
|
@ -61,7 +51,7 @@ InterCodeGenerator::ExValue InterCodeGenerator::ToValue(InterCodeProcedure* proc
|
|||
return v;
|
||||
}
|
||||
|
||||
InterCodeGenerator::ExValue InterCodeGenerator::Dereference(InterCodeProcedure* proc, Expression* exp, InterCodeBasicBlock*& block, InlineMapper* inlineMapper, ExValue v, int level, int limit)
|
||||
InterCodeGenerator::ExValue InterCodeGenerator::Dereference(InterCodeProcedure* proc, Expression* exp, InterCodeBasicBlock*& block, InlineMapper* inlineMapper, ExValue v, int level)
|
||||
{
|
||||
while (v.mReference > level)
|
||||
{
|
||||
|
|
@ -82,19 +72,11 @@ InterCodeGenerator::ExValue InterCodeGenerator::Dereference(InterCodeProcedure*
|
|||
ins->mSrc[0].mStride = v.mReference == 1 ? v.mType->mStripe : 1;
|
||||
|
||||
|
||||
if (v.mReference == 1)
|
||||
{
|
||||
if (v.mType->mType == DT_TYPE_ENUM && !v.mBits)
|
||||
if (v.mReference == 1 && v.mType->mType == DT_TYPE_ENUM && !v.mBits)
|
||||
{
|
||||
ins->mDst.mRange.LimitMin(v.mType->mMinValue);
|
||||
ins->mDst.mRange.LimitMax(v.mType->mMaxValue);
|
||||
}
|
||||
else if (v.mType->mType == DT_TYPE_INTEGER && !v.mBits && limit > 0)
|
||||
{
|
||||
ins->mDst.mRange.LimitMin(0);
|
||||
ins->mDst.mRange.LimitMax(limit - 1);
|
||||
}
|
||||
}
|
||||
|
||||
if (v.mType->mFlags & DTF_VOLATILE)
|
||||
ins->mVolatile = true;
|
||||
|
|
@ -788,10 +770,7 @@ void InterCodeGenerator::InitGlobalVariable(InterCodeModule * mod, Declaration*
|
|||
decb = decb->mBase;
|
||||
|
||||
if (decb && decb->mStripe != 1)
|
||||
{
|
||||
AddGlobalVariableRanges(var->mLinkerObject, decb, 0, nullptr);
|
||||
var->mLinkerObject->mStripe = decb->mStripe;
|
||||
}
|
||||
|
||||
Declaration* type = dec->mBase;
|
||||
while (type->mType == DT_TYPE_ARRAY)
|
||||
|
|
@ -800,16 +779,6 @@ void InterCodeGenerator::InitGlobalVariable(InterCodeModule * mod, Declaration*
|
|||
var->mLinkerObject->mFlags |= LOBJF_CONST;
|
||||
if (dec->mFlags & DTF_ZEROPAGE)
|
||||
var->mLinkerObject->mFlags |= LOBJF_ZEROPAGE;
|
||||
if (dec->mFlags & DTF_NO_PAGE_CROSS)
|
||||
var->mLinkerObject->mFlags |= LOBJF_NEVER_CROSS | LOBJF_NO_CROSS;
|
||||
if (mCompilerOptions & COPT_OPTIMIZE_PAGE_CROSSING)
|
||||
{
|
||||
if (dec->mSize <= 256 && dec->mSize > 1)
|
||||
{
|
||||
if (dec->mBase->ContainsArray())
|
||||
var->mLinkerObject->mFlags |= LOBJF_NEVER_CROSS | LOBJF_NO_CROSS;
|
||||
}
|
||||
}
|
||||
|
||||
var->mIndex = mod->mGlobalVars.Size();
|
||||
var->mDeclaration = dec;
|
||||
|
|
@ -903,7 +872,7 @@ void InterCodeGenerator::TranslateAssembler(InterCodeModule* mod, Declaration *
|
|||
cexp = cexp->mRight;
|
||||
}
|
||||
|
||||
// Check if remapping of labels due to operand address size change
|
||||
// Check if remapping of lables due to operand address size change
|
||||
if (osize != rsize)
|
||||
{
|
||||
adec->mBase->mScope->Iterate([=](const Ident* ident, Declaration* dec) {
|
||||
|
|
@ -1669,7 +1638,7 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateInline(Declaration* pro
|
|||
mErrors->Error(exp->mLeft->mLocation, EERR_NOT_AN_LVALUE, "Not an addressable expression");
|
||||
|
||||
if (vp.mTemp != vr.mTemp)
|
||||
CopyStruct(proc, exp, block, vp, vr, inlineMapper, false);
|
||||
CopyStructSimple(proc, exp, block, inlineMapper, vp, vr);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -1680,15 +1649,12 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateInline(Declaration* pro
|
|||
else if (vr.mType->IsReference() && !(pdec && pdec->mBase->IsReference()))
|
||||
{
|
||||
vr.mReference++;
|
||||
vr.mType = vr.mType->mBase;
|
||||
vr = Dereference(proc, texp, block, inlineMapper, vr);
|
||||
}
|
||||
else
|
||||
vr = Dereference(proc, texp, block, inlineMapper, vr);
|
||||
|
||||
if (pdec && (pdec->mFlags & DTF_FPARAM_UNUSED) && vr.mType->mType == DT_TYPE_VOID)
|
||||
;
|
||||
else if (pdec)
|
||||
if (pdec)
|
||||
{
|
||||
if (pdec->mBase->mType == DT_TYPE_POINTER && vr.mType->mType == DT_TYPE_INTEGER)
|
||||
{
|
||||
|
|
@ -1942,7 +1908,6 @@ void InterCodeGenerator::CopyStruct(InterCodeProcedure* proc, Expression* exp, I
|
|||
nmapper.mReturn = new InterCodeBasicBlock(proc);
|
||||
nmapper.mVarIndex = proc->mNumLocals;
|
||||
nmapper.mConstExpr = false;
|
||||
nmapper.mLocation = new Location(MapLocation(exp, inlineMapper));
|
||||
proc->mNumLocals += ccdec->mNumVars;
|
||||
if (inlineMapper)
|
||||
nmapper.mDepth = inlineMapper->mDepth + 1;
|
||||
|
|
@ -2231,13 +2196,13 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
|
|||
if (dec->mBase->mFlags & DTF_SIGNED)
|
||||
{
|
||||
if (dec->mInteger < -128 || dec->mInteger > 127)
|
||||
mErrors->Error(exp->mLocation, EWARN_CONSTANT_TRUNCATED, "Integer constant truncated");
|
||||
mErrors->Error(dec->mLocation, EWARN_CONSTANT_TRUNCATED, "Integer constant truncated");
|
||||
ins->mConst.mIntConst = int8(dec->mInteger);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (dec->mInteger < 0 || dec->mInteger > 255)
|
||||
mErrors->Error(exp->mLocation, EWARN_CONSTANT_TRUNCATED, "Unsigned integer constant truncated");
|
||||
mErrors->Error(dec->mLocation, EWARN_CONSTANT_TRUNCATED, "Unsigned integer constant truncated");
|
||||
ins->mConst.mIntConst = uint8(dec->mInteger);
|
||||
}
|
||||
}
|
||||
|
|
@ -2246,13 +2211,13 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
|
|||
if (dec->mBase->mFlags & DTF_SIGNED)
|
||||
{
|
||||
if (dec->mInteger < -32768 || dec->mInteger > 32767)
|
||||
mErrors->Error(exp->mLocation, EWARN_CONSTANT_TRUNCATED, "Integer constant truncated");
|
||||
mErrors->Error(dec->mLocation, EWARN_CONSTANT_TRUNCATED, "Integer constant truncated");
|
||||
ins->mConst.mIntConst = int16(dec->mInteger);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (dec->mInteger < 0 || dec->mInteger > 65535)
|
||||
mErrors->Error(exp->mLocation, EWARN_CONSTANT_TRUNCATED, "Unsigned integer constant truncated");
|
||||
mErrors->Error(dec->mLocation, EWARN_CONSTANT_TRUNCATED, "Unsigned integer constant truncated");
|
||||
ins->mConst.mIntConst = uint16(dec->mInteger);
|
||||
}
|
||||
}
|
||||
|
|
@ -2261,13 +2226,13 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
|
|||
if (dec->mBase->mFlags & DTF_SIGNED)
|
||||
{
|
||||
if (dec->mInteger < -2147483648LL || dec->mInteger > 2147483647LL)
|
||||
mErrors->Error(exp->mLocation, EWARN_CONSTANT_TRUNCATED, "Integer constant truncated");
|
||||
mErrors->Error(dec->mLocation, EWARN_CONSTANT_TRUNCATED, "Integer constant truncated");
|
||||
ins->mConst.mIntConst = int32(dec->mInteger);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (dec->mInteger < 0 || dec->mInteger > 4294967296LL)
|
||||
mErrors->Error(exp->mLocation, EWARN_CONSTANT_TRUNCATED, "Unsigned integer constant truncated");
|
||||
mErrors->Error(dec->mLocation, EWARN_CONSTANT_TRUNCATED, "Unsigned integer constant truncated");
|
||||
ins->mConst.mIntConst = uint32(dec->mInteger);
|
||||
}
|
||||
}
|
||||
|
|
@ -2728,9 +2693,6 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
|
|||
else
|
||||
{
|
||||
Declaration * otype = vll.mType;
|
||||
if (vll.mType->mType == DT_TYPE_BOOL && vr.mType->mType == DT_TYPE_BOOL)
|
||||
otype = TheUnsignedCharTypeDeclaration;
|
||||
|
||||
#if 1
|
||||
if ((exp->mRight->mType != EX_CONSTANT || (exp->mToken != TK_ASSIGN_ADD && exp->mToken != TK_ASSIGN_SUB && exp->mToken != TK_ASSIGN_AND && exp->mToken != TK_ASSIGN_OR)) && otype->mSize < 2)
|
||||
#else
|
||||
|
|
@ -2843,7 +2805,6 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
|
|||
}
|
||||
|
||||
vl = Dereference(proc, exp, block, inlineMapper, vl, vl.mType->mType == DT_TYPE_POINTER ? 0 : 1);
|
||||
|
||||
vr = Dereference(proc, exp, block, inlineMapper, vr);
|
||||
|
||||
if (vl.mType->mType != DT_TYPE_ARRAY && vl.mType->mType != DT_TYPE_POINTER)
|
||||
|
|
@ -2878,11 +2839,6 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
|
|||
ains->mSrc[1].mMemory = IM_INDIRECT;
|
||||
ains->mSrc[0].mType = IT_INT16;
|
||||
ains->mSrc[0].mTemp = mins->mDst.mTemp;
|
||||
if (vl.mType->mType == DT_TYPE_ARRAY && vl.mType->mSize > vl.mType->mBase->mSize && (exp->mFlags & ANAFL_RHS))
|
||||
{
|
||||
ains->mSrc[0].mRange.LimitMin(0);
|
||||
ains->mSrc[0].mRange.LimitMax(vl.mType->mSize);
|
||||
}
|
||||
ains->mSrc[1].mType = IT_POINTER;
|
||||
ains->mSrc[1].mTemp = vl.mTemp;
|
||||
ains->mDst.mType = IT_POINTER;
|
||||
|
|
@ -2949,7 +2905,7 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
|
|||
ptype->mSize = 2;
|
||||
ptype->mStride = vl.mType->mStride;
|
||||
vl.mReference = 0;
|
||||
vl.mType = ptype;
|
||||
vl.mType = exp->mDecType; // ptype;
|
||||
}
|
||||
|
||||
if (vr.mType->mType == DT_TYPE_POINTER)
|
||||
|
|
@ -3011,7 +2967,7 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
|
|||
ins->mDst.mTemp = proc->AddTemporary(ins->mDst.mType);
|
||||
block->Append(ins);
|
||||
}
|
||||
else if ((vr.mType->mType == DT_TYPE_POINTER || vr.mType->mType == DT_TYPE_ARRAY) && (vl.mType->mType == DT_TYPE_POINTER || vl.mType->mType == DT_TYPE_ARRAY) && vr.mType->mBase->IsConstSame(vl.mType->mBase))
|
||||
else if (vr.mType->mType == DT_TYPE_POINTER && vr.mType->mBase->IsConstSame(vl.mType->mBase))
|
||||
{
|
||||
if (exp->mToken == TK_SUB)
|
||||
{
|
||||
|
|
@ -3074,8 +3030,6 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
|
|||
}
|
||||
else
|
||||
mErrors->Error(exp->mLocation, EERR_INCOMPATIBLE_OPERATOR, "Invalid pointer operation");
|
||||
|
||||
vl.mType = exp->mDecType;
|
||||
}
|
||||
else if (vr.mType->mType == DT_TYPE_POINTER || vr.mType->mType == DT_TYPE_ARRAY)
|
||||
{
|
||||
|
|
@ -3601,8 +3555,6 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
|
|||
else
|
||||
dtype = TheSignedIntTypeDeclaration;
|
||||
}
|
||||
else if (vl.mType->mSize == 1 && vr.mType->mSize == 1 && ((vr.mType->mFlags & DTF_SIGNED) || (vl.mType->mFlags & DTF_SIGNED)))
|
||||
dtype = TheSignedIntTypeDeclaration;
|
||||
else
|
||||
{
|
||||
if (vl.mType->mSize == 4 || vr.mType->mSize == 4)
|
||||
|
|
@ -3730,18 +3682,6 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
|
|||
else if (!strcmp(iname->mString, "exp"))
|
||||
{
|
||||
}
|
||||
else if (!strcmp(iname->mString, "sqrt"))
|
||||
{
|
||||
}
|
||||
else if (!strcmp(iname->mString, "atan"))
|
||||
{
|
||||
}
|
||||
else if (!strcmp(iname->mString, "pow"))
|
||||
{
|
||||
}
|
||||
else if (!strcmp(iname->mString, "atan2"))
|
||||
{
|
||||
}
|
||||
else if (!strcmp(iname->mString, "breakpoint"))
|
||||
{
|
||||
InterInstruction* ins = new InterInstruction(MapLocation(exp, inlineMapper), IC_BREAKPOINT);
|
||||
|
|
@ -3960,7 +3900,6 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
|
|||
exp->mLeft->mDecValue->mType == DT_CONST_FUNCTION &&
|
||||
((mCompilerOptions & COPT_OPTIMIZE_INLINE) || (exp->mLeft->mDecValue->mFlags & DTF_FORCE_INLINE)) &&
|
||||
!(inlineMapper && inlineMapper->mDepth > 10) &&
|
||||
!(exp->mLeft->mDecValue->mFlags & DTF_PREVENT_INLINE) &&
|
||||
exp->mType != EX_VCALL;
|
||||
bool doInline = false, inlineConstexpr = false;
|
||||
|
||||
|
|
@ -4043,7 +3982,7 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
|
|||
Declaration * decResult = nullptr;
|
||||
GrowingArray<InterInstruction*> defins(nullptr);
|
||||
|
||||
if (ftype->mBase->IsComplexStruct())
|
||||
if (ftype->mBase->mType == DT_TYPE_STRUCT)
|
||||
{
|
||||
int ttemp;
|
||||
if (lrexp)
|
||||
|
|
@ -4327,12 +4266,7 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
|
|||
|
||||
cins->mSrc[0].mType = IT_POINTER;
|
||||
cins->mSrc[0].mTemp = vl.mTemp;
|
||||
if (ftype->mBase->IsShortIntStruct())
|
||||
{
|
||||
cins->mDst.mType = InterTypeOfSize(ftype->mBase->mSize);
|
||||
cins->mDst.mTemp = proc->AddTemporary(cins->mDst.mType);
|
||||
}
|
||||
else if (ftype->mBase->mType != DT_TYPE_VOID && ftype->mBase->mType != DT_TYPE_STRUCT)
|
||||
if (ftype->mBase->mType != DT_TYPE_VOID && ftype->mBase->mType != DT_TYPE_STRUCT)
|
||||
{
|
||||
cins->mDst.mType = InterTypeOf(ftype->mBase);
|
||||
cins->mDst.mTemp = proc->AddTemporary(cins->mDst.mType);
|
||||
|
|
@ -4355,114 +4289,7 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
|
|||
block->Append(xins);
|
||||
}
|
||||
|
||||
if (ftype->mBase->IsShortIntStruct())
|
||||
{
|
||||
int ttemp;
|
||||
if (lrexp)
|
||||
{
|
||||
ttemp = lrexp->mTemp;
|
||||
|
||||
decResult = lrexp->mType;
|
||||
}
|
||||
else
|
||||
{
|
||||
int nindex = proc->mNumLocals++;
|
||||
|
||||
Declaration* vdec = new Declaration(exp->mLocation, DT_VARIABLE);
|
||||
|
||||
vdec->mVarIndex = nindex;
|
||||
vdec->mBase = ftype->mBase;
|
||||
vdec->mSize = ftype->mBase->mSize;
|
||||
|
||||
decResult = vdec;
|
||||
|
||||
InterInstruction* vins = new InterInstruction(MapLocation(exp, inlineMapper), IC_CONSTANT);
|
||||
vins->mDst.mType = IT_POINTER;
|
||||
vins->mDst.mTemp = proc->AddTemporary(IT_POINTER);
|
||||
vins->mConst.mType = IT_POINTER;
|
||||
vins->mConst.mMemory = IM_LOCAL;
|
||||
vins->mConst.mVarIndex = nindex;
|
||||
vins->mConst.mOperandSize = ftype->mBase->mSize;
|
||||
block->Append(vins);
|
||||
|
||||
ttemp = vins->mDst.mTemp;
|
||||
}
|
||||
// Unmarshall result from return value into struct
|
||||
|
||||
Declaration* dec = ftype->mBase->mParams;
|
||||
while (dec)
|
||||
{
|
||||
if (dec->mType == DT_ELEMENT)
|
||||
{
|
||||
InterInstruction* oins = new InterInstruction(MapLocation(exp, inlineMapper), IC_CONSTANT);
|
||||
oins->mDst.mType = IT_INT16;
|
||||
oins->mDst.mTemp = proc->AddTemporary(IT_INT16);
|
||||
oins->mConst.mType = IT_INT16;
|
||||
oins->mConst.mIntConst = dec->mOffset;
|
||||
block->Append(oins);
|
||||
|
||||
InterInstruction* ains = new InterInstruction(MapLocation(exp, inlineMapper), IC_LEA);
|
||||
ains->mSrc[1].mMemory = IM_INDIRECT;
|
||||
ains->mSrc[1].mType = IT_POINTER;
|
||||
ains->mSrc[1].mTemp = ttemp;
|
||||
ains->mSrc[0] = oins->mDst;
|
||||
ains->mDst.mType = IT_POINTER;
|
||||
ains->mDst.mMemory = IM_INDIRECT;
|
||||
ains->mDst.mTemp = proc->AddTemporary(IT_POINTER);
|
||||
ains->mDst.mOperandSize = dec->mSize;
|
||||
ains->mNumOperands = 2;
|
||||
block->Append(ains);
|
||||
|
||||
InterInstruction* csins = new InterInstruction(MapLocation(exp, inlineMapper), IC_CONSTANT);
|
||||
csins->mDst.mType = IT_INT8;
|
||||
csins->mDst.mTemp = proc->AddTemporary(csins->mDst.mType);
|
||||
csins->mConst.mType = IT_INT8;
|
||||
csins->mConst.mIntConst = 8 * dec->mOffset;
|
||||
csins->mNumOperands = 0;
|
||||
block->Append(csins);
|
||||
|
||||
InterInstruction* asins = new InterInstruction(MapLocation(exp, inlineMapper), IC_CONSTANT);
|
||||
asins->mDst.mType = cins->mDst.mType;
|
||||
asins->mDst.mTemp = proc->AddTemporary(csins->mDst.mType);
|
||||
asins->mConst.mType = cins->mDst.mType;
|
||||
asins->mConst.mIntConst = (1ll << 8 * dec->mSize) - 1;
|
||||
asins->mNumOperands = 0;
|
||||
block->Append(asins);
|
||||
|
||||
InterInstruction* shins = new InterInstruction(MapLocation(exp, inlineMapper), IC_BINARY_OPERATOR);
|
||||
shins->mOperator = IA_SHR;
|
||||
shins->mDst.mType = cins->mDst.mType;
|
||||
shins->mDst.mTemp = proc->AddTemporary(shins->mDst.mType);
|
||||
shins->mSrc[1] = cins->mDst;
|
||||
shins->mSrc[0] = csins->mDst;
|
||||
shins->mNumOperands = 2;
|
||||
block->Append(shins);
|
||||
|
||||
InterInstruction* andins = new InterInstruction(MapLocation(exp, inlineMapper), IC_BINARY_OPERATOR);
|
||||
andins->mOperator = IA_AND;
|
||||
andins->mDst.mType = cins->mDst.mType;
|
||||
andins->mDst.mTemp = proc->AddTemporary(andins->mDst.mType);
|
||||
andins->mSrc[0] = asins->mDst;
|
||||
andins->mSrc[1] = shins->mDst;
|
||||
andins->mNumOperands = 2;
|
||||
block->Append(andins);
|
||||
|
||||
InterInstruction* sins = new InterInstruction(MapLocation(exp, inlineMapper), IC_STORE);
|
||||
sins->mSrc[0].mTemp = andins->mDst.mTemp;
|
||||
sins->mSrc[0].mType = InterTypeOf(dec->mBase);
|
||||
sins->mSrc[1] = ains->mDst;
|
||||
sins->mNumOperands = 2;
|
||||
block->Append(sins);
|
||||
}
|
||||
dec = dec->mNext;
|
||||
}
|
||||
|
||||
if (lrexp)
|
||||
return *lrexp;
|
||||
|
||||
return ExValue(ftype->mBase, ttemp, 1);
|
||||
}
|
||||
else if (decResult)
|
||||
if (decResult)
|
||||
{
|
||||
if (lrexp)
|
||||
return *lrexp;
|
||||
|
|
@ -4527,8 +4354,6 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
|
|||
vins->mDst.mType = IT_POINTER;
|
||||
vins->mDst.mTemp = proc->AddTemporary(ins->mDst.mType);
|
||||
|
||||
bool reference = false;
|
||||
|
||||
Declaration* vdec = refvars[i];
|
||||
if (vdec->mType == DT_ARGUMENT)
|
||||
{
|
||||
|
|
@ -4562,28 +4387,18 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
|
|||
vins->mConst.mIntConst = vdec->mOffset;
|
||||
if (inlineMapper)
|
||||
vins->mConst.mVarIndex += inlineMapper->mVarIndex;
|
||||
|
||||
if (vdec->mBase->mType == DT_TYPE_ARRAY || vdec->mBase->mType == DT_TYPE_STRUCT)
|
||||
reference = true;
|
||||
}
|
||||
|
||||
block->Append(vins);
|
||||
|
||||
InterInstruction* lins;
|
||||
if (reference)
|
||||
lins = vins;
|
||||
else
|
||||
{
|
||||
lins = new InterInstruction(MapLocation(exp, inlineMapper), IC_LOAD);
|
||||
lins->mDst.mType = InterTypeOf(vdec->mBase);
|
||||
lins->mNumOperands = 1;
|
||||
InterInstruction* lins = new InterInstruction(MapLocation(exp, inlineMapper), IC_LOAD);
|
||||
lins->mSrc[0].mMemory = IM_INDIRECT;
|
||||
lins->mSrc[0].mType = IT_POINTER;
|
||||
lins->mSrc[0].mTemp = vins->mDst.mTemp;
|
||||
lins->mDst.mType = InterTypeOf(vdec->mBase);
|
||||
lins->mDst.mTemp = proc->AddTemporary(lins->mDst.mType);
|
||||
lins->mSrc[0].mOperandSize = vdec->mSize;
|
||||
block->Append(lins);
|
||||
}
|
||||
|
||||
if (jins->mNumOperands >= 32)
|
||||
mErrors->Error(exp->mLocation, EERR_ASSEMBLER_LIMIT, "Maximum number of variables in assembler block exceeded", vdec->mIdent);
|
||||
|
|
@ -4676,130 +4491,9 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
|
|||
ins->mNumOperands = 1;
|
||||
}
|
||||
}
|
||||
else if (!inlineMapper && procType->mBase->IsShortIntStruct())
|
||||
{
|
||||
vr = TranslateExpression(procType, proc, block, exp->mLeft, destack, gotos, breakBlock, continueBlock, inlineMapper);
|
||||
|
||||
if (vr.mType->IsReference())
|
||||
{
|
||||
vr.mReference++;
|
||||
vr.mType = vr.mType->mBase;
|
||||
}
|
||||
|
||||
vr = Dereference(proc, exp, block, inlineMapper, vr, 1);
|
||||
|
||||
if (!procType->mBase || procType->mBase->mType == DT_TYPE_VOID)
|
||||
mErrors->Error(exp->mLocation, EERR_INVALID_RETURN, "Function has void return type");
|
||||
else if (!procType->mBase->CanAssign(vr.mType))
|
||||
mErrors->Error(exp->mLocation, EERR_INVALID_RETURN, "Cannot return incompatible type");
|
||||
else if (vr.mReference != 1)
|
||||
mErrors->Error(exp->mLocation, EERR_INVALID_RETURN, "Non addressable object");
|
||||
|
||||
// Build marshalled struct into single long
|
||||
InterInstruction* pins = new InterInstruction(MapLocation(exp, inlineMapper), IC_CONSTANT);
|
||||
pins->mDst.mType = InterTypeOfSize(procType->mBase->mSize);
|
||||
pins->mDst.mTemp = proc->AddTemporary(pins->mDst.mType);
|
||||
pins->mConst.mType = pins->mDst.mType;
|
||||
pins->mConst.mIntConst = 0;
|
||||
block->Append(pins);
|
||||
|
||||
Declaration* dec = procType->mBase->mParams;
|
||||
while (dec)
|
||||
{
|
||||
if (dec->mType == DT_ELEMENT)
|
||||
{
|
||||
InterInstruction * oins = new InterInstruction(MapLocation(exp, inlineMapper), IC_CONSTANT);
|
||||
oins->mDst.mType = IT_INT16;
|
||||
oins->mDst.mTemp = proc->AddTemporary(IT_INT16);
|
||||
oins->mConst.mType = IT_INT16;
|
||||
oins->mConst.mIntConst = dec->mOffset;
|
||||
block->Append(oins);
|
||||
|
||||
InterInstruction * ains = new InterInstruction(MapLocation(exp, inlineMapper), IC_LEA);
|
||||
ains->mSrc[1].mMemory = IM_INDIRECT;
|
||||
ains->mSrc[1].mType = IT_POINTER;
|
||||
ains->mSrc[1].mTemp = vr.mTemp;
|
||||
ains->mSrc[0] = oins->mDst;
|
||||
ains->mDst.mType = IT_POINTER;
|
||||
ains->mDst.mMemory = IM_INDIRECT;
|
||||
ains->mDst.mTemp = proc->AddTemporary(IT_POINTER);
|
||||
ains->mDst.mOperandSize = dec->mSize;
|
||||
ains->mNumOperands = 2;
|
||||
block->Append(ains);
|
||||
|
||||
InterInstruction* lins = new InterInstruction(MapLocation(exp, inlineMapper), IC_LOAD);
|
||||
lins->mSrc[0] = ains->mDst;
|
||||
lins->mDst.mType = InterTypeOf(dec->mBase);
|
||||
lins->mDst.mTemp = proc->AddTemporary(lins->mDst.mType);
|
||||
lins->mNumOperands = 1;
|
||||
block->Append(lins);
|
||||
|
||||
if (pins->mDst.mType == IT_INT32)
|
||||
{
|
||||
if (dec->mSize < 4)
|
||||
{
|
||||
InterInstruction* xins = new InterInstruction(MapLocation(exp, inlineMapper), IC_CONVERSION_OPERATOR);
|
||||
xins->mOperator = dec->mSize == 1 ? IA_EXT8TO32U : IA_EXT16TO32U;
|
||||
xins->mSrc[0] = lins->mDst;
|
||||
xins->mDst.mType = InterTypeOf(dec->mBase);
|
||||
xins->mDst.mTemp = proc->AddTemporary(pins->mDst.mType);
|
||||
xins->mNumOperands = 1;
|
||||
block->Append(xins);
|
||||
lins = xins;
|
||||
}
|
||||
}
|
||||
else if (pins->mDst.mType == IT_INT16)
|
||||
{
|
||||
if (dec->mSize < 2)
|
||||
{
|
||||
InterInstruction* xins = new InterInstruction(MapLocation(exp, inlineMapper), IC_CONVERSION_OPERATOR);
|
||||
xins->mOperator = IA_EXT8TO16U;
|
||||
xins->mSrc[0] = lins->mDst;
|
||||
xins->mDst.mType = InterTypeOf(dec->mBase);
|
||||
xins->mDst.mTemp = proc->AddTemporary(pins->mDst.mType);
|
||||
xins->mNumOperands = 1;
|
||||
block->Append(xins);
|
||||
lins = xins;
|
||||
}
|
||||
}
|
||||
|
||||
InterInstruction* csins = new InterInstruction(MapLocation(exp, inlineMapper), IC_CONSTANT);
|
||||
csins->mDst.mType = IT_INT8;
|
||||
csins->mDst.mTemp = proc->AddTemporary(csins->mDst.mType);
|
||||
csins->mConst.mType = IT_INT8;
|
||||
csins->mConst.mIntConst = 8 * dec->mOffset;
|
||||
csins->mNumOperands = 0;
|
||||
block->Append(csins);
|
||||
|
||||
InterInstruction* sins = new InterInstruction(MapLocation(exp, inlineMapper), IC_BINARY_OPERATOR);
|
||||
sins->mOperator = IA_SHL;
|
||||
sins->mDst.mType = pins->mDst.mType;
|
||||
sins->mDst.mTemp = proc->AddTemporary(sins->mDst.mType);
|
||||
sins->mSrc[1] = lins->mDst;
|
||||
sins->mSrc[0] = csins->mDst;
|
||||
sins->mNumOperands = 2;
|
||||
block->Append(sins);
|
||||
|
||||
InterInstruction* orins = new InterInstruction(MapLocation(exp, inlineMapper), IC_BINARY_OPERATOR);
|
||||
orins->mOperator = IA_OR;
|
||||
orins->mDst.mType = pins->mDst.mType;
|
||||
orins->mDst.mTemp = proc->AddTemporary(orins->mDst.mType);
|
||||
orins->mSrc[0] = pins->mDst;
|
||||
orins->mSrc[1] = sins->mDst;
|
||||
orins->mNumOperands = 2;
|
||||
block->Append(orins);
|
||||
|
||||
pins = orins;
|
||||
}
|
||||
dec = dec->mNext;
|
||||
}
|
||||
|
||||
ins->mCode = IC_RETURN_VALUE;
|
||||
ins->mSrc[0] = pins->mDst;
|
||||
ins->mNumOperands = 1;
|
||||
}
|
||||
else if (procType->mBase->mType == DT_TYPE_STRUCT)
|
||||
{
|
||||
|
||||
InterInstruction* ains = new InterInstruction(MapLocation(exp, inlineMapper), IC_CONSTANT);
|
||||
|
||||
if (inlineMapper)
|
||||
|
|
@ -4869,6 +4563,101 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
|
|||
bool moving = exp->mLeft->IsRValue() || exp->mLeft->mType == EX_VARIABLE && !(exp->mLeft->mDecValue->mFlags & (DTF_STATIC | DTF_GLOBAL)) && exp->mLeft->mDecType->mType != DT_TYPE_REFERENCE;
|
||||
|
||||
CopyStruct(proc, exp, block, rvr, vr, inlineMapper, moving);
|
||||
#if 0
|
||||
if (procType->mBase->mCopyConstructor)
|
||||
{
|
||||
Declaration* ccdec = procType->mBase->mCopyConstructor;
|
||||
if (ccdec->mBase->mFlags & DTF_FASTCALL)
|
||||
{
|
||||
if (!ccdec->mLinkerObject)
|
||||
this->TranslateProcedure(proc->mModule, ccdec->mValue, ccdec);
|
||||
|
||||
InterInstruction* psins = new InterInstruction(MapLocation(exp, inlineMapper), IC_CONSTANT);
|
||||
psins->mDst.mType = IT_POINTER;
|
||||
psins->mDst.mTemp = proc->AddTemporary(IT_POINTER);
|
||||
psins->mConst.mVarIndex = 0;
|
||||
psins->mConst.mIntConst = 0;
|
||||
psins->mConst.mOperandSize = 2;
|
||||
if (procType->mFlags & DTF_FASTCALL)
|
||||
{
|
||||
psins->mConst.mMemory = IM_FPARAM;
|
||||
psins->mConst.mVarIndex += ccdec->mBase->mFastCallBase;
|
||||
}
|
||||
else
|
||||
psins->mConst.mMemory = IM_PARAM;
|
||||
block->Append(psins);
|
||||
|
||||
InterInstruction* ssins = new InterInstruction(MapLocation(exp, inlineMapper), IC_STORE);
|
||||
ssins->mSrc[0] = ains->mDst;
|
||||
ssins->mSrc[1] = psins->mDst;
|
||||
block->Append(ssins);
|
||||
|
||||
InterInstruction* plins = new InterInstruction(MapLocation(exp, inlineMapper), IC_CONSTANT);
|
||||
plins->mDst.mType = IT_POINTER;
|
||||
plins->mDst.mTemp = proc->AddTemporary(IT_POINTER);
|
||||
plins->mConst.mVarIndex = 2;
|
||||
plins->mConst.mIntConst = 0;
|
||||
plins->mConst.mOperandSize = 2;
|
||||
if (procType->mFlags & DTF_FASTCALL)
|
||||
{
|
||||
plins->mConst.mMemory = IM_FPARAM;
|
||||
plins->mConst.mVarIndex += ccdec->mBase->mFastCallBase;
|
||||
}
|
||||
else
|
||||
plins->mConst.mMemory = IM_PARAM;
|
||||
block->Append(plins);
|
||||
|
||||
InterInstruction* slins = new InterInstruction(MapLocation(exp, inlineMapper), IC_STORE);
|
||||
slins->mSrc[0].mType = IT_POINTER;
|
||||
slins->mSrc[0].mTemp = vr.mTemp;
|
||||
slins->mSrc[0].mMemory = IM_INDIRECT;
|
||||
slins->mSrc[0].mOperandSize = procType->mBase->mSize;
|
||||
slins->mSrc[0].mStride = vr.mType->mStripe;
|
||||
slins->mSrc[1] = plins->mDst;
|
||||
block->Append(slins);
|
||||
|
||||
proc->AddCalledFunction(proc->mModule->mProcedures[ccdec->mVarIndex]);
|
||||
|
||||
InterInstruction* pcins = new InterInstruction(MapLocation(exp, inlineMapper), IC_CONSTANT);
|
||||
pcins->mDst.mType = IT_POINTER;
|
||||
pcins->mDst.mTemp = proc->AddTemporary(IT_POINTER);
|
||||
pcins->mConst.mType = IT_POINTER;
|
||||
pcins->mConst.mVarIndex = ccdec->mVarIndex;
|
||||
pcins->mConst.mIntConst = 0;
|
||||
pcins->mConst.mOperandSize = 2;
|
||||
pcins->mConst.mMemory = IM_GLOBAL;
|
||||
pcins->mConst.mLinkerObject = ccdec->mLinkerObject;
|
||||
block->Append(pcins);
|
||||
|
||||
InterInstruction* cins = new InterInstruction(MapLocation(exp, inlineMapper), IC_CALL);
|
||||
if (ccdec->mFlags & DTF_NATIVE)
|
||||
cins->mCode = IC_CALL_NATIVE;
|
||||
else
|
||||
cins->mCode = IC_CALL;
|
||||
cins->mSrc[0] = pcins->mDst;
|
||||
cins->mNumOperands = 1;
|
||||
|
||||
block->Append(cins);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
InterInstruction* cins = new InterInstruction(MapLocation(exp, inlineMapper), IC_COPY);
|
||||
cins->mSrc[0].mType = IT_POINTER;
|
||||
cins->mSrc[0].mTemp = vr.mTemp;
|
||||
cins->mSrc[0].mMemory = IM_INDIRECT;
|
||||
cins->mSrc[0].mOperandSize = procType->mBase->mSize;
|
||||
cins->mSrc[0].mStride = vr.mType->mStripe;
|
||||
|
||||
cins->mSrc[1].mOperandSize = procType->mBase->mSize;
|
||||
cins->mSrc[1].mType = IT_POINTER;
|
||||
cins->mSrc[1].mTemp = ains->mDst.mTemp;
|
||||
cins->mSrc[1].mMemory = IM_INDIRECT;
|
||||
|
||||
cins->mConst.mOperandSize = procType->mBase->mSize;
|
||||
block->Append(cins);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -5176,32 +4965,13 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
|
|||
vl = TranslateExpression(procType, proc, tblock, exp->mRight->mLeft, destack, gotos, breakBlock, continueBlock, inlineMapper);
|
||||
vr = TranslateExpression(procType, proc, fblock, exp->mRight->mRight, destack, gotos, breakBlock, continueBlock, inlineMapper);
|
||||
|
||||
int ttemp, tref = 0;
|
||||
InterType ttype;
|
||||
|
||||
Declaration* dtype = exp->mDecType;
|
||||
|
||||
if (dtype->IsReference())
|
||||
{
|
||||
vl = Dereference(proc, exp, block, inlineMapper, vl, 1);
|
||||
vr = Dereference(proc, exp, block, inlineMapper, vr, 1);
|
||||
tref = 1;
|
||||
|
||||
dtype = dtype->mBase;
|
||||
ttype = IT_POINTER;
|
||||
}
|
||||
else
|
||||
{
|
||||
InterType stypel, styper;
|
||||
|
||||
if (vl.mType->IsReference())
|
||||
vl = ToValue(proc, exp, block, inlineMapper, vl);
|
||||
if (vr.mType->IsReference())
|
||||
vr = ToValue(proc, exp, block, inlineMapper, vr);
|
||||
int ttemp;
|
||||
InterType ttype, stypel, styper;
|
||||
|
||||
stypel = InterTypeOf(vl.mType);
|
||||
styper = InterTypeOf(vr.mType);
|
||||
|
||||
Declaration* dtype;
|
||||
if (stypel == IT_POINTER || styper == IT_POINTER)
|
||||
{
|
||||
if (vl.mType->mType == DT_TYPE_ARRAY)
|
||||
|
|
@ -5214,8 +4984,6 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
|
|||
else
|
||||
vr = Dereference(proc, exp, fblock, inlineMapper, vr);
|
||||
|
||||
if (vl.mType->mBase && vr.mType->mBase)
|
||||
{
|
||||
if (vl.mType->mBase->IsSubType(vr.mType->mBase))
|
||||
dtype = vr.mType;
|
||||
else if (vr.mType->mBase->IsSubType(vl.mType->mBase))
|
||||
|
|
@ -5225,12 +4993,6 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
|
|||
mErrors->Error(exp->mLocation, EERR_INCOMPATIBLE_OPERATOR, "Incompatible conditional types");
|
||||
dtype = vl.mType;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
mErrors->Error(exp->mLocation, EERR_INCOMPATIBLE_OPERATOR, "Incompatible conditional types");
|
||||
dtype = vl.mType;
|
||||
}
|
||||
|
||||
Declaration* ntype = new Declaration(dtype->mLocation, DT_TYPE_POINTER);
|
||||
ntype->mBase = dtype->mBase;
|
||||
|
|
@ -5263,7 +5025,6 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
|
|||
vl = CoerceType(proc, exp, tblock, inlineMapper, vl, dtype);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (ttype != IT_NONE)
|
||||
{
|
||||
|
|
@ -5313,7 +5074,7 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
|
|||
|
||||
block = eblock;
|
||||
|
||||
return ExValue(dtype, ttemp, tref);
|
||||
return ExValue(dtype, ttemp);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -5338,9 +5099,6 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
|
|||
|
||||
InterInstruction * ins = new InterInstruction(MapLocation(exp, inlineMapper), IC_CONVERSION_OPERATOR);
|
||||
|
||||
if (vr.mType->IsReference() && !exp->mDecType->IsReference())
|
||||
vr = ToValue(proc, exp, block, inlineMapper, vr);
|
||||
|
||||
if (exp->mDecType->mType == DT_TYPE_FLOAT && vr.mType->IsIntegerType())
|
||||
{
|
||||
vr = Dereference(proc, exp, block, inlineMapper, vr);
|
||||
|
|
@ -5637,37 +5395,6 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
|
|||
return ExValue(TheVoidTypeDeclaration);
|
||||
}
|
||||
|
||||
case EX_FORBODY:
|
||||
{
|
||||
DestructStack* odestack = destack;
|
||||
|
||||
InterInstruction* jins0 = new InterInstruction(MapLocation(exp, inlineMapper), IC_JUMP);
|
||||
InterInstruction* jins1 = new InterInstruction(MapLocation(exp, inlineMapper), IC_JUMP);
|
||||
|
||||
InterCodeBasicBlock* lblock = new InterCodeBasicBlock(proc);
|
||||
InterCodeBasicBlock* cblock = new InterCodeBasicBlock(proc);
|
||||
|
||||
block->Append(jins0);
|
||||
block->Close(lblock, nullptr);
|
||||
|
||||
DestructStack* idestack = destack;
|
||||
|
||||
vr = TranslateExpression(procType, proc, lblock, exp->mLeft, destack, gotos, breakBlock, BranchTarget(cblock, idestack), inlineMapper);
|
||||
|
||||
lblock->Append(jins1);
|
||||
lblock->Close(cblock, nullptr);
|
||||
|
||||
UnwindDestructStack(procType, proc, cblock, destack, idestack, inlineMapper);
|
||||
destack = idestack;
|
||||
|
||||
block = cblock;
|
||||
|
||||
exp = exp->mRight;
|
||||
if (!exp)
|
||||
return ExValue(TheVoidTypeDeclaration);
|
||||
|
||||
} break;
|
||||
|
||||
case EX_FOR:
|
||||
{
|
||||
DestructStack* odestack = destack;
|
||||
|
|
@ -5787,7 +5514,7 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
|
|||
}
|
||||
|
||||
case EX_AGGREGATE:
|
||||
mErrors->Error(exp->mLocation, EERR_INVALID_INITIALIZER, "Unexpected aggregate");
|
||||
mErrors->Error(exp->mLocation, EERR_INVALID_INITIALIZER, "Unexpected aggreate");
|
||||
return ExValue(TheVoidTypeDeclaration);
|
||||
|
||||
case EX_SWITCH:
|
||||
|
|
@ -6236,10 +5963,7 @@ InterCodeProcedure* InterCodeGenerator::TranslateProcedure(InterCodeModule * mod
|
|||
proc->mNativeProcedure = true;
|
||||
|
||||
if (dec->mFlags & DTF_INTERRUPT)
|
||||
{
|
||||
proc->mInterrupt = true;
|
||||
proc->mCompilerOptions &= ~COPT_OPTIMIZE_OUTLINE;
|
||||
}
|
||||
|
||||
if (dec->mFlags & DTF_HWINTERRUPT)
|
||||
proc->mHardwareInterrupt = true;
|
||||
|
|
@ -6312,12 +6036,7 @@ InterCodeProcedure* InterCodeGenerator::TranslateProcedure(InterCodeModule * mod
|
|||
else
|
||||
proc->mFastCallBase = BC_REG_FPARAMS_END - BC_REG_FPARAMS;
|
||||
|
||||
if (dec->mBase->mBase->IsShortIntStruct())
|
||||
{
|
||||
proc->mValueReturn = true;
|
||||
proc->mReturnType = IT_INT32;
|
||||
}
|
||||
else if (dec->mBase->mBase->mType != DT_TYPE_VOID && dec->mBase->mBase->mType != DT_TYPE_STRUCT)
|
||||
if (dec->mBase->mBase->mType != DT_TYPE_VOID && dec->mBase->mBase->mType != DT_TYPE_STRUCT)
|
||||
{
|
||||
proc->mValueReturn = true;
|
||||
proc->mReturnType = InterTypeOf(dec->mBase->mBase);
|
||||
|
|
@ -6393,7 +6112,7 @@ InterCodeProcedure* InterCodeGenerator::TranslateProcedure(InterCodeModule * mod
|
|||
}
|
||||
}
|
||||
else
|
||||
mErrors->Error(dec->mLocation, EERR_UNDEFINED_OBJECT, "Calling undefined function", dec->FullIdent());
|
||||
mErrors->Error(dec->mLocation, EERR_UNDEFINED_OBJECT, "Calling undefined function", dec->mQualIdent->mString);
|
||||
|
||||
if (strcmp(proc->mIdent->mString, "main"))
|
||||
{
|
||||
|
|
@ -6418,7 +6137,7 @@ InterCodeProcedure* InterCodeGenerator::TranslateProcedure(InterCodeModule * mod
|
|||
|
||||
void InterCodeGenerator::CompleteMainInit(void)
|
||||
{
|
||||
if (mErrors->mErrorCount == 0 && mMainInitBlock)
|
||||
if (mErrors->mErrorCount == 0)
|
||||
{
|
||||
InterInstruction* ins = new InterInstruction(mMainInitProc->mLocation, IC_JUMP);
|
||||
mMainInitBlock->Append(ins);
|
||||
|
|
|
|||
|
|
@ -94,12 +94,12 @@ protected:
|
|||
void BuildSwitchTree(InterCodeProcedure* proc, Expression* exp, InterCodeBasicBlock* block, InlineMapper * inlineMapper, ExValue v, const SwitchNodeArray& nodes, int left, int right, int vleft, int vright, InterCodeBasicBlock* dblock);
|
||||
|
||||
ExValue ToValue(InterCodeProcedure* proc, Expression* exp, InterCodeBasicBlock*& block, InlineMapper* inlineMapper, ExValue v);
|
||||
ExValue Dereference(InterCodeProcedure* proc, Expression* exp, InterCodeBasicBlock*& block, InlineMapper* inlineMapper, ExValue v, int level = 0, int limit = 0);
|
||||
ExValue Dereference(InterCodeProcedure* proc, Expression* exp, InterCodeBasicBlock*& block, InlineMapper* inlineMapper, ExValue v, int level = 0);
|
||||
ExValue CoerceType(InterCodeProcedure* proc, Expression* exp, InterCodeBasicBlock*& block, InlineMapper* inlineMapper, ExValue v, Declaration * type, bool checkTrunc = true);
|
||||
ExValue TranslateExpression(Declaration * procType, InterCodeProcedure * proc, InterCodeBasicBlock*& block, Expression* exp, DestructStack*& destack, GotoNode*& gotos, const BranchTarget & breakBlock, const BranchTarget& continueBlock, InlineMapper * inlineMapper, ExValue * lrexp = nullptr);
|
||||
void TranslateLogic(Declaration* procType, InterCodeProcedure* proc, InterCodeBasicBlock* block, InterCodeBasicBlock* tblock, InterCodeBasicBlock* fblock, Expression* exp, DestructStack*& destack, GotoNode*& gotos, InlineMapper* inlineMapper);
|
||||
ExValue TranslateInline(Declaration* procType, InterCodeProcedure* proc, InterCodeBasicBlock*& block, Expression* exp, const BranchTarget& breakBlock, const BranchTarget& continueBlock, InlineMapper* inlineMapper, bool inlineConstexpr, ExValue* lrexp);
|
||||
void CopyStruct (InterCodeProcedure* proc, Expression* exp, InterCodeBasicBlock*& block, ExValue vl, ExValue vr, InlineMapper* inlineMapper, bool moving);
|
||||
void CopyStruct(InterCodeProcedure* proc, Expression* exp, InterCodeBasicBlock*& block, ExValue vl, ExValue vr, InlineMapper* inlineMapper, bool moving);
|
||||
void CopyStructSimple(InterCodeProcedure* proc, Expression* exp, InterCodeBasicBlock * block, InlineMapper* inlineMapper, ExValue vl, ExValue vr);
|
||||
void StoreValue(InterCodeProcedure* proc, Expression* exp, InterCodeBasicBlock*& block, InlineMapper* inlineMapper, ExValue vl, ExValue vr);
|
||||
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ bool LinkerReference::operator!=(const LinkerReference& ref)
|
|||
}
|
||||
|
||||
LinkerObject::LinkerObject(void)
|
||||
: mReferences(nullptr), mNumTemporaries(0), mSize(0), mStripe(0), mAlignment(1), mStackSection(nullptr), mIdent(nullptr), mFullIdent(nullptr), mStartUsed(0x10000), mEndUsed(0x00000), mMemory(nullptr)
|
||||
: mReferences(nullptr), mNumTemporaries(0), mSize(0), mAlignment(1), mStackSection(nullptr), mIdent(nullptr), mFullIdent(nullptr), mStartUsed(0x10000), mEndUsed(0x00000), mMemory(nullptr)
|
||||
, mPrefix(nullptr), mSuffix(nullptr), mProc(nullptr), mNativeProc(nullptr)
|
||||
{}
|
||||
|
||||
|
|
@ -650,7 +650,7 @@ bool LinkerRegion::Allocate(Linker * linker, LinkerObject* lobj, bool merge, boo
|
|||
int start = (mFreeChunks[i].mStart + lobj->mAlignment - 1) & ~(lobj->mAlignment - 1);
|
||||
int end = start + lobj->mSize;
|
||||
|
||||
if (((lobj->mFlags & LOBJF_NEVER_CROSS) || !(linker->mCompilerOptions & COPT_OPTIMIZE_CODE_SIZE) && (lobj->mFlags & LOBJF_NO_CROSS) && !(lobj->mSection->mFlags & LSECF_PACKED)) && lobj->mSize <= 256 && (start & 0xff00) != ((end - 1) & 0xff00))
|
||||
if (!(linker->mCompilerOptions & COPT_OPTIMIZE_CODE_SIZE) && (lobj->mFlags & LOBJF_NO_CROSS) && lobj->mSize <= 256 && (start & 0xff00) != ((end - 1) & 0xff00) && !(lobj->mSection->mFlags & LSECF_PACKED))
|
||||
;
|
||||
else if (end <= mFreeChunks[i].mEnd)
|
||||
{
|
||||
|
|
@ -702,7 +702,7 @@ bool LinkerRegion::Allocate(Linker * linker, LinkerObject* lobj, bool merge, boo
|
|||
int start = (mStart + mUsed + lobj->mAlignment - 1) & ~(lobj->mAlignment - 1);
|
||||
int end = start + lobj->mSize;
|
||||
|
||||
if (((lobj->mFlags & LOBJF_NEVER_CROSS) || !(linker->mCompilerOptions & COPT_OPTIMIZE_CODE_SIZE) && !retry && (lobj->mFlags & LOBJF_NO_CROSS) && !(lobj->mSection->mFlags & LSECF_PACKED)) && !(lobj->mFlags & LOBJF_FORCE_ALIGN) && lobj->mSize <= 256 && (start & 0xff00) != ((end - 1) & 0xff00))
|
||||
if (!(linker->mCompilerOptions & COPT_OPTIMIZE_CODE_SIZE) && !retry && (lobj->mFlags & LOBJF_NO_CROSS) && !(lobj->mFlags & LOBJF_FORCE_ALIGN) && lobj->mSize <= 256 && (start & 0xff00) != ((end - 1) & 0xff00) && !(lobj->mSection->mFlags & LSECF_PACKED))
|
||||
{
|
||||
start = (start + 0x00ff) & 0xff00;
|
||||
end = start + lobj->mSize;
|
||||
|
|
@ -1903,8 +1903,6 @@ bool Linker::WriteDbjFile(FILE* file)
|
|||
return true;
|
||||
}
|
||||
|
||||
static const char hexchars[] = "0123456789abcdef";
|
||||
|
||||
bool Linker::WriteLblFile(const char* filename)
|
||||
{
|
||||
FILE* file;
|
||||
|
|
@ -1918,28 +1916,7 @@ bool Linker::WriteLblFile(const char* filename)
|
|||
if (obj->mFlags & LOBJF_REFERENCED)
|
||||
{
|
||||
if (obj->mIdent)
|
||||
{
|
||||
char buffer[400];
|
||||
char nbuffer[500];
|
||||
|
||||
strcpy_s(buffer, obj->mIdent->mString);
|
||||
int i = 0, j = 0;
|
||||
while (buffer[i])
|
||||
{
|
||||
if (buffer[i] >= '0' && buffer[i] <= '9' || buffer[i] >= 'a' && buffer[i] <= 'z' || buffer[i] >= 'A' && buffer[i] <= 'Z' || buffer[i] == '_' || buffer[i] == ':')
|
||||
nbuffer[j++] = buffer[i];
|
||||
else
|
||||
{
|
||||
nbuffer[j++] = '?';
|
||||
nbuffer[j++] = hexchars[(buffer[i] >> 4) & 0x0f];
|
||||
nbuffer[j++] = hexchars[buffer[i] & 0x0f];
|
||||
|
||||
}
|
||||
i++;
|
||||
}
|
||||
nbuffer[j] = 0;
|
||||
fprintf(file, "al %04x .%s\n", obj->mAddress, nbuffer);
|
||||
}
|
||||
fprintf(file, "al %04x .%s\n", obj->mAddress, obj->mIdent->mString);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -156,7 +156,6 @@ static const uint32 LOBJF_NO_CROSS = 0x00000080;
|
|||
static const uint32 LOBJF_ZEROPAGE = 0x00000100;
|
||||
static const uint32 LOBJF_FORCE_ALIGN = 0x00000200;
|
||||
static const uint32 LOBJF_ZEROPAGESET = 0x00000400;
|
||||
static const uint32 LOBJF_NEVER_CROSS = 0x00000800;
|
||||
|
||||
static const uint32 LOBJF_ARG_REG_A = 0x00001000;
|
||||
static const uint32 LOBJF_ARG_REG_X = 0x00002000;
|
||||
|
|
@ -164,7 +163,6 @@ static const uint32 LOBJF_ARG_REG_Y = 0x00004000;
|
|||
|
||||
static const uint32 LOBJF_RET_REG_A = 0x00010000;
|
||||
static const uint32 LOBJF_RET_REG_X = 0x00020000;
|
||||
static const uint32 LOBJF_RET_REG_Y = 0x00020000;
|
||||
|
||||
static const uint32 LOBJF_LOCAL_VAR = 0x00100000;
|
||||
static const uint32 LOBJF_LOCAL_USED = 0x00200000;
|
||||
|
|
@ -192,7 +190,7 @@ public:
|
|||
LinkerObjectType mType;
|
||||
int mID, mMapID;
|
||||
int mAddress, mRefAddress;
|
||||
int mSize, mAlignment, mStripe, mStartUsed, mEndUsed;
|
||||
int mSize, mAlignment, mStartUsed, mEndUsed;
|
||||
LinkerSection * mSection;
|
||||
LinkerRegion * mRegion;
|
||||
uint8 * mData, * mMemory;
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -135,23 +135,18 @@ static const uint32 NCIF_USE_CPU_REG_X = 0x00002000;
|
|||
static const uint32 NCIF_USE_CPU_REG_Y = 0x00004000;
|
||||
static const uint32 NCIF_USE_CPU_REG_C = 0x00008000;
|
||||
|
||||
static const uint32 NCIF_PROVIDE_CPU_REG_A = 0x00010000;
|
||||
static const uint32 NCIF_PROVIDE_CPU_REG_X = 0x00020000;
|
||||
static const uint32 NCIF_PROVIDE_CPU_REG_Y = 0x00040000;
|
||||
static const uint32 NCIF_PROVIDE_CPU_REG_C = 0x00080000;
|
||||
|
||||
// use a 32bit zero page register indexed by X for JSR
|
||||
static const uint32 NCIF_USE_ZP_32_X = 0x00100000;
|
||||
static const uint32 NICF_USE_ZP_ADDR = 0x00200000;
|
||||
static const uint32 NICF_USE_WORKREGS = 0x00400000;
|
||||
static const uint32 NCIF_USE_ZP_32_X = 0x00010000;
|
||||
static const uint32 NICF_USE_ZP_ADDR = 0x00020000;
|
||||
static const uint32 NICF_USE_WORKREGS = 0x00040000;
|
||||
|
||||
static const uint32 NCIF_BREAKPOINT = 0x00800000;
|
||||
static const uint32 NCIF_BREAKPOINT = 0x00080000;
|
||||
|
||||
class NativeCodeInstruction
|
||||
{
|
||||
public:
|
||||
NativeCodeInstruction(void);
|
||||
NativeCodeInstruction(const InterInstruction * ins, AsmInsType type, AsmInsMode mode = ASMIM_IMPLIED, int64 address = 0, LinkerObject * linkerObject = nullptr, uint32 flags = NCIF_LOWER | NCIF_UPPER, int param = 0, int minv = 0, int maxv = 255);
|
||||
NativeCodeInstruction(const InterInstruction * ins, AsmInsType type, AsmInsMode mode = ASMIM_IMPLIED, int64 address = 0, LinkerObject * linkerObject = nullptr, uint32 flags = NCIF_LOWER | NCIF_UPPER, int param = 0);
|
||||
NativeCodeInstruction(const InterInstruction* ins, AsmInsType type, const NativeCodeInstruction & addr);
|
||||
|
||||
AsmInsType mType;
|
||||
|
|
@ -162,13 +157,11 @@ public:
|
|||
uint32 mLive;
|
||||
LinkerObject * mLinkerObject;
|
||||
const InterInstruction * mIns;
|
||||
uint8 mMinVal, mMaxVal;
|
||||
|
||||
void Disassemble(FILE* file) const;
|
||||
void DisassembleAddress(FILE* file) const;
|
||||
|
||||
void CopyMode(const NativeCodeInstruction& ins);
|
||||
void CopyModeAndRange(const NativeCodeInstruction& ins);
|
||||
|
||||
void Assemble(NativeCodeBasicBlock* block);
|
||||
void FilterRegUsage(NumberSet& requiredTemps, NumberSet& providedTemps);
|
||||
|
|
@ -205,7 +198,6 @@ public:
|
|||
bool UsesZeroPage(int address) const;
|
||||
bool ReferencesZeroPage(int address) const;
|
||||
|
||||
bool SameLinkerObjectVariableRange(const NativeCodeInstruction& ins, bool sameXY = false) const;
|
||||
|
||||
bool ChangesGlobalMemory(void) const;
|
||||
bool UsesMemoryOf(const NativeCodeInstruction& ins) const;
|
||||
|
|
@ -267,7 +259,7 @@ public:
|
|||
ExpandingArray<NativeCodeBasicBlock*> mEntryBlocks;
|
||||
|
||||
int mOffset, mSize, mPlace, mNumEntries, mNumEntered, mFrameOffset, mTemp;
|
||||
bool mPlaced, mCopied, mKnownShortBranch, mBypassed, mAssembled, mNoFrame, mVisited, mLoopHead, mVisiting, mLocked, mPatched, mPatchFail, mPatchChecked, mPatchUsed, mPatchStart, mPatchLoop, mPatchLoopChanged, mPatchExit;
|
||||
bool mPlaced, mCopied, mKnownShortBranch, mBypassed, mAssembled, mNoFrame, mVisited, mLoopHead, mVisiting, mLocked, mPatched, mPatchFail, mPatchChecked, mPatchStart, mPatchLoop, mPatchLoopChanged, mPatchExit;
|
||||
bool mEntryRegA, mEntryRegX, mEntryRegY, mExitRegA, mExitRegX, mChecked;
|
||||
NativeCodeBasicBlock * mDominator, * mSameBlock;
|
||||
|
||||
|
|
@ -286,7 +278,6 @@ public:
|
|||
NativeCodeInstruction mALSIns, mXLSIns, mYLSIns;
|
||||
|
||||
void Disassemble(FILE* file);
|
||||
void DisassembleBody(FILE* file);
|
||||
|
||||
NativeCodeInstruction DecodeNative(const InterInstruction* ins, LinkerObject * lobj, int& offset) const;
|
||||
|
||||
|
|
@ -303,7 +294,6 @@ public:
|
|||
int LeadsInto(NativeCodeBasicBlock* block, int dist);
|
||||
NativeCodeBasicBlock* PlaceSequence(ExpandingArray<NativeCodeBasicBlock*>& placement, NativeCodeBasicBlock* block);
|
||||
void BuildPlacement(ExpandingArray<NativeCodeBasicBlock*>& placement);
|
||||
void OptimizePlacement(void);
|
||||
void InitialOffset(int& total);
|
||||
bool CalculateOffset(int& total, bool final);
|
||||
|
||||
|
|
@ -328,8 +318,6 @@ public:
|
|||
bool UsesZeroPage(int address, int from = 0, int to = 65536) const;
|
||||
bool ReferencesZeroPage(int address, int from = 0, int to = 65536) const;
|
||||
|
||||
bool ChangesMemory(const NativeCodeInstruction& ins, int from = 0, int to = 65536) const;
|
||||
bool ReferencesMemory(const NativeCodeInstruction& ins, int from = 0, int to = 65536) const;
|
||||
|
||||
bool RemoveNops(void);
|
||||
bool PeepHoleOptimizer(int pass);
|
||||
|
|
@ -348,7 +336,7 @@ public:
|
|||
bool PeepHoleOptimizerIterate(int pass);
|
||||
bool PeepHoleOptimizerExits(int pass);
|
||||
|
||||
void BlockSizeReduction(NativeCodeProcedure* proc, int xenter, int yenter, int center);
|
||||
void BlockSizeReduction(NativeCodeProcedure* proc, int xenter, int yenter);
|
||||
bool BlockSizeCopyReduction(NativeCodeProcedure* proc, int & si, int & di);
|
||||
|
||||
bool OptimizeSimpleLoopInvariant(NativeCodeProcedure* proc, bool full);
|
||||
|
|
@ -361,7 +349,6 @@ public:
|
|||
bool OptimizeSingleEntryLoop(NativeCodeProcedure* proc);
|
||||
|
||||
bool OptimizeSimpleLoop(NativeCodeProcedure* proc, bool full);
|
||||
bool OptimizeSimpleForLoop(void);
|
||||
bool SimpleLoopReversal(NativeCodeProcedure* proc);
|
||||
bool OptimizeInnerLoop(NativeCodeProcedure* proc, NativeCodeBasicBlock* head, NativeCodeBasicBlock* tail, ExpandingArray<NativeCodeBasicBlock*>& blocks);
|
||||
bool OptimizeXYSimpleLoop(void);
|
||||
|
|
@ -373,11 +360,9 @@ public:
|
|||
bool OptimizeInnerLoops(NativeCodeProcedure* proc);
|
||||
NativeCodeBasicBlock* CollectInnerLoop(NativeCodeBasicBlock* head, ExpandingArray<NativeCodeBasicBlock*>& lblocks);
|
||||
|
||||
int CorrectXOffset(const InterInstruction * ins, int yoffset, int at);
|
||||
int CorrectYOffset(const InterInstruction * ins, int yoffset, int at);
|
||||
bool OptimizeGenericLoop(void);
|
||||
bool CollectGenericLoop(ExpandingArray<NativeCodeBasicBlock*>& lblocks);
|
||||
bool CollectSingleEntryGenericLoop(ExpandingArray<NativeCodeBasicBlock*>& lblocks);
|
||||
bool OptimizeGenericLoop(NativeCodeProcedure* proc);
|
||||
bool CollectGenericLoop(NativeCodeProcedure* proc, ExpandingArray<NativeCodeBasicBlock*>& lblocks);
|
||||
bool CollectSingleEntryGenericLoop(NativeCodeProcedure* proc, ExpandingArray<NativeCodeBasicBlock*>& lblocks);
|
||||
void CollectReachable(ExpandingArray<NativeCodeBasicBlock*>& lblock);
|
||||
|
||||
bool OptimizeFindLoop(NativeCodeProcedure* proc);
|
||||
|
|
@ -411,7 +396,7 @@ public:
|
|||
NativeCodeBasicBlock* BinaryOperator(InterCodeProcedure* proc, NativeCodeProcedure* nproc, const InterInstruction * ins, const InterInstruction* sins1, const InterInstruction* sins0);
|
||||
void UnaryOperator(InterCodeProcedure* proc, NativeCodeProcedure* nproc, const InterInstruction * ins);
|
||||
void RelationalOperator(InterCodeProcedure* proc, const InterInstruction * ins, NativeCodeProcedure * nproc, NativeCodeBasicBlock* trueJump, NativeCodeBasicBlock * falseJump);
|
||||
void LoadEffectiveAddress(InterCodeProcedure* proc, const InterInstruction * ins, const InterInstruction* sins1, const InterInstruction* sins0, bool addrvalid, bool addrused = false);
|
||||
void LoadEffectiveAddress(InterCodeProcedure* proc, const InterInstruction * ins, const InterInstruction* sins1, const InterInstruction* sins0, bool addrvalid);
|
||||
void LoadStoreOpAbsolute2D(InterCodeProcedure* proc, const InterInstruction* lins1, const InterInstruction* lins2, const InterInstruction* mins);
|
||||
void SignExtendAddImmediate(InterCodeProcedure* proc, const InterInstruction* xins, const InterInstruction* ains);
|
||||
void BinaryDivModPair(InterCodeProcedure* proc, NativeCodeProcedure* nproc, const InterInstruction* ins1, const InterInstruction* ins2);
|
||||
|
|
@ -428,7 +413,6 @@ public:
|
|||
|
||||
void LoadByteIndexedValue(InterCodeProcedure* proc, const InterInstruction* iins, const InterInstruction* rins);
|
||||
void StoreByteIndexedValue(InterCodeProcedure* proc, const InterInstruction* iins, const InterInstruction* rins);
|
||||
void CopyByteIndexedValue(InterCodeProcedure* proc, const InterInstruction* riins, const InterInstruction* wiins, const InterInstruction* rins, const InterInstruction* wins);
|
||||
|
||||
void CallAssembler(InterCodeProcedure* proc, NativeCodeProcedure* nproc, const InterInstruction * ins);
|
||||
void CallFunction(InterCodeProcedure* proc, NativeCodeProcedure* nproc, const InterInstruction * ins);
|
||||
|
|
@ -465,6 +449,8 @@ public:
|
|||
bool MergeBasicBlocks(void);
|
||||
bool RemoveJumpToBranch(void);
|
||||
|
||||
void MarkLoopHead(void);
|
||||
|
||||
struct DominatorStacks
|
||||
{
|
||||
ExpandingArray< NativeCodeBasicBlock* > d1, d2;
|
||||
|
|
@ -539,7 +525,6 @@ public:
|
|||
bool MoveTXADCDown(int at);
|
||||
bool MoveTXALogicTAXDown(int at);
|
||||
bool FoldShiftORAIntoLoadImmUp(int at);
|
||||
bool ReverseShiftByteOrder(int at);
|
||||
|
||||
bool FindAccuExitValue(int& at);
|
||||
bool MoveLoadXAbsUpCrossBlock(int at);
|
||||
|
|
@ -573,7 +558,6 @@ public:
|
|||
bool CombineSameYtoX(int xpos, int ypos, int end);
|
||||
|
||||
bool FindImmediateStore(int at, int reg, const NativeCodeInstruction*& ains);
|
||||
int FindImmediateGlobalStore(int at, const NativeCodeInstruction& ins);
|
||||
|
||||
bool JoinXYCrossBlock(void);
|
||||
bool CanCombineSameXtoYCrossBlock(int from);
|
||||
|
|
@ -610,9 +594,6 @@ public:
|
|||
bool OffsetValueForwarding(const ValueNumberingDataSet & data);
|
||||
bool AbsoluteValueForwarding(const ExpandingArray<NativeCodeLoadStorePair>& npairs);
|
||||
bool IndexXYValueForwarding(int xreg, int xoffset, int xvalue, int yreg, int yoffset, int yvalue);
|
||||
bool ReduceIndexXYZeroShuffle(NativeCodeBasicBlock* from, int xreg, int yreg);
|
||||
bool CheckLoopIndexXRegisters(NativeCodeBasicBlock* head, int xreg);
|
||||
bool CheckLoopIndexYRegisters(NativeCodeBasicBlock* head, int yreg);
|
||||
|
||||
void MarkLocalUsedLinkerObjects(void);
|
||||
bool RemoveLocalUnusedLinkerObjects(void);
|
||||
|
|
@ -636,8 +617,6 @@ public:
|
|||
bool HasTailSTXInto(int& addr, int& index, NativeCodeBasicBlock* tblock) const;
|
||||
bool HasTailSTYInto(int& addr, int& index, NativeCodeBasicBlock* tblock) const;
|
||||
|
||||
bool HasTailSTAGlobal(NativeCodeInstruction & ins, int& index) const;
|
||||
|
||||
bool MayBeMovedBeforeBlock(int at);
|
||||
bool MayBeMovedBeforeBlock(int at, const NativeCodeInstruction & ins);
|
||||
bool MayBeMovedBeforeBlock(int start, int end);
|
||||
|
|
@ -803,20 +782,10 @@ public:
|
|||
bool CheckPatchFailUse(void);
|
||||
|
||||
bool CheckPatchFailLoop(const NativeCodeBasicBlock* block, const NativeCodeBasicBlock* head, int reg, bool changed);
|
||||
bool CheckPatchFailLoopPair(const NativeCodeBasicBlock* block, const NativeCodeBasicBlock* head, int reg, bool changed);
|
||||
|
||||
bool JoinSameBranch(NativeCodeBasicBlock* block);
|
||||
bool MergeSameBranch(void);
|
||||
|
||||
bool CheckBoolBitPropagation(const NativeCodeBasicBlock* block, int at, int reg);
|
||||
bool PatchBoolBitPropagation(const NativeCodeBasicBlock* block, int at, int reg);
|
||||
|
||||
bool CollectRegBoolInstructionsForward(int reg, ExpandingArray<NativeCodeBasicBlock*>& cblocks, ExpandingArray<NativeCodeInstruction*>& lins);
|
||||
bool CollectRegBoolInstructionsBackward(int reg, ExpandingArray<NativeCodeBasicBlock*>& cblocks, ExpandingArray<NativeCodeInstruction*>& lins);
|
||||
|
||||
bool CollectCheckRegOriginBlocks(int at, int reg, ExpandingArray<NativeCodeBasicBlock*>& lblocks, ExpandingArray<NativeCodeInstruction*>& lins);
|
||||
bool PatchBitBoolConstOrigin(void);
|
||||
|
||||
// reg : base register pair to replace
|
||||
// index: index register
|
||||
// at : start position in block
|
||||
|
|
@ -826,20 +795,9 @@ public:
|
|||
bool CheckGlobalAddressSumYPointer(const NativeCodeBasicBlock * block, int reg, int index, int at, int yval);
|
||||
bool PatchGlobalAddressSumYPointer(const NativeCodeBasicBlock* block, int reg, int index, int at, int yval, LinkerObject * lobj, int address, uint32 flags = NCIF_LOWER | NCIF_UPPER);
|
||||
|
||||
// reg : register to replace
|
||||
// at : start position in block
|
||||
// ains : instruction loading original data
|
||||
// cycles : max number of cycles saving
|
||||
bool CheckSingleUseGlobalLoad(const NativeCodeBasicBlock* block, int reg, int at, const NativeCodeInstruction& ains, int cycles);
|
||||
bool PatchSingleUseGlobalLoad(const NativeCodeBasicBlock* block, int reg, int at, const NativeCodeInstruction& ains);
|
||||
|
||||
// rins : instruction storing the data
|
||||
// at : start position in block
|
||||
// ains : instruction loading original data
|
||||
// cycles : max number of cycles saving
|
||||
bool CheckSingleUseGlobalLoadStruct(const NativeCodeBasicBlock* block, const NativeCodeInstruction& rins, int at, const NativeCodeInstruction& ains, bool cleared, bool poisoned);
|
||||
bool PatchSingleUseGlobalLoadStruct(const NativeCodeBasicBlock* block, const NativeCodeInstruction& rins, int at, const NativeCodeInstruction& ains);
|
||||
|
||||
// reg : base register pair to replace
|
||||
// base: new base register
|
||||
// iins : indexing instruction
|
||||
|
|
|
|||
1896
oscar64/Parser.cpp
1896
oscar64/Parser.cpp
File diff suppressed because it is too large
Load Diff
|
|
@ -11,7 +11,6 @@ public:
|
|||
~Parser(void);
|
||||
|
||||
Parser* Clone(void);
|
||||
Parser * mParent;
|
||||
|
||||
DeclarationScope * mGlobals, * mScope, * mTemplateScope, * mCaptureScope;
|
||||
int mLocalIndex;
|
||||
|
|
@ -25,8 +24,6 @@ public:
|
|||
uint64 mCompilerOptionStack[32];
|
||||
int mCompilerOptionSP;
|
||||
|
||||
Location FullLocation(const Location& loc);
|
||||
|
||||
void Parse(void);
|
||||
protected:
|
||||
bool ExpectToken(Token token);
|
||||
|
|
@ -80,7 +77,6 @@ protected:
|
|||
Expression* DefaultInitExpression(Expression* vexp);
|
||||
Expression* ParseVarInitExpression(Expression* lexp, bool inner = false);
|
||||
Expression* CloneVarInitExpression(Expression* vexp, Expression* iexp, Expression * qexp);
|
||||
Expression* CopyElision(Expression* vexp, Expression* rexp);
|
||||
|
||||
Declaration* ParsePostfixDeclaration(void);
|
||||
Declaration* ReverseDeclaration(Declaration* odec, Declaration* bdec);
|
||||
|
|
@ -137,10 +133,7 @@ protected:
|
|||
|
||||
Declaration* ParseTypeID(bool tid, Declaration * bdec = nullptr);
|
||||
|
||||
Expression* ParseConstruction(Declaration* type);
|
||||
|
||||
Expression* ParseCastExpression(Expression* exp);
|
||||
Expression* ParseIdentExpression(const Location & eloc, Declaration* dec, bool lhs, bool tid = false);
|
||||
Expression* ParseSimpleExpression(bool lhs, bool tid = false);
|
||||
Expression* ParsePrefixExpression(bool lhs);
|
||||
Expression* ParsePostfixExpression(bool lhs);
|
||||
|
|
@ -162,7 +155,6 @@ protected:
|
|||
Expression* ParseListExpression(bool lhs, Declaration * params = nullptr);
|
||||
|
||||
Expression* ParseParenthesisExpression(void);
|
||||
void ParseStaticAssert(void);
|
||||
|
||||
Errors* mErrors;
|
||||
Scanner* mScanner;
|
||||
|
|
|
|||
|
|
@ -327,16 +327,6 @@ struct CTMHeader9
|
|||
uint8 mColors[7];
|
||||
};
|
||||
|
||||
struct CTTHeader9
|
||||
{
|
||||
uint8 mDispMode;
|
||||
uint8 mColorMethod;
|
||||
uint8 mFlags;
|
||||
uint8 mFgridWidth[2], mFGridHeight[2];
|
||||
char mFGridConfig;
|
||||
uint8 mColors[6];
|
||||
};
|
||||
|
||||
#if 0
|
||||
#pragma pack(push, 1)
|
||||
struct SPDHeader5
|
||||
|
|
@ -496,7 +486,6 @@ void SourceFile::ReadCharPad(Errors* errors, const Location& location, SourceFil
|
|||
CTMHeader ctmHeader;
|
||||
CTMHeader8 ctmHeader8;
|
||||
CTMHeader9 ctmHeader9;
|
||||
CTTHeader9 cttHeader9;
|
||||
uint16 ctmMarker, numChars, numTiles;
|
||||
char tileWidth, tileHeight;
|
||||
|
||||
|
|
@ -507,20 +496,10 @@ void SourceFile::ReadCharPad(Errors* errors, const Location& location, SourceFil
|
|||
fread(&ctmHeader8, sizeof(CTMHeader8), 1, mFile);
|
||||
break;
|
||||
case 9:
|
||||
if (ctmHeader.mID[2] == 'T')
|
||||
{
|
||||
fread(&cttHeader9, sizeof(CTTHeader9), 1, mFile);
|
||||
ctmHeader8.mDispMode = cttHeader9.mDispMode;
|
||||
ctmHeader8.mColorMethod = cttHeader9.mColorMethod;
|
||||
ctmHeader8.mFlags = cttHeader9.mFlags;
|
||||
}
|
||||
else
|
||||
{
|
||||
fread(&ctmHeader9, sizeof(CTMHeader9), 1, mFile);
|
||||
ctmHeader8.mDispMode = ctmHeader9.mDispMode;
|
||||
ctmHeader8.mColorMethod = ctmHeader9.mColorMethod;
|
||||
ctmHeader8.mFlags = ctmHeader9.mFlags;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -51,7 +51,6 @@ const char* TokenNames[] =
|
|||
"'extern'",
|
||||
"'inline'",
|
||||
"'__assume'",
|
||||
"'static_assert'",
|
||||
|
||||
"__asm",
|
||||
"__interrupt",
|
||||
|
|
@ -822,8 +821,6 @@ void Scanner::NextPreToken(void)
|
|||
}
|
||||
}
|
||||
else if (mToken == TK_PREP_IDENT)
|
||||
{
|
||||
if (mTokenIdent->mString[0])
|
||||
{
|
||||
Macro* def = nullptr;
|
||||
if (mDefineArguments)
|
||||
|
|
@ -848,12 +845,6 @@ void Scanner::NextPreToken(void)
|
|||
else
|
||||
mErrors->Error(mLocation, EERR_INVALID_PREPROCESSOR, "Invalid preprocessor command", mTokenIdent);
|
||||
}
|
||||
else
|
||||
{
|
||||
mToken = TK_HASH;
|
||||
return;
|
||||
}
|
||||
}
|
||||
else if (mToken == TK_PREP_UNDEF)
|
||||
{
|
||||
NextRawToken();
|
||||
|
|
@ -1125,15 +1116,14 @@ void Scanner::NextPreToken(void)
|
|||
while (mTokenChar == ' ')
|
||||
NextChar();
|
||||
|
||||
if (mTokenChar == '#' && mLine[mOffset] == '#')
|
||||
while (mTokenChar == '#' && mLine[mOffset] == '#')
|
||||
{
|
||||
char tkbase[256];
|
||||
strcpy_s(tkbase, mTokenIdent->mString);
|
||||
|
||||
do {
|
||||
mOffset++;
|
||||
NextChar();
|
||||
|
||||
char tkbase[256];
|
||||
strcpy_s(tkbase, mTokenIdent->mString);
|
||||
|
||||
ptrdiff_t n = 0;
|
||||
char tkident[256];
|
||||
while (IsIdentChar(mTokenChar))
|
||||
|
|
@ -1162,32 +1152,9 @@ void Scanner::NextPreToken(void)
|
|||
n--;
|
||||
tkbase[n] = 0;
|
||||
|
||||
while (mTokenChar == ' ')
|
||||
NextChar();
|
||||
|
||||
} while (mTokenChar == '#' && mLine[mOffset] == '#');
|
||||
|
||||
ptrdiff_t n = strlen(tkbase);
|
||||
char* str = new char[n + 1];
|
||||
strcpy_s(str, n + 1, tkbase);
|
||||
|
||||
MacroExpansion* ex = new MacroExpansion();
|
||||
ex->mDefinedArguments = mDefineArguments;
|
||||
|
||||
ex->mLine = mLine;
|
||||
ex->mOffset = mOffset;
|
||||
ex->mLink = mMacroExpansion;
|
||||
ex->mChar = mTokenChar;
|
||||
|
||||
mMacroExpansion = ex;
|
||||
mMacroExpansionDepth++;
|
||||
if (mMacroExpansionDepth > 1024)
|
||||
mErrors->Error(mLocation, EFATAL_MACRO_EXPANSION_DEPTH, "Maximum macro expansion depth exceeded", mTokenIdent);
|
||||
mLine = str;
|
||||
mOffset = 0;
|
||||
NextChar();
|
||||
mTokenIdent = Ident::Unique(tkbase);
|
||||
}
|
||||
else
|
||||
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
|
@ -1833,8 +1800,6 @@ void Scanner::NextRawToken(void)
|
|||
mToken = TK_ASM;
|
||||
else if (!strcmp(tkident, "__assume"))
|
||||
mToken = TK_ASSUME;
|
||||
else if (!strcmp(tkident, "static_assert"))
|
||||
mToken = TK_STATIC_ASSERT;
|
||||
else if (!strcmp(tkident, "__interrupt"))
|
||||
mToken = TK_INTERRUPT;
|
||||
else if (!strcmp(tkident, "__hwinterrupt"))
|
||||
|
|
@ -2014,7 +1979,7 @@ void Scanner::NextRawToken(void)
|
|||
|
||||
default:
|
||||
// dirty little hack to implement token preview, got to fix
|
||||
// this with an infinite preview sequence at one point
|
||||
// this with an infinit preview sequence at one point
|
||||
mUngetToken = mToken;
|
||||
mToken = TK_OPERATOR;
|
||||
return;
|
||||
|
|
|
|||
|
|
@ -49,7 +49,6 @@ enum Token
|
|||
TK_EXTERN,
|
||||
TK_INLINE,
|
||||
TK_ASSUME,
|
||||
TK_STATIC_ASSERT,
|
||||
|
||||
TK_ASM,
|
||||
TK_INTERRUPT,
|
||||
|
|
|
|||
|
|
@ -76,7 +76,7 @@ int main2(int argc, const char** argv)
|
|||
|
||||
#else
|
||||
strcpy(strProductName, "oscar64");
|
||||
strcpy(strProductVersion, "1.31.261");
|
||||
strcpy(strProductVersion, "1.31.259");
|
||||
|
||||
#ifdef __APPLE__
|
||||
uint32_t length = sizeof(basePath);
|
||||
|
|
@ -111,12 +111,38 @@ int main2(int argc, const char** argv)
|
|||
GrowingArray<const char*> dataFiles(nullptr);
|
||||
GrowingArray<bool> dataFileCompressed(false);
|
||||
|
||||
bool emulate = false, profile = false, customCRT = false;
|
||||
int trace = 0;
|
||||
|
||||
compiler->mPreprocessor->AddPath(basePath);
|
||||
strcpy_s(includePath, basePath);
|
||||
strcat_s(includePath, "include");
|
||||
{
|
||||
FILE* crtFile;
|
||||
char crtFileNamePath[FILENAME_MAX];
|
||||
crtFileNamePath[FILENAME_MAX - 1] = '\0';
|
||||
strcpy_s(crtFileNamePath, basePath);
|
||||
strcat_s(crtFileNamePath, "include/crt.h");
|
||||
|
||||
if (!fopen_s(&crtFile, crtFileNamePath, "r"))
|
||||
strcat_s(includePath, "include/");
|
||||
else
|
||||
{
|
||||
strcpy_s(crtFileNamePath, basePath);
|
||||
strcat_s(crtFileNamePath, "include/oscar64/crt.h");
|
||||
|
||||
if (!fopen_s(&crtFile, crtFileNamePath, "r"))
|
||||
strcat_s(includePath, "include/oscar64/");
|
||||
else
|
||||
{
|
||||
printf("Could not locate Oscar64 includes under %s\n", basePath);
|
||||
return 20;
|
||||
}
|
||||
}
|
||||
fclose(crtFile);
|
||||
}
|
||||
compiler->mPreprocessor->AddPath(includePath);
|
||||
strcpy_s(crtPath, includePath);
|
||||
strcat_s(crtPath, "crt.c");
|
||||
|
||||
bool emulate = false, profile = false;
|
||||
int trace = 0;
|
||||
|
||||
targetPath[0] = 0;
|
||||
diskPath[0] = 0;
|
||||
|
|
@ -159,10 +185,6 @@ int main2(int argc, const char** argv)
|
|||
{
|
||||
compiler->mPreprocessor->AddPath(arg + 3);
|
||||
}
|
||||
else if (arg[1] == 'i' && arg[2] == 'i' && arg[3] == '=')
|
||||
{
|
||||
strcpy_s(includePath, arg + 4);
|
||||
}
|
||||
else if (arg[1] == 'f' && arg[2] == '=')
|
||||
{
|
||||
dataFiles.Push(arg + 3);
|
||||
|
|
@ -184,7 +206,6 @@ int main2(int argc, const char** argv)
|
|||
else if (arg[1] == 'r' && arg[2] == 't' && arg[3] == '=')
|
||||
{
|
||||
strcpy_s(crtPath, arg + 4);
|
||||
customCRT = true;
|
||||
}
|
||||
else if (arg[1] == 'd' && arg[2] == '6' && arg[3] == '4' && arg[4] == '=')
|
||||
{
|
||||
|
|
@ -232,8 +253,6 @@ int main2(int argc, const char** argv)
|
|||
compiler->mCompilerOptions |= COPT_OPTIMIZE_ASSEMBLER;
|
||||
else if (arg[2] == 'i' && !arg[3])
|
||||
compiler->mCompilerOptions |= COPT_OPTIMIZE_AUTO_INLINE;
|
||||
else if (arg[2] == 'i' && arg[3] == 'i' && !arg[4])
|
||||
compiler->mCompilerOptions |= COPT_OPTIMIZE_AUTO_INLINE | COPT_OPTIMIZE_AUTO_INLINE_ALL;
|
||||
else if (arg[2] == 'z' && !arg[3])
|
||||
compiler->mCompilerOptions |= COPT_OPTIMIZE_AUTO_ZEROPAGE;
|
||||
else if (arg[2] == 'p' && !arg[3])
|
||||
|
|
@ -244,8 +263,6 @@ int main2(int argc, const char** argv)
|
|||
compiler->mCompilerOptions |= COPT_OPTIMIZE_MERGE_CALLS;
|
||||
else if (arg[2] == 'o' && !arg[3])
|
||||
compiler->mCompilerOptions |= COPT_OPTIMIZE_OUTLINE;
|
||||
else if (arg[2] == 'x' && !arg[3])
|
||||
compiler->mCompilerOptions |= COPT_OPTIMIZE_PAGE_CROSSING;
|
||||
else
|
||||
compiler->mErrors->Error(loc, EERR_COMMAND_LINE, "Invalid command line argument", arg);
|
||||
}
|
||||
|
|
@ -427,12 +444,6 @@ int main2(int argc, const char** argv)
|
|||
compiler->mTargetMachine = TMACH_PLUS4;
|
||||
compiler->AddDefine(Ident::Unique("__PLUS4__"), "1");
|
||||
}
|
||||
else if (!strcmp(targetMachine, "mega65"))
|
||||
{
|
||||
strcpy_s(basicStart, "0x2001");
|
||||
compiler->mTargetMachine = TMACH_MEGA65;
|
||||
compiler->AddDefine(Ident::Unique("__MEGA65__"), "1");
|
||||
}
|
||||
else if (!strcmp(targetMachine, "x16"))
|
||||
{
|
||||
strcpy_s(basicStart, "0x0801");
|
||||
|
|
@ -557,35 +568,6 @@ int main2(int argc, const char** argv)
|
|||
|
||||
// Add runtime module
|
||||
|
||||
compiler->mPreprocessor->AddPath(includePath);
|
||||
|
||||
if (!customCRT)
|
||||
{
|
||||
FILE* crtFile;
|
||||
char crtFileNamePath[FILENAME_MAX];
|
||||
crtFileNamePath[FILENAME_MAX - 1] = '\0';
|
||||
strcpy_s(crtFileNamePath, includePath);
|
||||
strcat_s(crtFileNamePath, "/crt.h");
|
||||
|
||||
if (fopen_s(&crtFile, crtFileNamePath, "r"))
|
||||
{
|
||||
strcpy_s(crtFileNamePath, basePath);
|
||||
strcat_s(crtFileNamePath, "include/oscar64/crt.h");
|
||||
|
||||
if (!fopen_s(&crtFile, crtFileNamePath, "r"))
|
||||
strcat_s(includePath, "include/oscar64/");
|
||||
else
|
||||
{
|
||||
printf("Could not locate Oscar64 includes under %s\n", basePath);
|
||||
return 20;
|
||||
}
|
||||
}
|
||||
fclose(crtFile);
|
||||
|
||||
strcpy_s(crtPath, includePath);
|
||||
strcat_s(crtPath, "/crt.c");
|
||||
}
|
||||
|
||||
if (crtPath[0])
|
||||
compiler->mCompilationUnits->AddUnit(loc, crtPath, nullptr);
|
||||
|
||||
|
|
|
|||
|
|
@ -25,8 +25,8 @@ LANGUAGE LANG_ENGLISH, SUBLANG_NEUTRAL
|
|||
//
|
||||
|
||||
VS_VERSION_INFO VERSIONINFO
|
||||
FILEVERSION 1,31,261,0
|
||||
PRODUCTVERSION 1,31,261,0
|
||||
FILEVERSION 1,31,259,0
|
||||
PRODUCTVERSION 1,31,259,0
|
||||
FILEFLAGSMASK 0x3fL
|
||||
#ifdef _DEBUG
|
||||
FILEFLAGS 0x1L
|
||||
|
|
@ -43,12 +43,12 @@ BEGIN
|
|||
BEGIN
|
||||
VALUE "CompanyName", "oscar64"
|
||||
VALUE "FileDescription", "oscar64 compiler"
|
||||
VALUE "FileVersion", "1.31.261.0"
|
||||
VALUE "FileVersion", "1.31.259.0"
|
||||
VALUE "InternalName", "oscar64.exe"
|
||||
VALUE "LegalCopyright", "Copyright (C) 2021"
|
||||
VALUE "OriginalFilename", "oscar64.exe"
|
||||
VALUE "ProductName", "oscar64"
|
||||
VALUE "ProductVersion", "1.31.261.0"
|
||||
VALUE "ProductVersion", "1.31.259.0"
|
||||
END
|
||||
END
|
||||
BLOCK "VarFileInfo"
|
||||
|
|
|
|||
|
|
@ -34,12 +34,6 @@
|
|||
}
|
||||
"Entry"
|
||||
{
|
||||
"MsmKey" = "8:_03D7013B0D39A89CEA9D267005ADCE39"
|
||||
"OwnerKey" = "8:_FB2E467BC172457785F4279BB0BFE8B6"
|
||||
"MsmSig" = "8:_UNDEFINED"
|
||||
}
|
||||
"Entry"
|
||||
{
|
||||
"MsmKey" = "8:_04ABABC55200450383686DD782DD1548"
|
||||
"OwnerKey" = "8:_UNDEFINED"
|
||||
"MsmSig" = "8:_UNDEFINED"
|
||||
|
|
@ -400,12 +394,6 @@
|
|||
}
|
||||
"Entry"
|
||||
{
|
||||
"MsmKey" = "8:_4B482689C546CDFC92F367BA507E7ADE"
|
||||
"OwnerKey" = "8:_FB2E467BC172457785F4279BB0BFE8B6"
|
||||
"MsmSig" = "8:_UNDEFINED"
|
||||
}
|
||||
"Entry"
|
||||
{
|
||||
"MsmKey" = "8:_4B8FC526E6CC47FC8321D0191BFDBEDC"
|
||||
"OwnerKey" = "8:_UNDEFINED"
|
||||
"MsmSig" = "8:_UNDEFINED"
|
||||
|
|
@ -424,12 +412,6 @@
|
|||
}
|
||||
"Entry"
|
||||
{
|
||||
"MsmKey" = "8:_4E94486A43C1D1C032A05ED1E6F1FCEF"
|
||||
"OwnerKey" = "8:_FB2E467BC172457785F4279BB0BFE8B6"
|
||||
"MsmSig" = "8:_UNDEFINED"
|
||||
}
|
||||
"Entry"
|
||||
{
|
||||
"MsmKey" = "8:_4E9503F4F8F343739E4685C2066B3AD0"
|
||||
"OwnerKey" = "8:_UNDEFINED"
|
||||
"MsmSig" = "8:_UNDEFINED"
|
||||
|
|
@ -526,12 +508,6 @@
|
|||
}
|
||||
"Entry"
|
||||
{
|
||||
"MsmKey" = "8:_65687B00DD49EEBBFFECE831614822A9"
|
||||
"OwnerKey" = "8:_FB2E467BC172457785F4279BB0BFE8B6"
|
||||
"MsmSig" = "8:_UNDEFINED"
|
||||
}
|
||||
"Entry"
|
||||
{
|
||||
"MsmKey" = "8:_67C8F824E02B4211B315AB32AB7ABBB1"
|
||||
"OwnerKey" = "8:_UNDEFINED"
|
||||
"MsmSig" = "8:_UNDEFINED"
|
||||
|
|
@ -760,14 +736,14 @@
|
|||
}
|
||||
"Entry"
|
||||
{
|
||||
"MsmKey" = "8:_9B2E1BB3CD154CEFB214378A64B0B00C"
|
||||
"OwnerKey" = "8:_UNDEFINED"
|
||||
"MsmKey" = "8:_98B942589E984AAD381F87F18DDB79D3"
|
||||
"OwnerKey" = "8:_FB2E467BC172457785F4279BB0BFE8B6"
|
||||
"MsmSig" = "8:_UNDEFINED"
|
||||
}
|
||||
"Entry"
|
||||
{
|
||||
"MsmKey" = "8:_9CA4DFBA483A862FBF3DAEDE506D7DBD"
|
||||
"OwnerKey" = "8:_FB2E467BC172457785F4279BB0BFE8B6"
|
||||
"MsmKey" = "8:_9B2E1BB3CD154CEFB214378A64B0B00C"
|
||||
"OwnerKey" = "8:_UNDEFINED"
|
||||
"MsmSig" = "8:_UNDEFINED"
|
||||
}
|
||||
"Entry"
|
||||
|
|
@ -796,14 +772,14 @@
|
|||
}
|
||||
"Entry"
|
||||
{
|
||||
"MsmKey" = "8:_A1455504C259EDA9662CE90C07369CC5"
|
||||
"OwnerKey" = "8:_FB2E467BC172457785F4279BB0BFE8B6"
|
||||
"MsmKey" = "8:_A14BC161099E420286E6A1595596D0F0"
|
||||
"OwnerKey" = "8:_UNDEFINED"
|
||||
"MsmSig" = "8:_UNDEFINED"
|
||||
}
|
||||
"Entry"
|
||||
{
|
||||
"MsmKey" = "8:_A14BC161099E420286E6A1595596D0F0"
|
||||
"OwnerKey" = "8:_UNDEFINED"
|
||||
"MsmKey" = "8:_A16BC2645A14DC0435B7119153B32DE8"
|
||||
"OwnerKey" = "8:_FB2E467BC172457785F4279BB0BFE8B6"
|
||||
"MsmSig" = "8:_UNDEFINED"
|
||||
}
|
||||
"Entry"
|
||||
|
|
@ -826,12 +802,6 @@
|
|||
}
|
||||
"Entry"
|
||||
{
|
||||
"MsmKey" = "8:_A2F68033370E18CD792ECD1F91357C1B"
|
||||
"OwnerKey" = "8:_FB2E467BC172457785F4279BB0BFE8B6"
|
||||
"MsmSig" = "8:_UNDEFINED"
|
||||
}
|
||||
"Entry"
|
||||
{
|
||||
"MsmKey" = "8:_A32310DEFD4E41118CD7D36A8614C0D4"
|
||||
"OwnerKey" = "8:_UNDEFINED"
|
||||
"MsmSig" = "8:_UNDEFINED"
|
||||
|
|
@ -886,12 +856,6 @@
|
|||
}
|
||||
"Entry"
|
||||
{
|
||||
"MsmKey" = "8:_AD3AED76152E705799261747B7FD2015"
|
||||
"OwnerKey" = "8:_FB2E467BC172457785F4279BB0BFE8B6"
|
||||
"MsmSig" = "8:_UNDEFINED"
|
||||
}
|
||||
"Entry"
|
||||
{
|
||||
"MsmKey" = "8:_AE023AEA6C444140B19CD627DDC2CB87"
|
||||
"OwnerKey" = "8:_UNDEFINED"
|
||||
"MsmSig" = "8:_UNDEFINED"
|
||||
|
|
@ -940,6 +904,12 @@
|
|||
}
|
||||
"Entry"
|
||||
{
|
||||
"MsmKey" = "8:_B61CD152136A6E3CE5FF69D29E7A3F7B"
|
||||
"OwnerKey" = "8:_FB2E467BC172457785F4279BB0BFE8B6"
|
||||
"MsmSig" = "8:_UNDEFINED"
|
||||
}
|
||||
"Entry"
|
||||
{
|
||||
"MsmKey" = "8:_B85448D515F0487FB6845119AE346F1D"
|
||||
"OwnerKey" = "8:_UNDEFINED"
|
||||
"MsmSig" = "8:_UNDEFINED"
|
||||
|
|
@ -982,12 +952,6 @@
|
|||
}
|
||||
"Entry"
|
||||
{
|
||||
"MsmKey" = "8:_C0E88FBB7B883ED27FFB3C60DBE114B8"
|
||||
"OwnerKey" = "8:_FB2E467BC172457785F4279BB0BFE8B6"
|
||||
"MsmSig" = "8:_UNDEFINED"
|
||||
}
|
||||
"Entry"
|
||||
{
|
||||
"MsmKey" = "8:_C239EFB1C3A646809AD2740ABDE747B0"
|
||||
"OwnerKey" = "8:_UNDEFINED"
|
||||
"MsmSig" = "8:_UNDEFINED"
|
||||
|
|
@ -1084,18 +1048,6 @@
|
|||
}
|
||||
"Entry"
|
||||
{
|
||||
"MsmKey" = "8:_D04F8D80984DFA3EA342FE8FA1B7CC91"
|
||||
"OwnerKey" = "8:_FB2E467BC172457785F4279BB0BFE8B6"
|
||||
"MsmSig" = "8:_UNDEFINED"
|
||||
}
|
||||
"Entry"
|
||||
{
|
||||
"MsmKey" = "8:_D057B4CD935875ECE7F0A91620660D07"
|
||||
"OwnerKey" = "8:_FB2E467BC172457785F4279BB0BFE8B6"
|
||||
"MsmSig" = "8:_UNDEFINED"
|
||||
}
|
||||
"Entry"
|
||||
{
|
||||
"MsmKey" = "8:_D0E45B48D76B4407B0BDE4378C1DB2C7"
|
||||
"OwnerKey" = "8:_UNDEFINED"
|
||||
"MsmSig" = "8:_UNDEFINED"
|
||||
|
|
@ -1517,26 +1469,6 @@
|
|||
"IsDependency" = "11:FALSE"
|
||||
"IsolateTo" = "8:"
|
||||
}
|
||||
"{1FB2D0AE-D3B9-43D4-B9DD-F88EC61E35DE}:_03D7013B0D39A89CEA9D267005ADCE39"
|
||||
{
|
||||
"SourcePath" = "8:VCRUNTIME140.dll"
|
||||
"TargetName" = "8:VCRUNTIME140.dll"
|
||||
"Tag" = "8:"
|
||||
"Folder" = "8:_607E75AF0E2A4CB9908C4C39DF8FE6E4"
|
||||
"Condition" = "8:"
|
||||
"Transitive" = "11:FALSE"
|
||||
"Vital" = "11:TRUE"
|
||||
"ReadOnly" = "11:FALSE"
|
||||
"Hidden" = "11:FALSE"
|
||||
"System" = "11:FALSE"
|
||||
"Permanent" = "11:FALSE"
|
||||
"SharedLegacy" = "11:FALSE"
|
||||
"PackageAs" = "3:1"
|
||||
"Register" = "3:1"
|
||||
"Exclude" = "11:FALSE"
|
||||
"IsDependency" = "11:TRUE"
|
||||
"IsolateTo" = "8:"
|
||||
}
|
||||
"{1FB2D0AE-D3B9-43D4-B9DD-F88EC61E35DE}:_04ABABC55200450383686DD782DD1548"
|
||||
{
|
||||
"SourcePath" = "8:..\\samples\\games\\lander.c"
|
||||
|
|
@ -2737,26 +2669,6 @@
|
|||
"IsDependency" = "11:FALSE"
|
||||
"IsolateTo" = "8:"
|
||||
}
|
||||
"{1FB2D0AE-D3B9-43D4-B9DD-F88EC61E35DE}:_4B482689C546CDFC92F367BA507E7ADE"
|
||||
{
|
||||
"SourcePath" = "8:api-ms-win-crt-runtime-l1-1-0.dll"
|
||||
"TargetName" = "8:api-ms-win-crt-runtime-l1-1-0.dll"
|
||||
"Tag" = "8:"
|
||||
"Folder" = "8:_607E75AF0E2A4CB9908C4C39DF8FE6E4"
|
||||
"Condition" = "8:"
|
||||
"Transitive" = "11:FALSE"
|
||||
"Vital" = "11:TRUE"
|
||||
"ReadOnly" = "11:FALSE"
|
||||
"Hidden" = "11:FALSE"
|
||||
"System" = "11:FALSE"
|
||||
"Permanent" = "11:FALSE"
|
||||
"SharedLegacy" = "11:FALSE"
|
||||
"PackageAs" = "3:1"
|
||||
"Register" = "3:1"
|
||||
"Exclude" = "11:FALSE"
|
||||
"IsDependency" = "11:TRUE"
|
||||
"IsolateTo" = "8:"
|
||||
}
|
||||
"{1FB2D0AE-D3B9-43D4-B9DD-F88EC61E35DE}:_4B8FC526E6CC47FC8321D0191BFDBEDC"
|
||||
{
|
||||
"SourcePath" = "8:..\\samples\\resources\\scifiglyph.bin"
|
||||
|
|
@ -2817,26 +2729,6 @@
|
|||
"IsDependency" = "11:FALSE"
|
||||
"IsolateTo" = "8:"
|
||||
}
|
||||
"{1FB2D0AE-D3B9-43D4-B9DD-F88EC61E35DE}:_4E94486A43C1D1C032A05ED1E6F1FCEF"
|
||||
{
|
||||
"SourcePath" = "8:api-ms-win-crt-locale-l1-1-0.dll"
|
||||
"TargetName" = "8:api-ms-win-crt-locale-l1-1-0.dll"
|
||||
"Tag" = "8:"
|
||||
"Folder" = "8:_607E75AF0E2A4CB9908C4C39DF8FE6E4"
|
||||
"Condition" = "8:"
|
||||
"Transitive" = "11:FALSE"
|
||||
"Vital" = "11:TRUE"
|
||||
"ReadOnly" = "11:FALSE"
|
||||
"Hidden" = "11:FALSE"
|
||||
"System" = "11:FALSE"
|
||||
"Permanent" = "11:FALSE"
|
||||
"SharedLegacy" = "11:FALSE"
|
||||
"PackageAs" = "3:1"
|
||||
"Register" = "3:1"
|
||||
"Exclude" = "11:FALSE"
|
||||
"IsDependency" = "11:TRUE"
|
||||
"IsolateTo" = "8:"
|
||||
}
|
||||
"{1FB2D0AE-D3B9-43D4-B9DD-F88EC61E35DE}:_4E9503F4F8F343739E4685C2066B3AD0"
|
||||
{
|
||||
"SourcePath" = "8:..\\include\\plus4\\ted.c"
|
||||
|
|
@ -3157,26 +3049,6 @@
|
|||
"IsDependency" = "11:FALSE"
|
||||
"IsolateTo" = "8:"
|
||||
}
|
||||
"{1FB2D0AE-D3B9-43D4-B9DD-F88EC61E35DE}:_65687B00DD49EEBBFFECE831614822A9"
|
||||
{
|
||||
"SourcePath" = "8:api-ms-win-crt-stdio-l1-1-0.dll"
|
||||
"TargetName" = "8:api-ms-win-crt-stdio-l1-1-0.dll"
|
||||
"Tag" = "8:"
|
||||
"Folder" = "8:_607E75AF0E2A4CB9908C4C39DF8FE6E4"
|
||||
"Condition" = "8:"
|
||||
"Transitive" = "11:FALSE"
|
||||
"Vital" = "11:TRUE"
|
||||
"ReadOnly" = "11:FALSE"
|
||||
"Hidden" = "11:FALSE"
|
||||
"System" = "11:FALSE"
|
||||
"Permanent" = "11:FALSE"
|
||||
"SharedLegacy" = "11:FALSE"
|
||||
"PackageAs" = "3:1"
|
||||
"Register" = "3:1"
|
||||
"Exclude" = "11:FALSE"
|
||||
"IsDependency" = "11:TRUE"
|
||||
"IsolateTo" = "8:"
|
||||
}
|
||||
"{1FB2D0AE-D3B9-43D4-B9DD-F88EC61E35DE}:_67C8F824E02B4211B315AB32AB7ABBB1"
|
||||
{
|
||||
"SourcePath" = "8:..\\samples\\games\\breakout.c"
|
||||
|
|
@ -3937,6 +3809,26 @@
|
|||
"IsDependency" = "11:FALSE"
|
||||
"IsolateTo" = "8:"
|
||||
}
|
||||
"{1FB2D0AE-D3B9-43D4-B9DD-F88EC61E35DE}:_98B942589E984AAD381F87F18DDB79D3"
|
||||
{
|
||||
"SourcePath" = "8:ucrtbased.dll"
|
||||
"TargetName" = "8:ucrtbased.dll"
|
||||
"Tag" = "8:"
|
||||
"Folder" = "8:_607E75AF0E2A4CB9908C4C39DF8FE6E4"
|
||||
"Condition" = "8:"
|
||||
"Transitive" = "11:FALSE"
|
||||
"Vital" = "11:TRUE"
|
||||
"ReadOnly" = "11:FALSE"
|
||||
"Hidden" = "11:FALSE"
|
||||
"System" = "11:FALSE"
|
||||
"Permanent" = "11:FALSE"
|
||||
"SharedLegacy" = "11:FALSE"
|
||||
"PackageAs" = "3:1"
|
||||
"Register" = "3:1"
|
||||
"Exclude" = "11:FALSE"
|
||||
"IsDependency" = "11:TRUE"
|
||||
"IsolateTo" = "8:"
|
||||
}
|
||||
"{1FB2D0AE-D3B9-43D4-B9DD-F88EC61E35DE}:_9B2E1BB3CD154CEFB214378A64B0B00C"
|
||||
{
|
||||
"SourcePath" = "8:..\\include\\plus4\\ted.h"
|
||||
|
|
@ -3957,26 +3849,6 @@
|
|||
"IsDependency" = "11:FALSE"
|
||||
"IsolateTo" = "8:"
|
||||
}
|
||||
"{1FB2D0AE-D3B9-43D4-B9DD-F88EC61E35DE}:_9CA4DFBA483A862FBF3DAEDE506D7DBD"
|
||||
{
|
||||
"SourcePath" = "8:VCRUNTIME140_1.dll"
|
||||
"TargetName" = "8:VCRUNTIME140_1.dll"
|
||||
"Tag" = "8:"
|
||||
"Folder" = "8:_607E75AF0E2A4CB9908C4C39DF8FE6E4"
|
||||
"Condition" = "8:"
|
||||
"Transitive" = "11:FALSE"
|
||||
"Vital" = "11:TRUE"
|
||||
"ReadOnly" = "11:FALSE"
|
||||
"Hidden" = "11:FALSE"
|
||||
"System" = "11:FALSE"
|
||||
"Permanent" = "11:FALSE"
|
||||
"SharedLegacy" = "11:FALSE"
|
||||
"PackageAs" = "3:1"
|
||||
"Register" = "3:1"
|
||||
"Exclude" = "11:FALSE"
|
||||
"IsDependency" = "11:TRUE"
|
||||
"IsolateTo" = "8:"
|
||||
}
|
||||
"{1FB2D0AE-D3B9-43D4-B9DD-F88EC61E35DE}:_9D0D7A63D6C848CD85489D6E7C43AFAD"
|
||||
{
|
||||
"SourcePath" = "8:..\\include\\stdio.h"
|
||||
|
|
@ -4057,26 +3929,6 @@
|
|||
"IsDependency" = "11:FALSE"
|
||||
"IsolateTo" = "8:"
|
||||
}
|
||||
"{1FB2D0AE-D3B9-43D4-B9DD-F88EC61E35DE}:_A1455504C259EDA9662CE90C07369CC5"
|
||||
{
|
||||
"SourcePath" = "8:api-ms-win-crt-time-l1-1-0.dll"
|
||||
"TargetName" = "8:api-ms-win-crt-time-l1-1-0.dll"
|
||||
"Tag" = "8:"
|
||||
"Folder" = "8:_607E75AF0E2A4CB9908C4C39DF8FE6E4"
|
||||
"Condition" = "8:"
|
||||
"Transitive" = "11:FALSE"
|
||||
"Vital" = "11:TRUE"
|
||||
"ReadOnly" = "11:FALSE"
|
||||
"Hidden" = "11:FALSE"
|
||||
"System" = "11:FALSE"
|
||||
"Permanent" = "11:FALSE"
|
||||
"SharedLegacy" = "11:FALSE"
|
||||
"PackageAs" = "3:1"
|
||||
"Register" = "3:1"
|
||||
"Exclude" = "11:FALSE"
|
||||
"IsDependency" = "11:TRUE"
|
||||
"IsolateTo" = "8:"
|
||||
}
|
||||
"{1FB2D0AE-D3B9-43D4-B9DD-F88EC61E35DE}:_A14BC161099E420286E6A1595596D0F0"
|
||||
{
|
||||
"SourcePath" = "8:..\\include\\opp\\ofstream.h"
|
||||
|
|
@ -4097,6 +3949,26 @@
|
|||
"IsDependency" = "11:FALSE"
|
||||
"IsolateTo" = "8:"
|
||||
}
|
||||
"{1FB2D0AE-D3B9-43D4-B9DD-F88EC61E35DE}:_A16BC2645A14DC0435B7119153B32DE8"
|
||||
{
|
||||
"SourcePath" = "8:VCRUNTIME140D.dll"
|
||||
"TargetName" = "8:VCRUNTIME140D.dll"
|
||||
"Tag" = "8:"
|
||||
"Folder" = "8:_607E75AF0E2A4CB9908C4C39DF8FE6E4"
|
||||
"Condition" = "8:"
|
||||
"Transitive" = "11:FALSE"
|
||||
"Vital" = "11:TRUE"
|
||||
"ReadOnly" = "11:FALSE"
|
||||
"Hidden" = "11:FALSE"
|
||||
"System" = "11:FALSE"
|
||||
"Permanent" = "11:FALSE"
|
||||
"SharedLegacy" = "11:FALSE"
|
||||
"PackageAs" = "3:1"
|
||||
"Register" = "3:1"
|
||||
"Exclude" = "11:FALSE"
|
||||
"IsDependency" = "11:TRUE"
|
||||
"IsolateTo" = "8:"
|
||||
}
|
||||
"{1FB2D0AE-D3B9-43D4-B9DD-F88EC61E35DE}:_A18504BA88CE40128ED44BD1854F0A33"
|
||||
{
|
||||
"SourcePath" = "8:..\\samples\\memmap\\easyflashreloc.c"
|
||||
|
|
@ -4157,26 +4029,6 @@
|
|||
"IsDependency" = "11:FALSE"
|
||||
"IsolateTo" = "8:"
|
||||
}
|
||||
"{1FB2D0AE-D3B9-43D4-B9DD-F88EC61E35DE}:_A2F68033370E18CD792ECD1F91357C1B"
|
||||
{
|
||||
"SourcePath" = "8:api-ms-win-crt-filesystem-l1-1-0.dll"
|
||||
"TargetName" = "8:api-ms-win-crt-filesystem-l1-1-0.dll"
|
||||
"Tag" = "8:"
|
||||
"Folder" = "8:_607E75AF0E2A4CB9908C4C39DF8FE6E4"
|
||||
"Condition" = "8:"
|
||||
"Transitive" = "11:FALSE"
|
||||
"Vital" = "11:TRUE"
|
||||
"ReadOnly" = "11:FALSE"
|
||||
"Hidden" = "11:FALSE"
|
||||
"System" = "11:FALSE"
|
||||
"Permanent" = "11:FALSE"
|
||||
"SharedLegacy" = "11:FALSE"
|
||||
"PackageAs" = "3:1"
|
||||
"Register" = "3:1"
|
||||
"Exclude" = "11:FALSE"
|
||||
"IsDependency" = "11:TRUE"
|
||||
"IsolateTo" = "8:"
|
||||
}
|
||||
"{1FB2D0AE-D3B9-43D4-B9DD-F88EC61E35DE}:_A32310DEFD4E41118CD7D36A8614C0D4"
|
||||
{
|
||||
"SourcePath" = "8:..\\include\\limits.h"
|
||||
|
|
@ -4357,26 +4209,6 @@
|
|||
"IsDependency" = "11:FALSE"
|
||||
"IsolateTo" = "8:"
|
||||
}
|
||||
"{1FB2D0AE-D3B9-43D4-B9DD-F88EC61E35DE}:_AD3AED76152E705799261747B7FD2015"
|
||||
{
|
||||
"SourcePath" = "8:api-ms-win-crt-math-l1-1-0.dll"
|
||||
"TargetName" = "8:api-ms-win-crt-math-l1-1-0.dll"
|
||||
"Tag" = "8:"
|
||||
"Folder" = "8:_607E75AF0E2A4CB9908C4C39DF8FE6E4"
|
||||
"Condition" = "8:"
|
||||
"Transitive" = "11:FALSE"
|
||||
"Vital" = "11:TRUE"
|
||||
"ReadOnly" = "11:FALSE"
|
||||
"Hidden" = "11:FALSE"
|
||||
"System" = "11:FALSE"
|
||||
"Permanent" = "11:FALSE"
|
||||
"SharedLegacy" = "11:FALSE"
|
||||
"PackageAs" = "3:1"
|
||||
"Register" = "3:1"
|
||||
"Exclude" = "11:FALSE"
|
||||
"IsDependency" = "11:TRUE"
|
||||
"IsolateTo" = "8:"
|
||||
}
|
||||
"{1FB2D0AE-D3B9-43D4-B9DD-F88EC61E35DE}:_AE023AEA6C444140B19CD627DDC2CB87"
|
||||
{
|
||||
"SourcePath" = "8:..\\include\\cx16\\vera.h"
|
||||
|
|
@ -4537,6 +4369,26 @@
|
|||
"IsDependency" = "11:FALSE"
|
||||
"IsolateTo" = "8:"
|
||||
}
|
||||
"{1FB2D0AE-D3B9-43D4-B9DD-F88EC61E35DE}:_B61CD152136A6E3CE5FF69D29E7A3F7B"
|
||||
{
|
||||
"SourcePath" = "8:VCRUNTIME140_1D.dll"
|
||||
"TargetName" = "8:VCRUNTIME140_1D.dll"
|
||||
"Tag" = "8:"
|
||||
"Folder" = "8:_607E75AF0E2A4CB9908C4C39DF8FE6E4"
|
||||
"Condition" = "8:"
|
||||
"Transitive" = "11:FALSE"
|
||||
"Vital" = "11:TRUE"
|
||||
"ReadOnly" = "11:FALSE"
|
||||
"Hidden" = "11:FALSE"
|
||||
"System" = "11:FALSE"
|
||||
"Permanent" = "11:FALSE"
|
||||
"SharedLegacy" = "11:FALSE"
|
||||
"PackageAs" = "3:1"
|
||||
"Register" = "3:1"
|
||||
"Exclude" = "11:FALSE"
|
||||
"IsDependency" = "11:TRUE"
|
||||
"IsolateTo" = "8:"
|
||||
}
|
||||
"{1FB2D0AE-D3B9-43D4-B9DD-F88EC61E35DE}:_B85448D515F0487FB6845119AE346F1D"
|
||||
{
|
||||
"SourcePath" = "8:..\\samples\\resources\\landersprites.bin"
|
||||
|
|
@ -4677,26 +4529,6 @@
|
|||
"IsDependency" = "11:FALSE"
|
||||
"IsolateTo" = "8:"
|
||||
}
|
||||
"{1FB2D0AE-D3B9-43D4-B9DD-F88EC61E35DE}:_C0E88FBB7B883ED27FFB3C60DBE114B8"
|
||||
{
|
||||
"SourcePath" = "8:api-ms-win-crt-string-l1-1-0.dll"
|
||||
"TargetName" = "8:api-ms-win-crt-string-l1-1-0.dll"
|
||||
"Tag" = "8:"
|
||||
"Folder" = "8:_607E75AF0E2A4CB9908C4C39DF8FE6E4"
|
||||
"Condition" = "8:"
|
||||
"Transitive" = "11:FALSE"
|
||||
"Vital" = "11:TRUE"
|
||||
"ReadOnly" = "11:FALSE"
|
||||
"Hidden" = "11:FALSE"
|
||||
"System" = "11:FALSE"
|
||||
"Permanent" = "11:FALSE"
|
||||
"SharedLegacy" = "11:FALSE"
|
||||
"PackageAs" = "3:1"
|
||||
"Register" = "3:1"
|
||||
"Exclude" = "11:FALSE"
|
||||
"IsDependency" = "11:TRUE"
|
||||
"IsolateTo" = "8:"
|
||||
}
|
||||
"{1FB2D0AE-D3B9-43D4-B9DD-F88EC61E35DE}:_C239EFB1C3A646809AD2740ABDE747B0"
|
||||
{
|
||||
"SourcePath" = "8:..\\include\\c64\\types.h"
|
||||
|
|
@ -5017,46 +4849,6 @@
|
|||
"IsDependency" = "11:FALSE"
|
||||
"IsolateTo" = "8:"
|
||||
}
|
||||
"{1FB2D0AE-D3B9-43D4-B9DD-F88EC61E35DE}:_D04F8D80984DFA3EA342FE8FA1B7CC91"
|
||||
{
|
||||
"SourcePath" = "8:api-ms-win-crt-heap-l1-1-0.dll"
|
||||
"TargetName" = "8:api-ms-win-crt-heap-l1-1-0.dll"
|
||||
"Tag" = "8:"
|
||||
"Folder" = "8:_607E75AF0E2A4CB9908C4C39DF8FE6E4"
|
||||
"Condition" = "8:"
|
||||
"Transitive" = "11:FALSE"
|
||||
"Vital" = "11:TRUE"
|
||||
"ReadOnly" = "11:FALSE"
|
||||
"Hidden" = "11:FALSE"
|
||||
"System" = "11:FALSE"
|
||||
"Permanent" = "11:FALSE"
|
||||
"SharedLegacy" = "11:FALSE"
|
||||
"PackageAs" = "3:1"
|
||||
"Register" = "3:1"
|
||||
"Exclude" = "11:FALSE"
|
||||
"IsDependency" = "11:TRUE"
|
||||
"IsolateTo" = "8:"
|
||||
}
|
||||
"{1FB2D0AE-D3B9-43D4-B9DD-F88EC61E35DE}:_D057B4CD935875ECE7F0A91620660D07"
|
||||
{
|
||||
"SourcePath" = "8:api-ms-win-crt-convert-l1-1-0.dll"
|
||||
"TargetName" = "8:api-ms-win-crt-convert-l1-1-0.dll"
|
||||
"Tag" = "8:"
|
||||
"Folder" = "8:_607E75AF0E2A4CB9908C4C39DF8FE6E4"
|
||||
"Condition" = "8:"
|
||||
"Transitive" = "11:FALSE"
|
||||
"Vital" = "11:TRUE"
|
||||
"ReadOnly" = "11:FALSE"
|
||||
"Hidden" = "11:FALSE"
|
||||
"System" = "11:FALSE"
|
||||
"Permanent" = "11:FALSE"
|
||||
"SharedLegacy" = "11:FALSE"
|
||||
"PackageAs" = "3:1"
|
||||
"Register" = "3:1"
|
||||
"Exclude" = "11:FALSE"
|
||||
"IsDependency" = "11:TRUE"
|
||||
"IsolateTo" = "8:"
|
||||
}
|
||||
"{1FB2D0AE-D3B9-43D4-B9DD-F88EC61E35DE}:_D0E45B48D76B4407B0BDE4378C1DB2C7"
|
||||
{
|
||||
"SourcePath" = "8:..\\include\\stdlib.h"
|
||||
|
|
@ -6310,15 +6102,15 @@
|
|||
{
|
||||
"Name" = "8:Microsoft Visual Studio"
|
||||
"ProductName" = "8:oscar64"
|
||||
"ProductCode" = "8:{1B9A0E10-DEA6-4276-AC91-17782FE44D94}"
|
||||
"PackageCode" = "8:{51BFE576-50D1-4F8F-AE7A-9FF07396F53D}"
|
||||
"ProductCode" = "8:{26C4BC0B-097A-4E5B-B403-8E947803667A}"
|
||||
"PackageCode" = "8:{0C803CC6-29F2-44B4-91D3-62724E5BC165}"
|
||||
"UpgradeCode" = "8:{9AB61EFF-ACAC-4079-9950-8D96615CD4EF}"
|
||||
"AspNetVersion" = "8:2.0.50727.0"
|
||||
"RestartWWWService" = "11:FALSE"
|
||||
"RemovePreviousVersions" = "11:TRUE"
|
||||
"DetectNewerInstalledVersion" = "11:TRUE"
|
||||
"InstallAllUsers" = "11:FALSE"
|
||||
"ProductVersion" = "8:1.31.261"
|
||||
"ProductVersion" = "8:1.31.259"
|
||||
"Manufacturer" = "8:oscar64"
|
||||
"ARPHELPTELEPHONE" = "8:"
|
||||
"ARPHELPLINK" = "8:"
|
||||
|
|
@ -6832,7 +6624,7 @@
|
|||
{
|
||||
"{5259A561-127C-4D43-A0A1-72F10C7B3BF8}:_FB2E467BC172457785F4279BB0BFE8B6"
|
||||
{
|
||||
"SourcePath" = "8:..\\Releasex64\\oscar64.exe"
|
||||
"SourcePath" = "8:..\\Debugx64\\oscar64.exe"
|
||||
"TargetName" = "8:"
|
||||
"Tag" = "8:"
|
||||
"Folder" = "8:_607E75AF0E2A4CB9908C4C39DF8FE6E4"
|
||||
|
|
|
|||
|
|
@ -29,7 +29,7 @@ const char MissileChars[] = {
|
|||
#define Charset ((char *)0xd800)
|
||||
|
||||
// Joystick and crosshair control
|
||||
volatile int CrossX = 160, CrossY = 100;
|
||||
int CrossX = 160, CrossY = 100;
|
||||
bool CrossP = false;
|
||||
char CrossDelay = 0;
|
||||
|
||||
|
|
@ -553,22 +553,20 @@ __interrupt void joy_interrupt()
|
|||
joy_poll(0);
|
||||
|
||||
// Move crosshair coordinates
|
||||
int cx = CrossX + 2 * joyx[0], cy = CrossY + 2 * joyy[0];
|
||||
CrossX += 2 * joyx[0]; CrossY += 2 * joyy[0];
|
||||
|
||||
// Stop at edges of screen
|
||||
if (cx < 8)
|
||||
cx = 8;
|
||||
else if (cx > 312)
|
||||
cx = 312;
|
||||
if (cy < 20)
|
||||
cy = 20;
|
||||
else if (cy > 172)
|
||||
cy = 172;
|
||||
if (CrossX < 8)
|
||||
CrossX = 8;
|
||||
else if (CrossX > 312)
|
||||
CrossX = 312;
|
||||
if (CrossY < 20)
|
||||
CrossY = 20;
|
||||
else if (CrossY > 172)
|
||||
CrossY = 172;
|
||||
|
||||
// Move crosshair sprite
|
||||
spr_move(0, cx + 14, cy + 40);
|
||||
CrossX = cx;
|
||||
CrossY = cy;
|
||||
spr_move(0, CrossX + 14, CrossY + 40);
|
||||
|
||||
// Check button
|
||||
if (joyb[0])
|
||||
|
|
@ -699,17 +697,15 @@ void game_play(void)
|
|||
// Check if fire request
|
||||
if (CrossP)
|
||||
{
|
||||
int cx = CrossX, cy = CrossY;
|
||||
|
||||
// Find launch site
|
||||
int sx = 160;
|
||||
if (cx < 120)
|
||||
if (CrossX < 120)
|
||||
sx = 24;
|
||||
else if (cx > 200)
|
||||
else if (CrossX > 200)
|
||||
sx = 296;
|
||||
|
||||
// Fire missile
|
||||
missile_start(sx, 184, cx, cy);
|
||||
missile_start(sx, 184, CrossX, CrossY);
|
||||
|
||||
// Reset request
|
||||
CrossP = false;
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@ __interrupt void doscroll(void)
|
|||
vic.color_border++;
|
||||
|
||||
// Update raster IRQ for scroll line with new horizontal scroll offset
|
||||
rirq_data(&scroll, 1, 7 - (x & 7));
|
||||
rirq_data(&scroll, 0, 7 - (x & 7));
|
||||
// Copy scrolled version of text when switching over char border
|
||||
if ((x & 7) == 0)
|
||||
memcpy((char *)0x0400 + 40 * 24, Text + ((x >> 3) & 255), 40);
|
||||
|
|
@ -37,13 +37,11 @@ int main(void)
|
|||
rirq_init(true);
|
||||
|
||||
// Build switch to scroll line IRQ
|
||||
rirq_build(&scroll, 2);
|
||||
// Delay for one line to get to right border
|
||||
rirq_delay(&scroll, 11);
|
||||
rirq_build(&scroll, 1);
|
||||
// Change control register two with this IRQ
|
||||
rirq_write(&scroll, 1, &vic.ctrl2, 0);
|
||||
rirq_write(&scroll, 0, &vic.ctrl2, 0);
|
||||
// Put it onto the scroll line
|
||||
rirq_set(0, 49 + 24 * 8, &scroll);
|
||||
rirq_set(0, 50 + 24 * 8, &scroll);
|
||||
|
||||
// Build the switch to normal IRQ
|
||||
rirq_build(&restore, 2);
|
||||
|
|
|
|||
|
|
@ -20,13 +20,11 @@ int main(void)
|
|||
rirq_init(true);
|
||||
|
||||
// Build switch to scroll line IRQ
|
||||
rirq_build(&scroll, 2);
|
||||
// Delay for one line to get to right border
|
||||
rirq_delay(&scroll, 11);
|
||||
rirq_build(&scroll, 1);
|
||||
// Change control register two with this IRQ
|
||||
rirq_write(&scroll, 1, &vic.ctrl2, 0);
|
||||
rirq_write(&scroll, 0, &vic.ctrl2, 0);
|
||||
// Put it onto the scroll line
|
||||
rirq_set(0, 49 + 24 * 8, &scroll);
|
||||
rirq_set(0, 50 + 24 * 8, &scroll);
|
||||
|
||||
// Build the switch to normal IRQ
|
||||
rirq_build(&bottom, 1);
|
||||
|
|
@ -48,7 +46,7 @@ int main(void)
|
|||
// wait for raster reaching bottom of screen
|
||||
rirq_wait();
|
||||
// Update raster IRQ for scroll line with new horizontal scroll offset
|
||||
rirq_data(&scroll, 1, 7 - (x & 7));
|
||||
rirq_data(&scroll, 0, 7 - (x & 7));
|
||||
// Copy scrolled version of text when switching over char border
|
||||
if ((x & 7) == 0)
|
||||
memcpy((char *)0x0400 + 40 * 24, Text + ((x >> 3) & 255), 40);
|
||||
|
|
|
|||
|
|
@ -27,7 +27,7 @@ ScreenRow * const color = (ScreenRow *)0xd800;
|
|||
// Move the screen one character to the left
|
||||
void scrollLeft(void)
|
||||
{
|
||||
// Loop horizontally
|
||||
// Loop horizontaly
|
||||
for(char x=0; x<39; x++)
|
||||
{
|
||||
// Unroll vertical loop 16 times
|
||||
|
|
|
|||
|
|
@ -64,7 +64,6 @@ const char * scrolltext[] = {
|
|||
"",
|
||||
"",
|
||||
"",
|
||||
""
|
||||
};
|
||||
|
||||
|
||||
|
|
@ -199,7 +198,7 @@ int main(void)
|
|||
// Update interrupt position
|
||||
for(char i=0; i<5; i++)
|
||||
{
|
||||
int ty = 48 * i + 45 + oy;
|
||||
int ty = 48 * i + 46 + oy;
|
||||
|
||||
// No interrupts below screen bottom
|
||||
if (ty < 250)
|
||||
|
|
@ -247,7 +246,7 @@ int main(void)
|
|||
case 42:
|
||||
readline(line, lpos);
|
||||
lpos++;
|
||||
if (lpos == 27)
|
||||
if (lpos == 28)
|
||||
lpos = 0;
|
||||
break;
|
||||
case 45:
|
||||
|
|
|
|||
Loading…
Reference in New Issue