Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 9892 → Rev 9893

/programs/develop/cedit/SRC/Icons.ob07
1,5 → 1,5
(*
Copyright 2021, 2022 Anton Krotov
Copyright 2021-2023 Anton Krotov
 
This file is part of CEdit.
 
58,14 → 58,14
 
PROCEDURE GetImg (ptr, size: INTEGER): INTEGER;
VAR
image_data, dst, x, type: INTEGER;
image_data, dst, x, Type: INTEGER;
BEGIN
image_data := img_decode(ptr, size, 0);
IF image_data # 0 THEN
SYSTEM.GET(image_data + 4, x);
ASSERT(x = SIZE);
SYSTEM.GET(image_data + 20, type);
IF type # 3 THEN
SYSTEM.GET(image_data + 20, Type);
IF Type # 3 THEN
dst := img_convert(image_data, 0, 3, 0, 0);
img_destroy(image_data);
image_data := dst
/programs/develop/oberon07/Compiler.kex
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/programs/develop/oberon07/LICENSE
1,6 → 1,6
BSD 2-Clause License
 
Copyright (c) 2018-2022, Anton Krotov
Copyright (c) 2018-2023, Anton Krotov
All rights reserved.
 
Redistribution and use in source and binary forms, with or without
/programs/develop/oberon07/doc/WinLib.txt
File deleted
\ No newline at end of file
/programs/develop/oberon07/doc/x86_64.txt
File deleted
\ No newline at end of file
/programs/develop/oberon07/doc/x86.txt
28,7 → 28,9
исходном коде), по умолчанию - 4
-nochk <"ptibcwra"> отключить проверки при выполнении (см. ниже)
-lower разрешить ключевые слова и встроенные идентификаторы в
нижнем регистре
нижнем регистре (по умолчанию)
-upper только верхний регистр для ключевых слов и встроенных
идентификаторов
-def <имя> задать символ условной компиляции
-ver <major.minor> версия программы (только для kosdll)
-uses вывести список импортированных модулей
81,6 → 83,7
13. Возможен импорт модулей с указанием пути и имени файла
14. Добавлен специальный синтаксис для условной компиляции (см. CC.txt)
15. Имя процедуры в конце объявления (после END) необязательно
16. Разрешено использовать нижний регистр для ключевых слов
 
------------------------------------------------------------------------------
Особенности реализации
137,6 → 140,10
PROCEDURE WSADR(x: строковая константа (WCHAR)): INTEGER
возвращает адрес x
 
PROCEDURE VAL(v: любой тип; T): T
v - переменная;
интерпретирует v, как переменную типа T
 
PROCEDURE SIZE(T): INTEGER
возвращает размер типа T
 
/programs/develop/oberon07/lib/KolibriOS/Math.ob07
1,7 → 1,7
(*
BSD 2-Clause License
 
Copyright (c) 2013-2014, 2018-2020 Anton Krotov
Copyright (c) 2013-2014, 2018-2022 Anton Krotov
All rights reserved.
*)
 
271,8 → 271,7
ELSIF x < -15.0 THEN
x := -1.0
ELSE
x := exp(2.0 * x);
x := (x - 1.0) / (x + 1.0)
x := 1.0 - 2.0 / (exp(2.0 * x) + 1.0)
END
 
RETURN x
/programs/develop/oberon07/source/AMD64.ob07
1,7 → 1,7
(*
BSD 2-Clause License
 
Copyright (c) 2018-2022, Anton Krotov
Copyright (c) 2018-2023, Anton Krotov
All rights reserved.
*)
 
1152,14 → 1152,13
movrm(reg1, reg1, 0)
 
|IL.opPARAM:
n := param2;
IF n = 1 THEN
IF param2 = 1 THEN
UnOp(reg1);
push(reg1);
drop
ELSE
ASSERT(R.top + 1 <= n);
PushAll(n)
ASSERT(R.top + 1 <= param2);
PushAll(param2)
END
 
|IL.opJNZ1:
1344,8 → 1343,8
 
|IL.opNEW:
PushAll(1);
n := param2 + 8;
ASSERT(UTILS.Align(n, 8));
n := param2 + 16;
ASSERT(UTILS.Align(n, 16));
pushc(n);
pushc(param1);
CallRTL(IL._new)
1787,11 → 1786,6
X86._movrm(reg1, reg1, 0, param2 * 8, FALSE);
X86._movrm(reg1, reg2, 0, param2 * 8, TRUE)
 
|IL.opCHKBYTE:
BinOp(reg1, reg2);
cmprc(reg1, 256);
jcc(jb, param1)
 
|IL.opCHKIDX:
UnOp(reg1);
cmprc(reg1, param2);
1832,14 → 1826,6
INCL(R.regs, reg1);
ASSERT(REG.GetReg(R, reg1))
 
|IL.opCHR:
UnOp(reg1);
andrc(reg1, 255)
 
|IL.opWCHR:
UnOp(reg1);
andrc(reg1, 65535)
 
|IL.opEQP, IL.opNEP, IL.opEQIP, IL.opNEIP:
UnOp(reg1);
reg2 := GetAnyReg();
2385,6 → 2371,7
 
BEGIN
Xmm[0] := 0;
X86.align16(TRUE);
tcount := CHL.Length(IL.codes.types);
 
Win64RegPar[0] := rcx;
/programs/develop/oberon07/source/ARITH.ob07
1,7 → 1,7
(*
BSD 2-Clause License
 
Copyright (c) 2018-2021, Anton Krotov
Copyright (c) 2018-2022, Anton Krotov
All rights reserved.
*)
 
217,7 → 217,6
PROCEDURE fconv* (s: ARRAY OF CHAR; VAR v: VALUE; VAR error: INTEGER);
VAR
value: REAL;
frac: REAL;
exp10: REAL;
i, n, d: INTEGER;
minus: BOOLEAN;
225,32 → 224,24
BEGIN
error := 0;
value := 0.0;
frac := 0.0;
exp10 := 1.0;
minus := FALSE;
n := 0;
 
i := 0;
WHILE (error = 0) & STRINGS.digit(s[i]) DO
IF opFloat2(value, 10.0, "*") & opFloat2(value, FLT(digit[ORD(s[i])]), "+") THEN
exp10 := 0.0;
WHILE (error = 0) & (STRINGS.digit(s[i]) OR (s[i] = ".")) DO
IF s[i] = "." THEN
exp10 := 1.0;
INC(i)
ELSE
error := 4
END
END;
 
INC(i);
 
WHILE (error = 0) & STRINGS.digit(s[i]) DO
IF opFloat2(frac, 10.0, "*") & opFloat2(frac, FLT(digit[ORD(s[i])]), "+") THEN
exp10 := exp10 * 10.0;
IF opFloat2(value, 10.0, "*") & opFloat2(value, FLT(digit[ORD(s[i])]), "+") & opFloat2(exp10, 10.0, "*") THEN
INC(i)
ELSE
error := 4
END
END
END;
 
IF ~opFloat2(value, frac / exp10, "+") THEN
IF ~opFloat2(value, exp10, "/") THEN
error := 4
END;
 
/programs/develop/oberon07/source/Compiler.ob07
1,7 → 1,7
(*
BSD 2-Clause License
 
Copyright (c) 2018-2022, Anton Krotov
Copyright (c) 2018-2023, Anton Krotov
All rights reserved.
*)
 
48,6 → 48,7
 
 
BEGIN
options.lower := TRUE;
out := "";
checking := options.checking;
_end := FALSE;
133,6 → 134,9
ELSIF param = "-lower" THEN
options.lower := TRUE
 
ELSIF param = "-upper" THEN
options.lower := FALSE
 
ELSIF param = "-pic" THEN
options.pic := TRUE
 
215,7 → 219,7
C.Ln;
C.String("Akron Oberon Compiler v"); C.Int(UTILS.vMajor); C.String("."); C.Int2(UTILS.vMinor);
C.String(" ("); C.Int(UTILS.bit_depth); C.StringLn("-bit) " + UTILS.Date);
C.StringLn("Copyright (c) 2018-2022, Anton Krotov");
C.StringLn("Copyright (c) 2018-2023, Anton Krotov");
 
IF inname = "" THEN
C.Ln;
243,7 → 247,8
C.StringLn(" -stk <size> set size of stack in Mbytes (Windows, Linux, KolibriOS)"); C.Ln;
C.StringLn(" -nochk <'ptibcwra'> disable runtime checking (pointers, types, indexes,");
C.StringLn(" BYTE, CHR, WCHR)"); C.Ln;
C.StringLn(" -lower allow lower case for keywords"); C.Ln;
C.StringLn(" -lower allow lower case for keywords (default)"); C.Ln;
C.StringLn(" -upper only upper case for keywords"); C.Ln;
C.StringLn(" -def <identifier> define conditional compilation symbol"); C.Ln;
C.StringLn(" -ver <major.minor> set version of program (KolibriOS DLL)"); C.Ln;
C.StringLn(" -ram <size> set size of RAM in bytes (MSP430) or Kbytes (STM32)"); C.Ln;
/programs/develop/oberon07/source/FILES.ob07
1,13 → 1,13
(*
BSD 2-Clause License
 
Copyright (c) 2018-2021, Anton Krotov
Copyright (c) 2018-2022, Anton Krotov
All rights reserved.
*)
 
MODULE FILES;
 
IMPORT UTILS, C := COLLECTIONS, CONSOLE;
IMPORT UTILS, C := COLLECTIONS;
 
 
TYPE
/programs/develop/oberon07/source/IL.ob07
1,7 → 1,7
(*
BSD 2-Clause License
 
Copyright (c) 2018-2022, Anton Krotov
Copyright (c) 2018-2023, Anton Krotov
All rights reserved.
*)
 
24,7 → 24,7
opCOPYA* = 6; opCASET* = 7; opMULC* = 8; opMUL* = 9; opDIV* = 10; opMOD* = 11;
opDIVL* = 12; opMODL* = 13; opDIVR* = 14; opMODR* = 15; opUMINUS* = 16;
opADD* = 17; opSUB* = 18; opONERR* = 19; opSUBL* = 20; opADDC* = 21; opSUBR* = 22;
opSAVE* = 23; opSAVEC* = 24; opSAVE8* = 25; opSAVE8C* = 26; opCHKBYTE* = 27; opDROP* = 28;
opSAVE* = 23; opSAVEC* = 24; opSAVE8* = 25; opSAVE8C* = 26; (*opCHKBYTE* = 27;*) opDROP* = 28;
opNOT* = 29;
 
opEQ* = 30; opNE* = opEQ + 1; opLT* = opEQ + 2; opLE* = opEQ + 3; opGT* = opEQ + 4; opGE* = opEQ + 5 (* 35 *);
72,7 → 72,7
opPUSHT* = 169; opTYPEGR* = 170; opISREC* = 171; opCHKIDX* = 172; opPARAM* = 173;
opCHKIDX2* = 174; opLEN* = 175; opROT* = 176; opSAVES* = 177; opSADR* = 178; opLENGTHW* = 179;
 
opCHR* = 180; opENDSW* = 181; opLEAVEF* = 182; opCLEANUP* = 183; opMOVE* = 184;
(*opCHR* = 180;*) opENDSW* = 181; opLEAVEF* = 182; opCLEANUP* = 183; opMOVE* = 184;
opLSR* = 185; opLSR1* = 186; opLSR2* = 187;
opMIN* = 188; opMINC* = 189; opMAX* = 190; opMAXC* = 191; opSYSVALIGN16* = 192;
opEQB* = 193; opNEB* = 194; opINF* = 195; opWIN64ALIGN16* = 196; opVLOAD8* = 197; opGLOAD8* = 198;
80,7 → 80,7
opLOAD64* = 202; opLLOAD64* = 203; opVLOAD64* = 204; opGLOAD64* = 205; opSAVE64* = 206;
 
opTYPEGD* = 207; opCALLI* = 208; opPUSHIP* = 209; opSAVEIP* = 210; opEQIP* = 211; opNEIP* = 212;
opSAVE16C* = 213; opWCHR* = 214; opHANDLER* = 215;
opSAVE16C* = 213; (*opWCHR* = 214;*) opHANDLER* = 215;
 
opSYSVCALL* = 216; opSYSVCALLI* = 217; opSYSVCALLP* = 218; opFNAME* = 219; opFASTCALL* = 220;
 
265,12 → 265,22
END PutByte;
 
 
PROCEDURE AlignData (n: INTEGER);
BEGIN
WHILE CHL.Length(codes.data) MOD n # 0 DO
PutByte(0)
END
END AlignData;
 
 
PROCEDURE putstr* (s: ARRAY OF CHAR): INTEGER;
VAR
i, n, res: INTEGER;
BEGIN
IF TARGETS.WinLin THEN
AlignData(16)
END;
res := CHL.Length(codes.data);
 
i := 0;
n := LENGTH(s);
WHILE i < n DO
290,6 → 300,9
 
BEGIN
IF codes.charoffs[c] = -1 THEN
IF TARGETS.WinLin THEN
AlignData(16)
END;
res := CHL.Length(codes.data);
PutByte(c);
PutByte(0);
307,13 → 320,13
i, n, res: INTEGER;
 
BEGIN
IF TARGETS.WinLin THEN
AlignData(16)
ELSE
AlignData(2)
END;
res := CHL.Length(codes.data);
 
IF ODD(res) THEN
PutByte(0);
INC(res)
END;
 
n := STRINGS.Utf8To16(s, codes.wstr);
 
i := 0;
341,13 → 354,13
 
BEGIN
IF codes.wcharoffs[c] = -1 THEN
IF TARGETS.WinLin THEN
AlignData(16)
ELSE
AlignData(2)
END;
res := CHL.Length(codes.data);
 
IF ODD(res) THEN
PutByte(0);
INC(res)
END;
 
IF TARGETS.LittleEndian THEN
PutByte(c MOD 256);
PutByte(c DIV 256)
/programs/develop/oberon07/source/MSP430.ob07
1,7 → 1,7
(*
BSD 2-Clause License
 
Copyright (c) 2019-2021, Anton Krotov
Copyright (c) 2019-2022, Anton Krotov
All rights reserved.
*)
 
984,11 → 984,6
drop;
Op2(opMOV + bw(param2 = 1), src_x(param1, SR), dst_x(0, reg2))
 
|IL.opCHKBYTE:
BinOp(reg1, reg2);
Op2(opCMP, imm(256), reg1);
jcc(jb, param1)
 
|IL.opCHKIDX:
UnOp(reg1);
Op2(opCMP, imm(param2), reg1);
1412,10 → 1407,6
Test(ACC);
jcc(jne, param1)
 
|IL.opCHR:
UnOp(reg1);
Op2(opAND, imm(255), reg1)
 
|IL.opABS:
UnOp(reg1);
Test(reg1);
/programs/develop/oberon07/source/PROG.ob07
1,7 → 1,7
(*
BSD 2-Clause License
 
Copyright (c) 2018-2022, Anton Krotov
Copyright (c) 2018-2023, Anton Krotov
All rights reserved.
*)
 
41,6 → 41,7
sysPUT8* = 35; sysPUT16* = 36; stCOPY* = 37; stWCHR* = 38;
sysWSADR* = 39; sysPUT32* = 40; (*sysNOP* = 41; sysEINT* = 42;
sysDINT* = 43;*)sysGET8* = 44; sysGET16* = 45; sysGET32* = 46;
sysVAL* = 47;
 
default32* = 2; _default32* = default32 + 1;
stdcall* = 4; _stdcall* = stdcall + 1;
239,13 → 240,18
 
PROCEDURE getOffset* (varIdent: IDENT): INTEGER;
VAR
size: INTEGER;
size, glob_align: INTEGER;
 
BEGIN
IF varIdent.offset = -1 THEN
size := varIdent._type.size;
IF varIdent.global THEN
IF UTILS.Align(program.bss, varIdent._type.align) THEN
IF TARGETS.WinLin THEN
glob_align := 16
ELSE
glob_align := varIdent._type.align
END;
IF UTILS.Align(program.bss, glob_align) THEN
IF UTILS.maxint - program.bss >= size THEN
varIdent.offset := program.bss;
INC(program.bss, size)
1109,6 → 1115,7
EnterProc(unit, "put8", idSYSPROC, sysPUT8);
EnterProc(unit, "code", idSYSPROC, sysCODE);
EnterProc(unit, "move", idSYSPROC, sysMOVE);
EnterProc(unit, "val", idSYSPROC, sysVAL);
(*
IF program.target.sys = mConst.Target_iMSP430 THEN
EnterProc(unit, "nop", idSYSPROC, sysNOP);
1256,7 → 1263,11
 
IF TARGETS.RealSize # 0 THEN
program.stTypes.tREAL := enterType(tREAL, TARGETS.RealSize, 0, NIL);
IF TARGETS.OS = TARGETS.osLINUX32 THEN
program.stTypes.tREAL.align := 4
ELSE
program.stTypes.tREAL.align := TARGETS.RealSize
END
END;
 
program.stTypes.tSTRING := enterType(tSTRING, TARGETS.WordSize, 0, NIL);
/programs/develop/oberon07/source/RVMxI.ob07
1,7 → 1,7
(*
BSD 2-Clause License
 
Copyright (c) 2020-2021, Anton Krotov
Copyright (c) 2020-2022, Anton Krotov
All rights reserved.
*)
 
790,14 → 790,6
UnOp(r1);
Emit(opLSRC, r1, param2 MOD (szWord * 8))
 
|IL.opCHR:
UnOp(r1);
Emit(opANDC, r1, 255)
 
|IL.opWCHR:
UnOp(r1);
Emit(opANDC, r1, 65535)
 
|IL.opABS:
UnOp(r1);
Emit(opCMPC, r1, 0);
958,11 → 950,6
END;
drop
 
|IL.opCHKBYTE:
BinOp(r1, r2);
Emit(opCMPC, r1, 256);
Emit(opJBT, param1, 0)
 
|IL.opCHKIDX:
UnOp(r1);
Emit(opCMPC, r1, param2);
/programs/develop/oberon07/source/STATEMENTS.ob07
402,12 → 402,6
IL.AddCmd(IL.opSAVE8C, ARITH.Int(e.value))
END
ELSE
IF chkBYTE IN Options.checking THEN
label := IL.NewLabel();
IL.AddCmd2(IL.opCHKBYTE, label, 0);
IL.OnError(line, errBYTE);
IL.SetLabel(label)
END;
IL.AddCmd0(IL.opSAVE8)
END
END
1062,7 → 1056,7
IF chkCHR IN Options.checking THEN
CheckRange(256, pos.line, errCHR)
ELSE
IL.AddCmd0(IL.opCHR)
IL.AddCmd(IL.opMODR, 256)
END
END
 
1077,7 → 1071,7
IF chkWCHR IN Options.checking THEN
CheckRange(65536, pos.line, errWCHR)
ELSE
IL.AddCmd0(IL.opWCHR)
IL.AddCmd(IL.opMODR, 65536)
END
END
 
1392,6 → 1386,8
field: PROG.FIELD;
pos: PARS.POSITION;
t, idx: PARS.EXPR;
sysVal: BOOLEAN;
n: INTEGER;
 
 
PROCEDURE LoadAdr (e: PARS.EXPR);
1444,7 → 1440,6
_type: PROG._TYPE;
 
BEGIN
 
IF chkIDX IN Options.checking THEN
label := IL.NewLabel();
IL.AddCmd2(IL.opCHKIDX2, label, 0);
1477,12 → 1472,35
 
BEGIN
qualident(parser, e);
sysVal := (e.obj = eSYSPROC) & (e.stproc = PROG.sysVAL);
IF sysVal THEN
PARS.checklex(parser, SCAN.lxLROUND);
PARS.Next(parser);
getpos(parser, pos);
designator(parser, e);
PARS.check(isVar(e), pos, 93);
IF PROG.isOpenArray(e._type) THEN
n := PROG.Dim(e._type);
WHILE n > 0 DO
IL.drop;
DEC(n)
END
END;
PARS.checklex(parser, SCAN.lxCOMMA);
PARS.Next(parser);
getpos(parser, pos);
qualident(parser, t);
PARS.check(t.obj = eTYPE, pos, 79);
e._type := t._type;
PARS.checklex(parser, SCAN.lxRROUND);
PARS.Next(parser)
END;
 
IF e.obj IN {ePROC, eIMP} THEN
PROG.UseProc(parser.unit, e.ident.proc)
END;
 
IF isVar(e) THEN
IF isVar(e) & ~sysVal THEN
LoadAdr(e)
END;
 
2599,6 → 2617,9
 
NextPos(parser, pos);
expression(parser, e1);
IF (e._type.typ = PROG.tBYTE) & (e1.obj # eCONST) & (e1._type.typ = PROG.tINTEGER) & (chkBYTE IN Options.checking) THEN
CheckRange(256, pos.line, errBYTE)
END;
 
IL.setlast(endcall.prev(IL.COMMAND));
 
/programs/develop/oberon07/source/TARGETS.ob07
1,7 → 1,7
(*
BSD 2-Clause License
 
Copyright (c) 2019-2021, Anton Krotov
Copyright (c) 2019-2021, 2023, Anton Krotov
All rights reserved.
*)
 
67,7 → 67,7
 
target*, CPU*, BitDepth*, OS*, RealSize*, WordSize*, AdrSize*, InstrSize*: INTEGER;
ComLinePar*, LibDir*, FileExt*: STRING;
Import*, Dispose*, RTL*, Dll*, LittleEndian*: BOOLEAN;
Import*, Dispose*, RTL*, Dll*, LittleEndian*, WinLin*: BOOLEAN;
 
 
PROCEDURE Enter (idx, CPU, RealSize, OS: INTEGER; ComLinePar, LibDir, FileExt: STRING);
110,6 → 110,7
Dispose := ~(target IN noDISPOSE);
RTL := ~(target IN noRTL);
Dll := target IN {Linux32SO, Linux64SO, Win32DLL, Win64DLL, KolibriOSDLL};
WinLin := OS IN {osWIN32, osLINUX32, osWIN64, osLINUX64};
WordSize := BitDepth DIV 8;
AdrSize := WordSize
END
/programs/develop/oberon07/source/THUMB.ob07
1,7 → 1,7
(*
BSD 2-Clause License
 
Copyright (c) 2019-2021, Anton Krotov
Copyright (c) 2019-2022, Anton Krotov
All rights reserved.
*)
 
91,7 → 91,11
 
RELOCCODE = ARRAY 7 OF INTEGER;
 
MEM = RECORD
start, size, startReserve, endReserve: INTEGER
END;
 
 
VAR
 
R: REG.REGS;
105,11 → 109,9
StkCount: INTEGER;
 
Target: RECORD
FlashAdr,
SRAMAdr,
flash, sram: MEM;
IVTLen,
MinStack,
Reserved: INTEGER;
MinStkSize: INTEGER;
InstrSet: SET;
isNXP: BOOLEAN
END;
1151,14 → 1153,13
PushAll(0)
 
|IL.opPARAM:
n := param2;
IF n = 1 THEN
IF param2 = 1 THEN
UnOp(r1);
push(r1);
drop
ELSE
ASSERT(R.top + 1 <= n);
PushAll(n)
ASSERT(R.top + 1 <= param2);
PushAll(param2)
END
 
|IL.opCLEANUP:
1587,14 → 1588,6
Tst(r1);
SetCC(jne, r1)
 
|IL.opCHR:
UnOp(r1);
Code(0B2C0H + r1 * 9) (* uxtb r1, r1 *)
 
|IL.opWCHR:
UnOp(r1);
Code(0B280H + r1 * 9) (* uxth r1, r1 *)
 
|IL.opASR, IL.opROR, IL.opLSL, IL.opLSR:
BinOp(r1, r2);
Shift(opcode, r1, r2);
1620,11 → 1613,6
END
END
 
|IL.opCHKBYTE:
BinOp(r1, r2);
CmpConst(r1, 256);
jcc(jb, param1)
 
|IL.opCHKIDX:
UnOp(r1);
CmpConst(r1, param2);
2344,16 → 2332,23
END epilog;
 
 
PROCEDURE SetTarget (FlashStart, SRAMStart: INTEGER; InstrSet: SET; isNXP: BOOLEAN);
PROCEDURE SetTarget (FlashStart, FlashSize, FlashReserve, SRAMStart, SRAMSize, SRAMReserve: INTEGER; InstrSet: SET; isNXP: BOOLEAN);
BEGIN
Target.FlashAdr := FlashStart;
Target.SRAMAdr := SRAMStart;
Target.flash.start := FlashStart;
Target.flash.size := FlashSize;
(*Target.flash.startReserve := 0;*)
Target.flash.endReserve := FlashReserve;
 
Target.sram.start := SRAMStart;
Target.sram.size := SRAMSize;
Target.sram.startReserve := 0;
Target.sram.endReserve := SRAMReserve;
 
Target.InstrSet := InstrSet;
Target.isNXP := isNXP;
 
Target.IVTLen := 256; (* >= 192 *)
Target.Reserved := 0;
Target.MinStack := 512;
Target.MinStkSize := 256;
END SetTarget;
 
 
2360,17 → 2355,13
PROCEDURE CodeGen* (outname: ARRAY OF CHAR; target: INTEGER; options: PROG.OPTIONS);
VAR
opt: PROG.OPTIONS;
i, j, DataAdr, BssAdr, DataSize, BssSize, CodeSize: INTEGER;
 
ram, rom, i, j: INTEGER;
 
DataAdr, BssAdr, DataSize, BssSize, CodeSize: INTEGER;
 
BEGIN
ram := MIN(MAX(options.ram, minRAM), maxRAM) * 1024;
rom := MIN(MAX(options.rom, minROM), maxROM) * 1024;
 
IF target = TARGETS.STM32CM3 THEN
SetTarget(08000000H, 20000000H, CortexM3, FALSE)
SetTarget(08000000H, MIN(MAX(options.rom, minROM), maxROM) * 1024, 0,
20000000H, MIN(MAX(options.ram, minRAM), maxRAM) * 1024, 0,
CortexM3, FALSE)
END;
 
tcount := CHL.Length(IL.codes.types);
2384,13 → 2375,13
 
StkCount := 0;
 
DataAdr := Target.SRAMAdr + Target.Reserved;
DataSize := CHL.Length(IL.codes.data) + tcount * 4 + Target.Reserved;
DataAdr := Target.sram.start + Target.sram.startReserve;
DataSize := CHL.Length(IL.codes.data) + tcount * 4 + Target.sram.startReserve;
WHILE DataSize MOD 4 # 0 DO
CHL.PushByte(IL.codes.data, 0);
INC(DataSize)
END;
BssAdr := DataAdr + DataSize - Target.Reserved;
BssAdr := DataAdr + DataSize - Target.sram.startReserve;
 
IL.set_bss(MAX(IL.codes.bss, MAX(IL.codes.dmin - CHL.Length(IL.codes.data), 4)));
 
2397,20 → 2388,20
BssSize := IL.codes.bss;
ASSERT(UTILS.Align(BssSize, 4));
 
prolog(BssSize, tcount, ORD(opt.pic), Target.SRAMAdr + ram, Target.IVTLen);
prolog(BssSize, tcount, ORD(opt.pic), Target.sram.start + Target.sram.size - Target.sram.endReserve, Target.IVTLen);
translate(ORD(opt.pic), tcount * 4);
epilog;
 
fixup(Target.FlashAdr, DataAdr, BssAdr);
fixup(Target.flash.start, DataAdr, BssAdr);
 
INC(DataSize, BssSize);
CodeSize := CHL.Length(program.code);
 
IF CodeSize > rom THEN
IF CodeSize > Target.flash.size - Target.flash.endReserve THEN
ERRORS.Error(203)
END;
 
IF DataSize > ram - Target.MinStack THEN
IF DataSize > Target.sram.size - Target.MinStkSize - Target.sram.endReserve THEN
ERRORS.Error(204)
END;
 
2426,15 → 2417,17
 
WR.Create(outname);
 
HEX.Data2(program.code, 0, CodeSize, high(Target.FlashAdr));
HEX.Data2(program.code, 0, CodeSize, high(Target.flash.start));
HEX.End;
 
WR.Close;
 
C.Dashes;
C.String( " rom: "); C.Int(CodeSize); C.String(" of "); C.Int(rom); C.String(" ("); C.Int(CodeSize * 100 DIV rom); C.StringLn("%)");
C.String( " rom: "); C.Int(CodeSize); C.String(" of "); C.Int(Target.flash.size - Target.flash.endReserve);
C.String(" ("); C.Int(CodeSize * 100 DIV (Target.flash.size - Target.flash.endReserve)); C.StringLn("%)");
C.Ln;
C.String( " ram: "); C.Int(DataSize); C.String(" of "); C.Int(ram); C.String(" ("); C.Int(DataSize * 100 DIV ram); C.StringLn("%)")
C.String( " ram: "); C.Int(DataSize); C.String(" of "); C.Int(Target.sram.size - Target.sram.endReserve);
C.String(" ("); C.Int(DataSize * 100 DIV (Target.sram.size - Target.sram.endReserve)); C.StringLn("%)")
END CodeGen;
 
 
/programs/develop/oberon07/source/UTILS.ob07
1,7 → 1,7
(*
BSD 2-Clause License
 
Copyright (c) 2018-2022, Anton Krotov
Copyright (c) 2018-2023, Anton Krotov
All rights reserved.
*)
 
23,8 → 23,8
max32* = 2147483647;
 
vMajor* = 1;
vMinor* = 57;
Date* = "31-aug-2022";
vMinor* = 63;
Date* = "21-jan-2023";
 
FILE_EXT* = ".ob07";
RTL_NAME* = "RTL";
/programs/develop/oberon07/source/X86.ob07
1,7 → 1,7
(*
BSD 2-Clause License
 
Copyright (c) 2018-2022, Anton Krotov
Copyright (c) 2018-2023, Anton Krotov
All rights reserved.
*)
 
954,14 → 954,13
jmp(param1)
 
|IL.opPARAM:
n := param2;
IF n = 1 THEN
IF param2 = 1 THEN
UnOp(reg1);
push(reg1);
drop
ELSE
ASSERT(R.top + 1 <= n);
PushAll(n)
ASSERT(R.top + 1 <= param2);
PushAll(param2)
END
 
|IL.opCLEANUP:
1438,11 → 1437,6
pushc(param1);
CallRTL(pic, IL._move)
 
|IL.opCHKBYTE:
BinOp(reg1, reg2);
cmprc(reg1, 256);
jcc(jb, param1)
 
|IL.opCHKIDX:
UnOp(reg1);
cmprc(reg1, param2);
1557,14 → 1551,6
CallRTL(pic, IL._lengthw);
GetRegA
 
|IL.opCHR:
UnOp(reg1);
andrc(reg1, 255)
 
|IL.opWCHR:
UnOp(reg1);
andrc(reg1, 65535)
 
|IL.opASR, IL.opROR, IL.opLSL, IL.opLSR:
UnOp(reg1);
IF reg1 # ecx THEN
1828,8 → 1814,17
 
|IL.opNEW:
PushAll(1);
CASE TARGETS.OS OF
|TARGETS.osWIN32:
n := param2 + 4;
ASSERT(UTILS.Align(n, 4))
|TARGETS.osLINUX32:
n := param2 + 16;
ASSERT(UTILS.Align(n, 16))
|TARGETS.osKOS:
n := param2 + 8;
ASSERT(UTILS.Align(n, 32));
ASSERT(UTILS.Align(n, 32))
END;
pushc(n);
pushc(param1);
CallRTL(pic, IL._new)
2444,6 → 2439,19
END epilog;
 
 
PROCEDURE align16* (bit64: BOOLEAN);
BEGIN
IF TARGETS.WinLin THEN
WHILE CHL.Length(IL.codes.data) MOD 16 # 0 DO
CHL.PushByte(IL.codes.data, 0)
END;
WHILE CHL.Length(IL.codes.types) MOD (4 - 2*ORD(bit64)) # 0 DO
CHL.PushInt(IL.codes.types, 0)
END
END
END align16;
 
 
PROCEDURE CodeGen* (outname: ARRAY OF CHAR; target: INTEGER; options: PROG.OPTIONS);
VAR
dllret, dllinit, sofinit: INTEGER;
2451,6 → 2459,7
 
BEGIN
FR[0] := 0;
align16(FALSE);
tcount := CHL.Length(IL.codes.types);
 
opt := options;
2476,7 → 2485,6
epilog(opt.pic, outname, target, opt.stack, opt.version, dllinit, dllret, sofinit);
 
BIN.fixup(program);
 
IF TARGETS.OS = TARGETS.osWIN32 THEN
PE32.write(program, outname, target = TARGETS.Win32C, target = TARGETS.Win32DLL, FALSE)
ELSIF target = TARGETS.KolibriOS THEN
2486,7 → 2494,6
ELSIF TARGETS.OS = TARGETS.osLINUX32 THEN
ELF.write(program, outname, sofinit, target = TARGETS.Linux32SO, FALSE)
END
 
END CodeGen;