added linux executables as release

git-svn-id: https://svn.inf.ethz.ch/svn/lecturers/a2/trunk@7577 8c9fc860-2736-0410-a75d-ab315db34111

lin32/a2.txt

@@ -0,0 +1,9 @@
+Files.AddSearchPath ../lin32/bin~ (* ../lin32 is a trick to get absolute path names *)
+Files.AddSearchPath ../source ~
+Files.AddSearchPath ../lin32/work ~
+Files.SetWorkPath work ~
+Configuration.Init~
+FSTools.Mount WORK RelativeFileSystem . ~
+Display.Install ~
+WindowManager.Install ~
+Autostart.Run~

lin32/bin/A2Sequencers.SymU

@@ -0,0 +1,287 @@
+MODULE A2Sequencers;
+	IMPORT Machine, Streams, Objects, Kernel;
+CONST 
+	NoDelay* = 0; 
+	MaxHandlers = 10; 
+TYPE 
+	Property* = OBJECT 
+	VAR 
+		locks: LONGINT; 
+		container*: OBJECT; 
+
+		PROCEDURE ^  & InitProperty; 
+		PROCEDURE ^ AcquireRead; 
+		PROCEDURE ^ ReleaseRead; 
+		PROCEDURE ^ AcquireWrite; 
+		PROCEDURE ^ ReleaseWrite; 
+		PROCEDURE ^ ToStream*(w: Streams.Writer); 
+		PROCEDURE ^ FromStream*(r: Streams.Reader); 
+	END Property; 
+
+	Boolean* = OBJECT (Property)
+	VAR 
+		value: BOOLEAN; 
+		handlers: ARRAY MaxHandlers OF BooleanHandler; 
+
+		PROCEDURE ^  & InitBoolean*(value: BOOLEAN); 
+		PROCEDURE ^ Get*(): BOOLEAN; 
+		PROCEDURE ^ Set*(value: BOOLEAN); 
+		PROCEDURE ^ Changed(value: BOOLEAN); 
+		PROCEDURE ^ AddHandler*(handler: BooleanHandler); 
+	END Boolean; 
+
+	Integer* = OBJECT (Property)
+	VAR 
+		value: LONGINT; 
+		handlers: ARRAY MaxHandlers OF IntegerHandler; 
+
+		PROCEDURE ^  & InitInteger*(value: LONGINT); 
+		PROCEDURE ^ Get*(): LONGINT; 
+		PROCEDURE ^ Set*(value: LONGINT); 
+		PROCEDURE ^ Inc*(step: LONGINT); 
+		PROCEDURE ^ Dec*(step: LONGINT); 
+		PROCEDURE ^ Changed(value: LONGINT); 
+		PROCEDURE ^ AddHandler*(handler: IntegerHandler); 
+	END Integer; 
+
+	Real* = OBJECT (Property)
+	VAR 
+		value: REAL; 
+		handlers: ARRAY MaxHandlers OF RealHandler; 
+
+		PROCEDURE ^  & InitReal*(value: REAL); 
+		PROCEDURE ^ Get*(): REAL; 
+		PROCEDURE ^ Set*(value: REAL); 
+		PROCEDURE ^ Changed(value: REAL); 
+		PROCEDURE ^ AddHandler*(handler: RealHandler); 
+	END Real; 
+
+	Set* = OBJECT (Property)
+	VAR 
+		value: SET; 
+		handlers: ARRAY MaxHandlers OF SetHandler; 
+
+		PROCEDURE ^  & InitSet*(value: SET); 
+		PROCEDURE ^ Get*(): SET; 
+		PROCEDURE ^ Set*(value: SET); 
+		PROCEDURE ^ Incl*(element: LONGINT); 
+		PROCEDURE ^ Excl*(element: LONGINT); 
+		PROCEDURE ^ Changed(value: SET); 
+		PROCEDURE ^ AddHandler*(handler: SetHandler); 
+	END Set; 
+
+	String* = OBJECT (Property)
+	VAR 
+		value: POINTER TO ARRAY OF CHAR; 
+		handlers: ARRAY MaxHandlers OF StringHandler; 
+
+		PROCEDURE ^  & InitString*(CONST value: ARRAY OF CHAR; length: LONGINT); 
+		PROCEDURE ^ Get*(VAR value: ARRAY OF CHAR); 
+		PROCEDURE ^ Set*(CONST value: ARRAY OF CHAR); 
+		PROCEDURE ^ Changed(CONST value: ARRAY OF CHAR); 
+		PROCEDURE ^ AddHandler*(handler: StringHandler); 
+	END String; 
+
+	Message* = OBJECT 
+	VAR 
+		next: Message; 
+		time: LONGINT; 
+
+		PROCEDURE ^  & InitMessage*; 
+		PROCEDURE ^ Handle*; 
+	END Message; 
+
+	ProcedureMessage* = OBJECT (Message)
+	VAR 
+		procedure: Procedure; 
+
+		PROCEDURE ^  & InitProcedureMessage*(procedure: Procedure); 
+		PROCEDURE ^ Handle*; 
+	END ProcedureMessage; 
+
+	BooleanMessage* = OBJECT (Message)
+	VAR 
+		value: BOOLEAN; 
+		procedure: BooleanProcedure; 
+
+		PROCEDURE ^  & InitBooleanMessage*(value: BOOLEAN; procedure: BooleanProcedure); 
+		PROCEDURE ^ Handle*; 
+	END BooleanMessage; 
+
+	IntegerMessage* = OBJECT (Message)
+	VAR 
+		value: LONGINT; 
+		procedure: IntegerProcedure; 
+
+		PROCEDURE ^  & InitIntegerMessage*(value: LONGINT; procedure: IntegerProcedure); 
+		PROCEDURE ^ Handle*; 
+	END IntegerMessage; 
+
+	IntegerIntegerMessage* = OBJECT (Message)
+	VAR 
+		value0, value1: LONGINT; 
+		procedure: IntegerIntegerProcedure; 
+
+		PROCEDURE ^  & InitIntegerIntegerMessage*(value0, value1: LONGINT; procedure: IntegerIntegerProcedure); 
+		PROCEDURE ^ Handle*; 
+	END IntegerIntegerMessage; 
+
+	RealMessage* = OBJECT (Message)
+	VAR 
+		value: REAL; 
+		procedure: RealProcedure; 
+
+		PROCEDURE ^  & InitRealMessage*(value: REAL; procedure: RealProcedure); 
+		PROCEDURE ^ Handle*; 
+	END RealMessage; 
+
+	SetMessage* = OBJECT (Message)
+	VAR 
+		value: SET; 
+		procedure: SetProcedure; 
+
+		PROCEDURE ^  & InitSetMessage*(value: SET; procedure: SetProcedure); 
+		PROCEDURE ^ Handle*; 
+	END SetMessage; 
+
+	StringMessage* = OBJECT (Message)
+	VAR 
+		value: POINTER TO ARRAY OF CHAR; 
+		procedure: StringProcedure; 
+
+		PROCEDURE ^  & InitStringMessage*(CONST value: ARRAY OF CHAR; procedure: StringProcedure); 
+		PROCEDURE ^ Handle*; 
+	END StringMessage; 
+
+	Request* = OBJECT {EXCLUSIVE} (Message)
+	VAR 
+		handled: BOOLEAN; 
+
+		PROCEDURE ^  & InitRequest*; 
+		PROCEDURE ^ Handle*; 
+		PROCEDURE ^ Await; 
+	END Request; 
+
+	IntegerRequest* = OBJECT {EXCLUSIVE} (Request)
+	VAR 
+		value: LONGINT; 
+		procedure: IntegerProcedure; 
+
+		PROCEDURE ^  & InitIntegerRequest*(value: LONGINT; procedure: IntegerProcedure); 
+		PROCEDURE ^ Handle*; 
+	END IntegerRequest; 
+
+	RequestBoolean* = OBJECT {EXCLUSIVE} (Request)
+	VAR 
+		procedure: ProcedureBoolean; 
+		result-: BOOLEAN; 
+
+		PROCEDURE ^  & InitRequestBoolean*(procedure: ProcedureBoolean); 
+		PROCEDURE ^ Handle*; 
+	END RequestBoolean; 
+
+	RequestInteger* = OBJECT {EXCLUSIVE} (Request)
+	VAR 
+		procedure: ProcedureInteger; 
+		result-: LONGINT; 
+
+		PROCEDURE ^  & InitRequestInteger*(procedure: ProcedureInteger); 
+		PROCEDURE ^ Handle*; 
+	END RequestInteger; 
+
+	RequestReal* = OBJECT {EXCLUSIVE} (Request)
+	VAR 
+		procedure: ProcedureReal; 
+		result-: REAL; 
+
+		PROCEDURE ^  & InitRequestReal*(procedure: ProcedureReal); 
+		PROCEDURE ^ Handle*; 
+	END RequestReal; 
+
+	IntegerRequestBoolean* = OBJECT {EXCLUSIVE} (Request)
+	VAR 
+		value: LONGINT; 
+		procedure: IntegerProcedureBoolean; 
+		result-: BOOLEAN; 
+
+		PROCEDURE ^  & InitIntegerRequestBoolean*(value: LONGINT; procedure: IntegerProcedureBoolean); 
+		PROCEDURE ^ Handle*; 
+	END IntegerRequestBoolean; 
+
+	RealRequestInteger* = OBJECT {EXCLUSIVE} (Request)
+	VAR 
+		value: REAL; 
+		procedure: RealProcedureInteger; 
+		result-: LONGINT; 
+
+		PROCEDURE ^  & InitRealRequestInteger*(value: REAL; procedure: RealProcedureInteger); 
+		PROCEDURE ^ Handle*; 
+	END RealRequestInteger; 
+
+	Sequencer* = OBJECT {EXCLUSIVE} 
+	VAR 
+		handling, woken: BOOLEAN; 
+		first: Message; 
+		timer: Objects.Timer; 
+
+		PROCEDURE ^  & InitSequencer*; 
+		PROCEDURE ^ SequencerCalledThis*(): BOOLEAN; 
+		PROCEDURE ^ HandleMessages; 
+		PROCEDURE ^ Add*(message: Message; time: LONGINT); 
+		PROCEDURE ^ AddMessage*(procedure: Procedure); 
+		PROCEDURE ^ AddBooleanMessage*(value: BOOLEAN; procedure: BooleanProcedure); 
+		PROCEDURE ^ AddIntegerMessage*(value: LONGINT; procedure: IntegerProcedure); 
+		PROCEDURE ^ AddRealMessage*(value: REAL; procedure: RealProcedure); 
+		PROCEDURE ^ AddSetMessage*(value: SET; procedure: SetProcedure); 
+		PROCEDURE ^ AddStringMessage*(CONST value: ARRAY OF CHAR; procedure: StringProcedure); 
+		PROCEDURE ^ AddIntegerIntegerMessage*(value0, value1: LONGINT; procedure: IntegerIntegerProcedure); 
+		PROCEDURE ^ AddIntegerRequest*(value: LONGINT; procedure: IntegerProcedure); 
+		PROCEDURE ^ AddRequestBoolean*(procedure: ProcedureBoolean): BOOLEAN; 
+		PROCEDURE ^ AddRequestInteger*(procedure: ProcedureInteger): LONGINT; 
+		PROCEDURE ^ AddRequestReal*(procedure: ProcedureReal): REAL; 
+		PROCEDURE ^ AddIntegerRequestBoolean*(value: LONGINT; procedure: IntegerProcedureBoolean): BOOLEAN; 
+		PROCEDURE ^ AddRealRequestInteger*(value: REAL; procedure: RealProcedureInteger): LONGINT; 
+		PROCEDURE ^ Remove*(message: Message); 
+		PROCEDURE ^ Handle*; 
+		PROCEDURE ^ Wakeup; 
+		PROCEDURE ^ Stop*; 
+	BEGIN{ACTIVE} 
+	END Sequencer; 
+
+	BooleanHandler = PROCEDURE {DELEGATE}(property: Boolean; value: BOOLEAN); 
+
+	IntegerHandler = PROCEDURE {DELEGATE}(property: Integer; value: LONGINT); 
+
+	RealHandler = PROCEDURE {DELEGATE}(property: Real; value: REAL); 
+
+	SetHandler = PROCEDURE {DELEGATE}(property: Set; value: SET); 
+
+	StringHandler = PROCEDURE {DELEGATE}(property: String; CONST value: ARRAY OF CHAR); 
+
+	Procedure = PROCEDURE {DELEGATE}; 
+
+	BooleanProcedure = PROCEDURE {DELEGATE}(value: BOOLEAN); 
+
+	IntegerProcedure = PROCEDURE {DELEGATE}(value: LONGINT); 
+
+	IntegerIntegerProcedure = PROCEDURE {DELEGATE}(value0, value1: LONGINT); 
+
+	RealProcedure = PROCEDURE {DELEGATE}(value: REAL); 
+
+	SetProcedure = PROCEDURE {DELEGATE}(value: SET); 
+
+	StringProcedure = PROCEDURE {DELEGATE}(CONST value: ARRAY OF CHAR); 
+
+	ProcedureBoolean = PROCEDURE {DELEGATE}():BOOLEAN; 
+
+	ProcedureInteger = PROCEDURE {DELEGATE}():LONGINT; 
+
+	ProcedureReal = PROCEDURE {DELEGATE}():REAL; 
+
+	IntegerProcedureBoolean = PROCEDURE {DELEGATE}(value: LONGINT):BOOLEAN; 
+
+	RealProcedureInteger = PROCEDURE {DELEGATE}(value: REAL):LONGINT; 
+
+	PROCEDURE ^ Delay*(delay: LONGINT): LONGINT; 
+BEGIN
+END A2Sequencers.

lin32/bin/AFM.SymU

@@ -0,0 +1,26 @@
+MODULE AFM;
+	IMPORT Files, KernelLog;
+CONST 
+TYPE 
+	CharInfo = RECORD 
+		w: LONGINT; 
+	END; 
+
+	FontMetrics* = OBJECT 
+	VAR 
+		chars: ARRAY 256 OF CharInfo; 
+		fontName: ARRAY 64 OF CHAR; 
+
+		PROCEDURE ^ AddCharInfo(ucs: LONGINT; ci: CharInfo); 
+		PROCEDURE ^ InternalGetWidth(ucs: LONGINT): LONGINT; 
+		PROCEDURE ^ GetWidth*(size: REAL; ucs: LONGINT): REAL; 
+		PROCEDURE ^ Kerning(ucs0, ucs1: LONGINT): LONGINT; 
+		PROCEDURE ^ GetStringWidth*(size: REAL; str: ARRAY OF CHAR): REAL; 
+		PROCEDURE ^ LoadAFM(filename: ARRAY OF CHAR; VAR res: LONGINT); 
+	END FontMetrics; 
+VAR 
+	times*, helvetica*, helveticaBold*: FontMetrics; 
+	res: LONGINT; 
+
+BEGIN
+END AFM.

lin32/bin/ASMAMD64.SymU

@@ -0,0 +1,751 @@
+MODULE ASMAMD64;
+CONST 
+	maxMnemonicNameLength = 12; 
+	maxMnemonics = 600; 
+	maxInstructions = 1400; 
+	maxRegisters = 150; 
+	maxCPUs = 30; 
+	maxOperands* = 3; 
+	none* =  -1; 
+	cpu8086* = 0; 
+	cpu186* = 1; 
+	cpu286* = 2; 
+	cpu386* = 3; 
+	cpu486* = 4; 
+	cpuPentium* = 5; 
+	cpuP6* = 6; 
+	cpuKatmai* = 7; 
+	cpuWillamette* = 8; 
+	cpuPrescott* = 9; 
+	cpuAMD64* = 10; 
+	cpuPrivileged* = 20; 
+	cpuProtected* = 21; 
+	cpuSSE* = 22; 
+	cpuSSE2* = 23; 
+	cpuSSE3* = 24; 
+	cpu3DNow* = 25; 
+	cpuMMX* = 26; 
+	cpuFPU* = 27; 
+	cpuOptions* = {cpuPrivileged .. cpuFPU}; 
+	optO16* = 0; 
+	optO32* = 1; 
+	optO64* = 2; 
+	optD64* = 3; 
+	optI64* = 4; 
+	optA16* = 5; 
+	optA32* = 6; 
+	optPOP* = 7; 
+	optPLOCK* = 8; 
+	optPREP* = 9; 
+	optPREPN* = 10; 
+	AL* = 0; 
+	AX* = 1; 
+	CL* = 2; 
+	CR8* = 3; 
+	CRn* = 4; 
+	CS* = 5; 
+	DRn* = 6; 
+	DS* = 7; 
+	DX* = 8; 
+	EAX* = 9; 
+	ECX* = 10; 
+	ES* = 11; 
+	FS* = 12; 
+	GS* = 13; 
+	RAX* = 14; 
+	SS* = 15; 
+	imm16* = 16; 
+	imm32* = 17; 
+	imm64* = 18; 
+	imm8* = 19; 
+	mem* = 20; 
+	mem128* = 21; 
+	mem16* = 22; 
+	mem32* = 23; 
+	mem64* = 24; 
+	mem8* = 25; 
+	mmx* = 26; 
+	mmxmem32* = 27; 
+	mmxmem64* = 28; 
+	moffset16* = 29; 
+	moffset32* = 30; 
+	moffset64* = 31; 
+	moffset8* = 32; 
+	one* = 33; 
+	pntr1616* = 34; 
+	pntr1632* = 35; 
+	rAX* = 36; 
+	reg16* = 37; 
+	reg32* = 38; 
+	reg64* = 39; 
+	reg8* = 40; 
+	regmem16* = 41; 
+	regmem32* = 42; 
+	regmem64* = 43; 
+	regmem8* = 44; 
+	rel16off* = 45; 
+	rel32off* = 46; 
+	rel8off* = 47; 
+	segReg* = 48; 
+	simm16* = 49; 
+	simm32* = 50; 
+	simm8* = 51; 
+	st0* = 52; 
+	sti* = 53; 
+	three* = 54; 
+	uimm16* = 55; 
+	uimm32* = 56; 
+	uimm8* = 57; 
+	xmm* = 58; 
+	xmmmem128* = 59; 
+	xmmmem32* = 60; 
+	xmmmem64* = 61; 
+	prfOP* = 102; 
+	prfADR* = 103; 
+	prfCS* = 46; 
+	prfDS* = 62; 
+	prfES* = 38; 
+	prfFS* = 100; 
+	prfGS* = 101; 
+	prfSS* = 54; 
+	prfLOCK* = 240; 
+	prfREP* = 243; 
+	prfREPE* = 243; 
+	prfREPZ* = 243; 
+	prfREPNE* = 242; 
+	prfREPNZ* = 242; 
+	opAAA = 0; 
+	opAAD = 1; 
+	opAAM = 2; 
+	opAAS = 3; 
+	opADC = 4; 
+	opADD* = 5; 
+	opADDPD = 6; 
+	opADDPS = 7; 
+	opADDSD* = 8; 
+	opADDSS* = 9; 
+	opADDSUBPD = 10; 
+	opADDSUBPS = 11; 
+	opAND* = 12; 
+	opANDNPD = 13; 
+	opANDNPS = 14; 
+	opANDPD* = 15; 
+	opANDPS* = 16; 
+	opARPL = 17; 
+	opBOUND = 18; 
+	opBSF = 19; 
+	opBSR = 20; 
+	opBSWAP = 21; 
+	opBT* = 22; 
+	opBTC = 23; 
+	opBTR* = 24; 
+	opBTS* = 25; 
+	opCALL* = 26; 
+	opCBW* = 27; 
+	opCDQ* = 28; 
+	opCDQE = 29; 
+	opCFLUSH = 30; 
+	opCLC = 31; 
+	opCLD* = 32; 
+	opCLGI = 33; 
+	opCLI = 34; 
+	opCLTS = 35; 
+	opCMC = 36; 
+	opCMOVA = 37; 
+	opCMOVAE = 38; 
+	opCMOVB = 39; 
+	opCMOVBE = 40; 
+	opCMOVC = 41; 
+	opCMOVE = 42; 
+	opCMOVG = 43; 
+	opCMOVGE = 44; 
+	opCMOVL = 45; 
+	opCMOVLE = 46; 
+	opCMOVNA = 47; 
+	opCMOVNAE = 48; 
+	opCMOVNB = 49; 
+	opCMOVNBE = 50; 
+	opCMOVNC = 51; 
+	opCMOVNE = 52; 
+	opCMOVNG = 53; 
+	opCMOVNGE = 54; 
+	opCMOVNL = 55; 
+	opCMOVNLE = 56; 
+	opCMOVNO = 57; 
+	opCMOVNP = 58; 
+	opCMOVNS = 59; 
+	opCMOVNZ = 60; 
+	opCMOVO = 61; 
+	opCMOVP = 62; 
+	opCMOVPE = 63; 
+	opCMOVPO = 64; 
+	opCMOVS = 65; 
+	opCMOVZ = 66; 
+	opCMP* = 67; 
+	opCMPPD = 68; 
+	opCMPPS = 69; 
+	opCMPS = 70; 
+	opCMPSB = 71; 
+	opCMPSD = 72; 
+	opCMPSQ = 73; 
+	opCMPSS = 74; 
+	opCMPSW = 75; 
+	opCMPXCHG = 76; 
+	opCMPXCHG16B = 77; 
+	opCMPXCHG8B = 78; 
+	opCOMISD* = 79; 
+	opCOMISS* = 80; 
+	opCPUID = 81; 
+	opCQO* = 82; 
+	opCVTDQ2PD = 83; 
+	opCVTDQ2PS = 84; 
+	opCVTPD2DQ = 85; 
+	opCVTPD2PI = 86; 
+	opCVTPD2PS = 87; 
+	opCVTPI2PD = 88; 
+	opCVTPI2PS = 89; 
+	opCVTPS2DQ = 90; 
+	opCVTPS2PD = 91; 
+	opCVTPS2PI = 92; 
+	opCVTSD2SI* = 93; 
+	opCVTSD2SS* = 94; 
+	opCVTSI2SD* = 95; 
+	opCVTSI2SS* = 96; 
+	opCVTSS2SD* = 97; 
+	opCVTSS2SI* = 98; 
+	opCVTTPD2DQ = 99; 
+	opCVTTPD2PI = 100; 
+	opCVTTPS2DQ = 101; 
+	opCVTTPS2PI = 102; 
+	opCVTTSD2SI = 103; 
+	opCVTTSS2SI = 104; 
+	opCWD* = 105; 
+	opCWDE = 106; 
+	opDAA = 107; 
+	opDAS = 108; 
+	opDEC* = 109; 
+	opDIV = 110; 
+	opDIVPD = 111; 
+	opDIVPS = 112; 
+	opDIVSD* = 113; 
+	opDIVSS* = 114; 
+	opEMMS = 115; 
+	opENTER* = 116; 
+	opF2XM1 = 117; 
+	opFABS = 118; 
+	opFADD = 119; 
+	opFADDP = 120; 
+	opFBLD = 121; 
+	opFBSTP = 122; 
+	opFCHS = 123; 
+	opFCLEX = 124; 
+	opFCMOVB = 125; 
+	opFCMOVBE = 126; 
+	opFCMOVE = 127; 
+	opFCMOVNB = 128; 
+	opFCMOVNBE = 129; 
+	opFCMOVNE = 130; 
+	opFCMOVNU = 131; 
+	opFCMOVU = 132; 
+	opFCOM = 133; 
+	opFCOMI = 134; 
+	opFCOMIP = 135; 
+	opFCOMP = 136; 
+	opFCOMPP = 137; 
+	opFCOS = 138; 
+	opFDECSTP = 139; 
+	opFDIV = 140; 
+	opFDIVP = 141; 
+	opFDIVR = 142; 
+	opFDIVRP = 143; 
+	opFEMMS = 144; 
+	opFFREE = 145; 
+	opFIADD = 146; 
+	opFICOM = 147; 
+	opFICOMP = 148; 
+	opFIDIV = 149; 
+	opFIDIVR = 150; 
+	opFILD = 151; 
+	opFIMUL = 152; 
+	opFINCSTP = 153; 
+	opFINIT = 154; 
+	opFIST = 155; 
+	opFISTP = 156; 
+	opFISTTP = 157; 
+	opFISUB = 158; 
+	opFISUBR = 159; 
+	opFLD = 160; 
+	opFLD1 = 161; 
+	opFLDCW = 162; 
+	opFLDENV = 163; 
+	opFLDL2E = 164; 
+	opFLDL2T = 165; 
+	opFLDLG2 = 166; 
+	opFLDLN2 = 167; 
+	opFLDPI = 168; 
+	opFLDZ = 169; 
+	opFMUL = 170; 
+	opFMULP = 171; 
+	opFNCLEX = 172; 
+	opFNINIT = 173; 
+	opFNOP = 174; 
+	opFNSAVE = 175; 
+	opFNSTCW = 176; 
+	opFNSTENV = 177; 
+	opFNSTSW = 178; 
+	opFPATAN = 179; 
+	opFPREM = 180; 
+	opFPREM1 = 181; 
+	opFPTAN = 182; 
+	opFRNDINT = 183; 
+	opFRSTOR = 184; 
+	opFSAVE = 185; 
+	opFSCALE = 186; 
+	opFSIN = 187; 
+	opFSINCOS = 188; 
+	opFSQRT = 189; 
+	opFST = 190; 
+	opFSTCW = 191; 
+	opFSTENV = 192; 
+	opFSTP = 193; 
+	opFSTSW = 194; 
+	opFSUB = 195; 
+	opFSUBP = 196; 
+	opFSUBR = 197; 
+	opFSUBRP = 198; 
+	opFTST = 199; 
+	opFUCOM = 200; 
+	opFUCOMI = 201; 
+	opFUCOMIP = 202; 
+	opFUCOMP = 203; 
+	opFUCOMPP = 204; 
+	opFWAIT = 205; 
+	opFXAM = 206; 
+	opFXCH = 207; 
+	opFXRSTOR = 208; 
+	opFXSAVE = 209; 
+	opFXTRACT = 210; 
+	opFYL2X = 211; 
+	opFYL2XP1 = 212; 
+	opHADDPD = 213; 
+	opHADDPS = 214; 
+	opHLT = 215; 
+	opHSUBPD = 216; 
+	opHSUBPS = 217; 
+	opIDIV* = 218; 
+	opIMUL* = 219; 
+	opIN* = 220; 
+	opINC* = 221; 
+	opINS = 222; 
+	opINSB = 223; 
+	opINSD = 224; 
+	opINSW = 225; 
+	opINT* = 226; 
+	opINT3* = 227; 
+	opINTO = 228; 
+	opINVD = 229; 
+	opINVLPG = 230; 
+	opINVLPGA = 231; 
+	opIRET = 232; 
+	opIRETD = 233; 
+	opIRETQ = 234; 
+	opJA* = 235; 
+	opJAE* = 236; 
+	opJB* = 237; 
+	opJBE* = 238; 
+	opJC* = 239; 
+	opJCXZ = 240; 
+	opJE* = 241; 
+	opJECXZ = 242; 
+	opJG* = 243; 
+	opJGE* = 244; 
+	opJL* = 245; 
+	opJLE* = 246; 
+	opJMP* = 247; 
+	opJNA = 248; 
+	opJNAE = 249; 
+	opJNB = 250; 
+	opJNBE = 251; 
+	opJNC* = 252; 
+	opJNE* = 253; 
+	opJNG = 254; 
+	opJNGE = 255; 
+	opJNL = 256; 
+	opJNLE = 257; 
+	opJNO = 258; 
+	opJNP = 259; 
+	opJNS = 260; 
+	opJNZ* = 261; 
+	opJO = 262; 
+	opJP = 263; 
+	opJPE = 264; 
+	opJPO = 265; 
+	opJRCXZ = 266; 
+	opJS = 267; 
+	opJZ = 268; 
+	opLAHF = 269; 
+	opLAR = 270; 
+	opLDDQU = 271; 
+	opLDMXCSR = 272; 
+	opLDS = 273; 
+	opLEA = 274; 
+	opLEAVE* = 275; 
+	opLES = 276; 
+	opLFENCE = 277; 
+	opLFS = 278; 
+	opLGDT = 279; 
+	opLGS = 280; 
+	opLIDT = 281; 
+	opLLDT = 282; 
+	opLMSW = 283; 
+	opLODS = 284; 
+	opLODSB = 285; 
+	opLODSD = 286; 
+	opLODSQ = 287; 
+	opLODSW = 288; 
+	opLOOP = 289; 
+	opLOOPE = 290; 
+	opLOOPNE = 291; 
+	opLOOPNZ = 292; 
+	opLOOPZ = 293; 
+	opLSL = 294; 
+	opLSS = 295; 
+	opLTR = 296; 
+	opMASKMOVDQU = 297; 
+	opMASKMOVQ = 298; 
+	opMAXPD = 299; 
+	opMAXPS = 300; 
+	opMAXSD = 301; 
+	opMAXSS = 302; 
+	opMFENCE = 303; 
+	opMINPD = 304; 
+	opMINPS = 305; 
+	opMINSD = 306; 
+	opMINSS = 307; 
+	opMOV* = 308; 
+	opMOVAPD = 309; 
+	opMOVAPS = 310; 
+	opMOVD* = 311; 
+	opMOVDDUP = 312; 
+	opMOVDQ2Q = 313; 
+	opMOVDQA = 314; 
+	opMOVDQU = 315; 
+	opMOVHLPS = 316; 
+	opMOVHPD = 317; 
+	opMOVHPS = 318; 
+	opMOVLHPS = 319; 
+	opMOVLPD = 320; 
+	opMOVLPS = 321; 
+	opMOVMSKPD = 322; 
+	opMOVMSKPS = 323; 
+	opMOVNTDQ = 324; 
+	opMOVNTI = 325; 
+	opMOVNTPD = 326; 
+	opMOVNTPS = 327; 
+	opMOVNTQ = 328; 
+	opMOVQ = 329; 
+	opMOVQ2DQ = 330; 
+	opMOVS = 331; 
+	opMOVSB* = 332; 
+	opMOVSD* = 333; 
+	opMOVSHDUP = 334; 
+	opMOVSLDUP = 335; 
+	opMOVSQ = 336; 
+	opMOVSS* = 337; 
+	opMOVSW = 338; 
+	opMOVSX* = 339; 
+	opMOVSXD* = 340; 
+	opMOVUPD = 341; 
+	opMOVUPS = 342; 
+	opMOVZX* = 343; 
+	opMUL* = 344; 
+	opMULPD = 345; 
+	opMULPS = 346; 
+	opMULSD* = 347; 
+	opMULSS* = 348; 
+	opNEG* = 349; 
+	opNOP* = 350; 
+	opNOT* = 351; 
+	opOR* = 352; 
+	opORPD = 353; 
+	opORPS = 354; 
+	opOUT* = 355; 
+	opOUTS = 356; 
+	opOUTSB = 357; 
+	opOUTSD = 358; 
+	opOUTSW = 359; 
+	opPACKSSDW = 360; 
+	opPACKSSWB = 361; 
+	opPACKUSWB = 362; 
+	opPADDB = 363; 
+	opPADDD = 364; 
+	opPADDQ = 365; 
+	opPADDSB = 366; 
+	opPADDSW = 367; 
+	opPADDUSB = 368; 
+	opPADDUSW = 369; 
+	opPADDW = 370; 
+	opPAND = 371; 
+	opPANDN = 372; 
+	opPAUSE = 373; 
+	opPAVGB = 374; 
+	opPAVGUSB = 375; 
+	opPAVGW = 376; 
+	opPCMPEQB = 377; 
+	opPCMPEQD = 378; 
+	opPCMPEQW = 379; 
+	opPCMPGTB = 380; 
+	opPCMPGTD = 381; 
+	opPCMPGTW = 382; 
+	opPEXTRW = 383; 
+	opPF2ID = 384; 
+	opPF2IW = 385; 
+	opPFACC = 386; 
+	opPFADD = 387; 
+	opPFCMPEQ = 388; 
+	opPFCMPGE = 389; 
+	opPFCMPGT = 390; 
+	opPFMAX = 391; 
+	opPFMIN = 392; 
+	opPFMUL = 393; 
+	opPFNACC = 394; 
+	opPFPNACC = 395; 
+	opPFRCP = 396; 
+	opPFRCPIT1 = 397; 
+	opPFRCPIT2 = 398; 
+	opPFRSQIT1 = 399; 
+	opPFRSQRT = 400; 
+	opPFSUB = 401; 
+	opPFSUBR = 402; 
+	opPI2FD = 403; 
+	opPI2FW = 404; 
+	opPINSRW = 405; 
+	opPMADDWD = 406; 
+	opPMAXSW = 407; 
+	opPMAXUB = 408; 
+	opPMINSW = 409; 
+	opPMINUB = 410; 
+	opPMOVMSKB = 411; 
+	opPMULHRW = 412; 
+	opPMULHUW = 413; 
+	opPMULHW = 414; 
+	opPMULLW = 415; 
+	opPMULUDQ = 416; 
+	opPOP* = 417; 
+	opPOPA = 418; 
+	opPOPAD = 419; 
+	opPOPAW = 420; 
+	opPOPF = 421; 
+	opPOPFD = 422; 
+	opPOPFQ = 423; 
+	opPOPFW = 424; 
+	opPOR = 425; 
+	opPREFETCH = 426; 
+	opPREFETCHNTA = 427; 
+	opPREFETCHT0 = 428; 
+	opPREFETCHT1 = 429; 
+	opPREFETCHT2 = 430; 
+	opPREFETCHW = 431; 
+	opPSADBW = 432; 
+	opPSHUFD = 433; 
+	opPSHUFHW = 434; 
+	opPSHUFLW = 435; 
+	opPSHUFW = 436; 
+	opPSLLD = 437; 
+	opPSLLDQ = 438; 
+	opPSLLQ = 439; 
+	opPSLLW = 440; 
+	opPSRAD = 441; 
+	opPSRAW = 442; 
+	opPSRLD = 443; 
+	opPSRLDQ = 444; 
+	opPSRLQ = 445; 
+	opPSRLW = 446; 
+	opPSUBB = 447; 
+	opPSUBD = 448; 
+	opPSUBQ = 449; 
+	opPSUBSB = 450; 
+	opPSUBSW = 451; 
+	opPSUBUSB = 452; 
+	opPSUBUSW = 453; 
+	opPSUBW = 454; 
+	opPSWAPD = 455; 
+	opPUNPCKHBW = 456; 
+	opPUNPCKHDQ = 457; 
+	opPUNPCKHQDQ = 458; 
+	opPUNPCKHWD = 459; 
+	opPUNPCKLBW = 460; 
+	opPUNPCKLDQ = 461; 
+	opPUNPCKLQDQ = 462; 
+	opPUNPCKLWD = 463; 
+	opPUSH* = 464; 
+	opPUSHA = 465; 
+	opPUSHAD = 466; 
+	opPUSHF = 467; 
+	opPUSHFD = 468; 
+	opPUSHFQ = 469; 
+	opPUSHFW = 470; 
+	opPXOR = 471; 
+	opRCL = 472; 
+	opRCPPS = 473; 
+	opRCPSS = 474; 
+	opRCR = 475; 
+	opRDMSR = 476; 
+	opRDPMC = 477; 
+	opRDTSC = 478; 
+	opRDTSCP = 479; 
+	opRET* = 480; 
+	opRETF = 481; 
+	opROL* = 482; 
+	opROR* = 483; 
+	opRSM = 484; 
+	opRSQRTPS = 485; 
+	opRSQRTSS = 486; 
+	opSAHF = 487; 
+	opSAL* = 488; 
+	opSAR* = 489; 
+	opSBB* = 490; 
+	opSCAS = 491; 
+	opSCASB = 492; 
+	opSCASD = 493; 
+	opSCASQ = 494; 
+	opSCASW = 495; 
+	opSETA* = 496; 
+	opSETAE* = 497; 
+	opSETB* = 498; 
+	opSETBE* = 499; 
+	opSETC* = 500; 
+	opSETE* = 501; 
+	opSETG* = 502; 
+	opSETGE* = 503; 
+	opSETL* = 504; 
+	opSETLE* = 505; 
+	opSETNA = 506; 
+	opSETNAE = 507; 
+	opSETNB = 508; 
+	opSETNBE = 509; 
+	opSETNC* = 510; 
+	opSETNE* = 511; 
+	opSETNG = 512; 
+	opSETNGE = 513; 
+	opSETNL = 514; 
+	opSETNLE = 515; 
+	opSETNO = 516; 
+	opSETNP = 517; 
+	opSETNS = 518; 
+	opSETNZ = 519; 
+	opSETO = 520; 
+	opSETP = 521; 
+	opSETPE = 522; 
+	opSETPO = 523; 
+	opSETS = 524; 
+	opSETZ = 525; 
+	opSFENCE = 526; 
+	opSGDT = 527; 
+	opSHL* = 528; 
+	opSHLD = 529; 
+	opSHR* = 530; 
+	opSHRD = 531; 
+	opSHUFPD = 532; 
+	opSHUFPS = 533; 
+	opSIDT = 534; 
+	opSKINIT = 535; 
+	opSLDT = 536; 
+	opSMSW = 537; 
+	opSQRTPD = 538; 
+	opSQRTPS = 539; 
+	opSQRTSD = 540; 
+	opSQRTSS = 541; 
+	opSTC = 542; 
+	opSTD* = 543; 
+	opSTGI = 544; 
+	opSTI = 545; 
+	opSTMXCSR = 546; 
+	opSTOS = 547; 
+	opSTOSB = 548; 
+	opSTOSD = 549; 
+	opSTOSQ = 550; 
+	opSTOSW = 551; 
+	opSTR = 552; 
+	opSUB* = 553; 
+	opSUBPD = 554; 
+	opSUBPS = 555; 
+	opSUBSD* = 556; 
+	opSUBSS* = 557; 
+	opSWAPGS = 558; 
+	opSYSCALL = 559; 
+	opSYSENTER = 560; 
+	opSYSEXIT = 561; 
+	opSYSRET = 562; 
+	opTEST = 563; 
+	opUCOMISD = 564; 
+	opUCOMISS = 565; 
+	opUD2 = 566; 
+	opUNPCKHPD = 567; 
+	opUNPCKHPS = 568; 
+	opUNPCKLPD = 569; 
+	opUNPCKLPS = 570; 
+	opVERR = 571; 
+	opVERW = 572; 
+	opVMLOAD = 573; 
+	opVMMCALL = 574; 
+	opVMRUN = 575; 
+	opVMSAVE = 576; 
+	opWBINVD = 577; 
+	opWRMSR = 578; 
+	opXADD = 579; 
+	opXCHG = 580; 
+	opXLAT = 581; 
+	opXLATB = 582; 
+	opXOR* = 583; 
+	opXORPD* = 584; 
+	opXORPS* = 585; 
+TYPE 
+	Name = ARRAY 20 OF CHAR; 
+
+	OperandType* = LONGINT; 
+
+	CPUOptions* = SET; 
+
+	Instruction = RECORD 
+		cpuoptions-: CPUOptions; 
+		options-: SET; 
+		opcode-: ARRAY 9 OF CHAR; 
+		operands-: ARRAY maxOperands OF OperandType; 
+		opCount-: LONGINT; 
+	END; 
+
+	Mnemonic = RECORD 
+		name-: ARRAY maxMnemonicNameLength OF CHAR; 
+		firstInstr-, lastInstr-: LONGINT; 
+	END; 
+
+	CPUType = RECORD 
+		name-: Name; 
+		cpuoptions-: CPUOptions; 
+	END; 
+
+	Register = RECORD 
+		name-: Name; 
+		type-: OperandType; 
+		index-: LONGINT; 
+	END; 
+VAR 
+	mnemonics-: ARRAY maxMnemonics OF Mnemonic; 
+	mnemCount: LONGINT; 
+	instructions-: ARRAY maxInstructions OF Instruction; 
+	instrCount: LONGINT; 
+	registers-: ARRAY maxRegisters OF Register; 
+	regCount: LONGINT; 
+	cpus-: ARRAY maxCPUs OF CPUType; 
+	cpuCount: LONGINT; 
+
+	PROCEDURE ^ FindMnem*(CONST mnem: ARRAY OF CHAR): LONGINT; 
+	PROCEDURE ^ FindReg*(CONST reg: ARRAY OF CHAR): LONGINT; 
+	PROCEDURE ^ FindCPU*(CONST cpu: ARRAY OF CHAR): LONGINT; 
+	PROCEDURE ^ Mnem(CONST name: ARRAY OF CHAR); 
+	PROCEDURE ^ Instr(op1, op2, op3: OperandType; CONST opcode: ARRAY OF CHAR; options: SET; cpuoptions: CPUOptions); 
+	PROCEDURE ^ Reg(CONST name: ARRAY OF CHAR; type: OperandType; index: LONGINT); 
+	PROCEDURE ^ Cpu(CONST name: ARRAY OF CHAR; cpuoptions: SET); 
+BEGIN
+END ASMAMD64.

lin32/bin/ASN1.SymU

@@ -0,0 +1,52 @@
+MODULE ASN1;
+	IMPORT Streams;
+CONST 
+	Trace = FALSE; 
+	ASN1Universal* = 0; 
+	ASN1Application* = 1; 
+	ASN1Context* = 2; 
+	ASN1Private* = 3; 
+	Boolean* = 1; 
+	Integer* = 2; 
+	BitString* = 3; 
+	String* = 4; 
+	Null* = 5; 
+	Oid* = 6; 
+	UTF8* = 12; 
+	PrintableString* = 19; 
+	TeletexString* = 20; 
+	IA5String* = 22; 
+	UTCTime* = 23; 
+	BMPString* = 30; 
+	Sequence* = 48; 
+	Set* = 49; 
+TYPE 
+	CharString* = POINTER TO ARRAY OF CHAR; 
+
+	Triplet* = OBJECT 
+	VAR 
+		tag*: LONGINT; 
+		class*: LONGINT; 
+		length*: LONGINT; 
+		unusedbits*: LONGINT; 
+		constructed*: BOOLEAN; 
+		definite*: BOOLEAN; 
+		bvalue*: BOOLEAN; 
+		ivalue*: LONGINT; 
+		svalue*: POINTER TO ARRAY OF CHAR; 
+		child*, curchild: Triplet; 
+		next*: Triplet; 
+		level*: LONGINT; 
+
+		PROCEDURE ^ AppendChild*(t: Triplet); 
+		PROCEDURE ^ Print*(w: Streams.Writer); 
+	END Triplet; 
+VAR 
+	log*: Streams.Writer; 
+
+	PROCEDURE ^ PrintHexString*(w: Streams.Writer; CONST s: ARRAY OF CHAR); 
+	PROCEDURE ^ PrintNumericString*(w: Streams.Writer; CONST s: ARRAY OF CHAR); 
+	PROCEDURE ^ PrintString*(w: Streams.Writer; CONST s: ARRAY OF CHAR); 
+	PROCEDURE ^ Decode*(reader: Streams.Reader; level: LONGINT; VAR len: LONGINT): Triplet; 
+BEGIN
+END ASN1.

lin32/bin/AVI.SymU

@@ -0,0 +1,170 @@
+MODULE AVI;
+	IMPORT SYSTEM, Machine, Streams, KernelLog, AOC := Codecs;
+CONST 
+	Debug = FALSE; 
+	DefaultReaderSize = 4096; 
+	WriteError = 2907; 
+TYPE 
+	MainAVIHeaderDesc* = OBJECT 
+	VAR 
+		microSecsPerFrame*: LONGINT; 
+		maxBytesPerSec*: LONGINT; 
+		reserved1*: LONGINT; 
+		flags*: LONGINT; 
+		totalFrames*: LONGINT; 
+		initialFrames*: LONGINT; 
+		streams*: LONGINT; 
+		suggestedBufferSize*: LONGINT; 
+		width*: LONGINT; 
+		height*: LONGINT; 
+		reserved*: ARRAY 4 OF LONGINT; 
+	END MainAVIHeaderDesc; 
+
+	AVIStreamHeader* = OBJECT 
+	VAR 
+		fccType*: ARRAY 4 OF CHAR; 
+		fccHandler*: ARRAY 4 OF CHAR; 
+		flags*: LONGINT; 
+		priority*: LONGINT; 
+		initialFrames*: LONGINT; 
+		scale*: LONGINT; 
+		rate*: LONGINT; 
+		start*: LONGINT; 
+		length*: LONGINT; 
+		suggestedBufferSize*: LONGINT; 
+		quality*: LONGINT; 
+		sampleSize*: LONGINT; 
+		left*: LONGINT; 
+		top*: LONGINT; 
+		right*: LONGINT; 
+		bottom*: LONGINT; 
+		streamIdentifier*: ARRAY 4 OF CHAR; 
+		bitMapInfo*: BitMapInfo; 
+		waveFormatEx*: WAVEFormatEx; 
+	END AVIStreamHeader; 
+
+	BitMapInfo = OBJECT 
+	VAR 
+		size*: LONGINT; 
+		width*: LONGINT; 
+		height*: LONGINT; 
+		planes*: LONGINT; 
+		bitCount*: LONGINT; 
+		compression*: LONGINT; 
+		sizeImage*: LONGINT; 
+		xPelsPerMeter*: LONGINT; 
+		yPelsPerMeter*: LONGINT; 
+		clrUsed*: LONGINT; 
+		clrImportant*: LONGINT; 
+	END BitMapInfo; 
+
+	WAVEFormatEx* = OBJECT 
+	VAR 
+		formatTag*: LONGINT; 
+		channels*: LONGINT; 
+		samplesPerSec*: LONGINT; 
+		avgBytesPerSec*: LONGINT; 
+		blockAlign*: LONGINT; 
+		bitsPerSample*: LONGINT; 
+		cbSize*: LONGINT; 
+	END WAVEFormatEx; 
+
+	AVIIndexEntry* = RECORD 
+		ckid*: LONGINT; 
+		flags*: LONGINT; 
+		offset*: LONGINT; 
+		length*: LONGINT; 
+		tot*: LONGINT; 
+	END; 
+
+	IndexArrayPointer* = POINTER TO ARRAY OF AVIIndexEntry; 
+
+	AVIStream* = OBJECT (AOC.DemuxStream)
+	VAR 
+		bufAdr: LONGINT; 
+		r: Streams.Reader; 
+		chunkSize*: LONGINT; 
+		streamHeader: AVIStreamHeader; 
+		stuffByte*: LONGINT; 
+		eof*: BOOLEAN; 
+
+		PROCEDURE ^  & Init*(r: Streams.Reader; streamHdr: AVIStreamHeader); 
+		PROCEDURE ^ CanSetPos*(): BOOLEAN; 
+		PROCEDURE ^ CompareCharArrays(ar1, ar2: ARRAY OF CHAR; len: LONGINT): BOOLEAN; 
+		PROCEDURE ^ ReadNextChunk(VAR buf: ARRAY OF CHAR); 
+		PROCEDURE ^ Resynch*(VAR buf: ARRAY OF CHAR): BOOLEAN; 
+		PROCEDURE ^ Pos*(): LONGINT; 
+		PROCEDURE ^ SetAVIPos*(pos: LONGINT; VAR retPos: LONGINT); 
+		PROCEDURE ^ Bytes*(VAR x: ARRAY OF CHAR; ofs, size: LONGINT; VAR len: LONGINT); 
+		PROCEDURE ^ SetPos*(pos: LONGINT); 
+	END AVIStream; 
+
+	AVIDemux* = OBJECT (AOC.AVDemultiplexer)
+	VAR 
+		r: Streams.Reader; 
+		filename*: ARRAY 256 OF CHAR; 
+		aviHeader: MainAVIHeaderDesc; 
+		audioStreamHeader: AVIStreamHeader; 
+		videoStreamHeader: AVIStreamHeader; 
+		riffLength: LONGINT; 
+		movieBeginPos: LONGINT; 
+		indexStart: LONGINT; 
+		videoFrames: LONGINT; 
+		audioChunks: LONGINT; 
+		videoIndex: IndexArrayPointer; 
+		audioIndex: IndexArrayPointer; 
+		audioBytes: LONGINT; 
+		videoBufferIndex: LONGINT; 
+		audioChunkSize: LONGINT; 
+		audioStream: AVIStream; 
+		videoStream: AVIStream; 
+		videoFramePos: LONGINT; 
+		audioFramePos: LONGINT; 
+
+		PROCEDURE ^ Open*(in: Streams.Reader; VAR res: LONGINT); 
+		PROCEDURE ^ GetAVIHeader*(): MainAVIHeaderDesc; 
+		PROCEDURE ^ CompareCharArrays(ar1, ar2: ARRAY OF CHAR; len: LONGINT): BOOLEAN; 
+		PROCEDURE ^ ReadHeader*(): BOOLEAN; 
+		PROCEDURE ^ ReadIndex*; 
+		PROCEDURE ^ SkipHeader*; 
+		PROCEDURE ^ ReadMainAVIHeader(): MainAVIHeaderDesc; 
+		PROCEDURE ^ ReadAVIStreamHeader(): AVIStreamHeader; 
+		PROCEDURE ^ ReadBitMapInfo(): BitMapInfo; 
+		PROCEDURE ^ ReadWaveFormatEx(): WAVEFormatEx; 
+		PROCEDURE ^ DumpHeaders*; 
+		PROCEDURE ^ DumpVideoIndex*; 
+		PROCEDURE ^ DumpAudioIndex*; 
+		PROCEDURE ^ GetAudioStreamHeader*(): AVIStreamHeader; 
+		PROCEDURE ^ GetVideoStreamHeader*(): AVIStreamHeader; 
+		PROCEDURE ^ GetStream*(streamNr: LONGINT): AOC.DemuxStream; 
+		PROCEDURE ^ GetMilliSecondsPerFrame*(): LONGINT; 
+		PROCEDURE ^ GetNofChannels*(): LONGINT; 
+		PROCEDURE ^ GetSamplesPerSecond*(): LONGINT; 
+		PROCEDURE ^ GetBitsPerSample*(): LONGINT; 
+		PROCEDURE ^ GetVideoIndex*(): IndexArrayPointer; 
+		PROCEDURE ^ GetAudioIndex*(): IndexArrayPointer; 
+		PROCEDURE ^ GetAudioChunks*(): LONGINT; 
+		PROCEDURE ^ GetAudioBytes*(): LONGINT; 
+		PROCEDURE ^ GetVideoFrames*(): LONGINT; 
+		PROCEDURE ^ GetNumberOfStreams*(): LONGINT; 
+		PROCEDURE ^ GetStreamInfo*(streamNr: LONGINT): AOC.AVStreamInfo; 
+		PROCEDURE ^ GetStreamType*(streamNr: LONGINT): LONGINT; 
+		PROCEDURE ^ GetInfo*(VAR vl, vf, vr, mspf, al, af, ar: LONGINT); 
+		PROCEDURE ^ GetData*(streamNr: LONGINT; VAR buf: ARRAY OF CHAR; ofs, size, min: LONGINT; VAR len, res: LONGINT); 
+		PROCEDURE ^ SetStreamPos*(streamNr: LONGINT; seekType: LONGINT; pos: LONGINT; VAR itemSize: LONGINT; VAR res: LONGINT); 
+		PROCEDURE ^ GetVideoWidth*(): LONGINT; 
+		PROCEDURE ^ GetVideoHeight*(): LONGINT; 
+		PROCEDURE ^ GetNextFrameSize*(streamNr: LONGINT): LONGINT; 
+		PROCEDURE ^ GetSampleSize*(): LONGINT; 
+	END AVIDemux; 
+
+	PROCEDURE ^ Align*(VAR index: LONGINT); 
+	PROCEDURE ^ IsAligned*(index: LONGINT): BOOLEAN; 
+	PROCEDURE ^ ShowBitsSlow*(n: LONGINT; VAR buf: ARRAY OF CHAR; VAR index: LONGINT): LONGINT; 
+	PROCEDURE ^ ShowBits*(n: LONGINT; VAR buf: ARRAY OF CHAR; VAR index: LONGINT): LONGINT; 
+	PROCEDURE ^ ShowBitsByteAligned*(n: LONGINT; VAR buf: ARRAY OF CHAR; VAR index: LONGINT): LONGINT; 
+	PROCEDURE ^ GetBits*(n: LONGINT; VAR buf: ARRAY OF CHAR; VAR index: LONGINT): LONGINT; 
+	PROCEDURE ^ SkipBits*(n: LONGINT; VAR index: LONGINT); 
+	PROCEDURE ^ Factory*(): AOC.AVDemultiplexer; 
+BEGIN
+END AVI.

lin32/bin/ActiveTimers.SymU

@@ -0,0 +1,18 @@
+MODULE ActiveTimers;
+	IMPORT Objects;
+TYPE 
+	Timer* = OBJECT {EXCLUSIVE} 
+	VAR 
+		timer: Objects.Timer; 
+		handler: Objects.EventHandler; 
+		timeout, running: BOOLEAN; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ SetTimeout*(h: Objects.EventHandler; ms: LONGINT); 
+		PROCEDURE ^ CancelTimeout*; 
+		PROCEDURE ^ HandleTimeout; 
+		PROCEDURE ^ Finalize*; 
+	BEGIN{ACTIVE} 
+	END Timer; 
+BEGIN
+END ActiveTimers.

lin32/bin/AlmSmtpReceiver.SymU

@@ -0,0 +1,143 @@
+MODULE AlmSmtpReceiver;
+	IMPORT DNS, Files, Streams, IP, Modules, KernelLog, TCP, TCPServices, Dates, Strings;
+CONST 
+	AlmSmtpReceiverPort = 25; 
+	MaxActive = (3 + 1); 
+	ID = \"BlueBottle Receiver "\; 
+	Version = \"MailBottle (0.2.00.16)"\; 
+	Rcp = \".Rcp"\; 
+	Msg = \".Msg"\; 
+	Log = \".Log"\; 
+	ConfigFileName = \"mail.config"\; 
+	ToDisk = TRUE; 
+	DebugMsg = FALSE; 
+	RcptInFileName = TRUE; 
+	MaxUserName = 11; 
+	Prefix = \"In."\; 
+	AlwaysAccept = \"129.132.178.196"\; 
+	EOF = 0X; 
+	maxLexLen = 127; 
+	noSym = 13; 
+	maxP = 13; 
+	maxT = 13; 
+	nrSets = 3; 
+	setSize = 32; 
+	nSets = ((maxT DIV setSize) + 1); 
+	SyEol = 1; 
+	SyCopy = 2; 
+	SyHelo = 3; 
+	SyQuit = 4; 
+	SyNoop = 5; 
+	SyRset = 6; 
+	SyData = 7; 
+	SyDot = 8; 
+	SyRcpt = 9; 
+	SyTo = 10; 
+	SyMail = 11; 
+	SyFrom = 12; 
+	SyTimeout = 14; 
+	Tab = 9X; 
+	LF = 0AX; 
+	CR = 0DX; 
+TYPE 
+	ErrorProc* = PROCEDURE (n: INTEGER); 
+
+	StartTable = ARRAY 128 OF INTEGER; 
+
+	SymbolSet = ARRAY nSets OF SET; 
+
+	String = ARRAY 128 OF CHAR; 
+
+	TokenPtr = POINTER TO Token; 
+
+	Token = RECORD 
+		s: String; 
+		next: TokenPtr; 
+	END; 
+
+	EnvelopePtr = POINTER TO Envelope; 
+
+	Envelope = RECORD 
+		mta, revMta, from: String; 
+		to: TokenPtr; 
+	END; 
+
+	Message* = RECORD 
+		env*: EnvelopePtr; 
+		file*: Files.File; 
+	END; 
+
+	SmtpAgent* = OBJECT {EXCLUSIVE} (TCPServices.Agent)
+	VAR 
+		ch: CHAR; 
+		res: LONGINT; 
+		out: Streams.Writer; 
+		in: Streams.Reader; 
+		log: Files.Writer; 
+		env: Envelope; 
+		thisName, verbSy: String; 
+		finished: BOOLEAN; 
+		sym: INTEGER; 
+		state: INTEGER; 
+		badTokens: LONGINT; 
+		auxString: String; 
+
+		PROCEDURE ^ GetCh(): CHAR; 
+		PROCEDURE ^ ConsumeName; 
+		PROCEDURE ^ AvailableName; 
+		PROCEDURE ^ OpenLog; 
+		PROCEDURE ^ ToMemory*(VAR token: ARRAY OF CHAR); 
+		PROCEDURE ^ DebugMsg1*(msg: ARRAY OF CHAR); 
+		PROCEDURE ^ PutStatus1*(msg: ARRAY OF CHAR); 
+		PROCEDURE ^ ChangeStatus1*(newsym: INTEGER; msg: ARRAY OF CHAR); 
+		PROCEDURE ^ PutStatus2*(msg0, msg1: ARRAY OF CHAR); 
+		PROCEDURE ^ ChangeStatus2*(newsym: INTEGER; msg0, msg1: ARRAY OF CHAR); 
+		PROCEDURE ^ AddExt*(VAR name: String; ext: ARRAY OF CHAR); 
+		PROCEDURE ^ PutBareName(name: String; VAR wr: Files.Writer); 
+		PROCEDURE ^ PutEnvelope(name: String); 
+		PROCEDURE ^ UpdateName(VAR s: String); 
+		PROCEDURE ^ HELO*; 
+		PROCEDURE ^ RSET*; 
+		PROCEDURE ^ NOOP*; 
+		PROCEDURE ^ QUIT*; 
+		PROCEDURE ^ RCPT*; 
+		PROCEDURE ^ Test; 
+		PROCEDURE ^ ToFile(name: String); 
+		PROCEDURE ^ DATA*(name: String); 
+		PROCEDURE ^ AddUserToName(VAR thisName: String); 
+		PROCEDURE ^ MAIL*; 
+		PROCEDURE ^ reset; 
+		PROCEDURE ^ Get; 
+		PROCEDURE ^ ErrMsg(msg: String); 
+		PROCEDURE ^ Error1(n: INTEGER); 
+		PROCEDURE ^ Error2(n, sym: INTEGER); 
+		PROCEDURE ^ Confirm(n: INTEGER); 
+		PROCEDURE ^ Expect(n: INTEGER); 
+		PROCEDURE ^ StartOf(s: INTEGER): BOOLEAN; 
+		PROCEDURE ^ Who; 
+		PROCEDURE ^ BackStagePass(pass: String): BOOLEAN; 
+	BEGIN{ACTIVE} 
+	END SmtpAgent; 
+VAR 
+	errors*: INTEGER; 
+	lasterror*: INTEGER; 
+	charcount: LONGINT; 
+	getCalls: LONGINT; 
+	start: StartTable; 
+	Pattern, Ack: ARRAY 6 OF CHAR; 
+	active: LONGINT; 
+	symSet: ARRAY nrSets OF SymbolSet; 
+	smtp: TCPServices.Service; 
+	nextName: String; 
+
+	PROCEDURE ^ ToLog0(msg: String); 
+	PROCEDURE ^ InitSmtpSTable; 
+	PROCEDURE ^ NewSmtpAgent(c: TCP.Connection; s: TCPServices.Service): TCPServices.Agent; 
+	PROCEDURE ^ GetRegistry(VAR filename: String); 
+	PROCEDURE ^ PutRegistry(VAR filename: String); 
+	PROCEDURE ^ Announce(VAR out: Streams.Writer); 
+	PROCEDURE ^ Open*; 
+	PROCEDURE ^ Close*; 
+	PROCEDURE ^ Cleanup; 
+BEGIN
+END AlmSmtpReceiver.

lin32/bin/AnimationCodec.SymU

@@ -0,0 +1,51 @@
+MODULE AnimationCodec;
+	IMPORT Streams, KernelLog, Strings, Files, Codecs, XML, XMLScanner, XMLParser, WMGraphics;
+CONST 
+	Version = \"ANI09a"\; 
+	HeaderMissing* = 20001; 
+	HeaderError* = 20002; 
+	WrongVersion* = 20003; 
+	FormatError* = 20004; 
+	ImageNotFound* = 20010; 
+	XmlHeader = \"Header"\; 
+	XmlVersion = \"version"\; 
+	XmlWidth = \"width"\; 
+	XmlHeight = \"height"\; 
+	XmlBackgroundColor = \"bgcolor"\; 
+	XmlFrames = \"Frames"\; 
+	XmlFrame = \"Frame"\; 
+	XmlImageName = \"image"\; 
+	XmlLeft = \"x"\; 
+	XmlTop = \"y"\; 
+	XmlDelayTime = \"time"\; 
+	XmlDisposeMode = \"mode"\; 
+	XmlFrom = \"from"\; 
+	XmlTo = \"to"\; 
+	Debug = TRUE; 
+TYPE 
+	Settings = RECORD 
+		x, y: LONGINT; 
+		time, mode: LONGINT; 
+	END; 
+
+	Decoder* = OBJECT (Codecs.AnimationDecoder)
+	VAR 
+		animation: XML.Element; 
+		width, height, bgcolor: LONGINT; 
+		default: Settings; 
+		error: BOOLEAN; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ RestoreDefaultSettings; 
+		PROCEDURE ^ ReportError(pos, line, col: LONGINT; CONST msg: ARRAY OF CHAR); 
+		PROCEDURE ^ Open*(in: Streams.Reader; VAR res: LONGINT); 
+		PROCEDURE ^ ProcessFrame(frame: XML.Element; VAR desc: Codecs.ImageDescriptor; VAR res: LONGINT); 
+		PROCEDURE ^ ProcessFrames(frames: XML.Element; VAR sequence: Codecs.ImageSequence; VAR res: LONGINT); 
+		PROCEDURE ^ GetImageSequence*(VAR sequence: Codecs.ImageSequence; VAR res: LONGINT); 
+	END Decoder; 
+
+	PROCEDURE ^ GenerateFilename(CONST base: ARRAY OF CHAR; VAR filename: ARRAY OF CHAR; suffix, minDigits: LONGINT); 
+	PROCEDURE ^ GetInteger(element: XML.Element; CONST attributeName: ARRAY OF CHAR; VAR value: LONGINT): BOOLEAN; 
+	PROCEDURE ^ GenDecoder*(): Codecs.AnimationDecoder; 
+BEGIN
+END AnimationCodec.

lin32/bin/Archives.SymU

@@ -0,0 +1,42 @@
+MODULE Archives;
+	IMPORT Configuration, Strings, Streams;
+CONST 
+	ArchiveNameSize = 128; 
+TYPE 
+	StringObject* = OBJECT 
+	VAR 
+		value-: ARRAY 256 OF CHAR; 
+
+		PROCEDURE ^  & Init*(CONST name: ARRAY OF CHAR); 
+	END StringObject; 
+
+	EntryInfo* = OBJECT 
+
+		PROCEDURE ^ GetName*(): Strings.String; 
+		PROCEDURE ^ GetSize*(): LONGINT; 
+		PROCEDURE ^ GetInfoString*(): Strings.String; 
+	END EntryInfo; 
+
+	Index* = POINTER TO ARRAY OF EntryInfo; 
+
+	Archive* = OBJECT 
+	VAR 
+		name*: ARRAY ArchiveNameSize OF CHAR; 
+
+		PROCEDURE ^ Acquire*; 
+		PROCEDURE ^ Release*; 
+		PROCEDURE ^ GetIndex*(): Index; 
+		PROCEDURE ^ GetEntryInfo*(CONST name: ARRAY OF CHAR): EntryInfo; 
+		PROCEDURE ^ RemoveEntry*(CONST name: ARRAY OF CHAR); 
+		PROCEDURE ^ RenameEntry*(CONST from, to: ARRAY OF CHAR): EntryInfo; 
+		PROCEDURE ^ OpenSender*(CONST name: ARRAY OF CHAR): Streams.Sender; 
+		PROCEDURE ^ OpenReceiver*(CONST name: ARRAY OF CHAR): Streams.Receiver; 
+		PROCEDURE ^ Copy*(CONST name: ARRAY OF CHAR): Archive; 
+	END Archive; 
+
+	FactoryProcedure = PROCEDURE (name: StringObject):Archive; 
+
+	PROCEDURE ^ Old*(CONST name, type: ARRAY OF CHAR): Archive; 
+	PROCEDURE ^ New*(CONST name, type: ARRAY OF CHAR): Archive; 
+BEGIN
+END Archives.

lin32/bin/Array1dBytes.SymU

@@ -0,0 +1,188 @@
+MODULE Array1dBytes;
+	IMPORT SYSTEM;
+TYPE 
+	Bytes* = POINTER TO ARRAY OF SYSTEM.BYTE; 
+
+	Byte* = SYSTEM.BYTE; 
+
+	Word* = ARRAY 2 OF SYSTEM.BYTE; 
+
+	DWord* = ARRAY 4 OF SYSTEM.BYTE; 
+
+	QWord* = ARRAY 8 OF SYSTEM.BYTE; 
+
+	PROCEDURE {FingerPrint(-1807882291)}  - AdrCheck*(adr, lower, size: LONGINT);
+	CODE {SYSTEM.i386}
+		MOV	ECX, [ESP]	;  upper
+		MOV	EBX, [ESP+4]	;  lower
+		MOV	EAX, [ESP+8]	;  adr
+		CMP	EAX, EBX
+		JAE	lowerok	;  offset >= adr?
+		PUSH	7
+		INT	3
+		lowerok: ;  offset >= adr
+		ADD	ECX, EBX
+		CMP	EAX, ECX
+		JB	upperok	;  offset < upper?
+		PUSH	7
+		INT	3
+		upperok: ;  offset < upper
+		ADD	ESP, 12	;  adjust stack pointer(inline procedure!)
+	
+	END AdrCheck; 
+	PROCEDURE {FingerPrint(-712869057)}  - RangeCheck*(offset, len, upper: LONGINT);
+	CODE {SYSTEM.i386}
+		MOV	ECX, [ESP]	;  upper
+		MOV	EBX, [ESP+4]	;  len
+		MOV	EAX, [ESP+8]	;  offset
+		CMP	EAX, 0
+		JAE	lowerok	;  offset >= 0?
+		PUSH	7
+		INT	3
+		lowerok: ;  offset >= 0
+		CMP	EBX, 0
+		JAE	lenok	;  len >= 0?
+		PUSH	7
+		INT	3
+		lenok: ;  len >= 0
+		ADD	EAX, EBX
+		CMP	EAX, ECX
+		JBE	upperok	;  offset+len <= upper?
+		PUSH	7
+		INT	3
+		upperok: ;  offset+len <= upper
+		ADD	ESP, 12	;  adjust stack pointer(inline procedure!)
+	
+	END RangeCheck; 
+	PROCEDURE {FingerPrint(1427773561)}  - RangeCheck2*(x, y, w, h, width, height: LONGINT);
+	CODE {SYSTEM.i386}
+		MOV	ECX, [ESP]	;  upper = height
+		MOV	EBX, [ESP+8]	;  len = h
+		MOV	EAX, [ESP+16]	;  offset = y
+		CMP	EAX, 0
+		JAE	lowerok	;  offset >= 0?
+		PUSH	7
+		INT	3
+		lowerok: ;  offset >= 0
+		CMP	EBX, 0
+		JAE	lenok	;  len >= 0?
+		PUSH	7
+		INT	3
+		lenok: ;  len >= 0
+		ADD	EAX, EBX
+		CMP	EAX, ECX
+		JBE	upperok	;  offset+len <= upper?
+		PUSH	7
+		INT	3
+		upperok: ;  offset+len <= upper
+		MOV	ECX, [ESP+4]	;  upper = width
+		MOV	EBX, [ESP+12]	;  len = w
+		MOV	EAX, [ESP+20]	;  offset = x
+		CMP	EAX, 0
+		JAE	lowerok2	;  offset >= 0?
+		PUSH	7
+		INT	3
+		lowerok2: ;  offset >= 0
+		CMP	EBX, 0
+		JAE	lenok2	;  len >= 0?
+		PUSH	7
+		INT	3
+		lenok2: ;  len >= 0
+		ADD	EAX, EBX
+		CMP	EAX, ECX
+		JBE	upperok2	;  offset+len <= upper?
+		PUSH	7
+		INT	3
+		upperok2: ;  offset+len <= upper
+		ADD	ESP, 24	;  adjust stack pointer(inline procedure!)
+	
+	END RangeCheck2; 
+	PROCEDURE {FingerPrint(2123246868)}  - PatRangeCheck*(offset, step, piecelen, pieces, upper: LONGINT);
+	CODE {SYSTEM.i386}
+		MOV	EDI, [ESP]	;  upper
+		MOV	EDX, [ESP+4]	;  pieces
+		MOV	ECX, [ESP+8]	;  piecelen
+		MOV	EBX, [ESP+12]	;  step
+		MOV	EAX, [ESP+16]	;  offset
+		CMP	EBX, 0
+		JAE	piecesok	;  pieces >= 0?
+		PUSH	7
+		INT	3
+		piecesok: ;  pieces >= 0
+		CMP	ECX, 0
+		JA	piecelenok	;  piecelen > 0?
+		PUSH	7
+		INT	3
+		piecelenok: ;  piecelen > 0
+		CMP	EBX, ECX
+		JAE	stepok	;  step >= piecelen?
+		PUSH	7
+		INT	3
+		stepok: ;  step >= piecelen > 0
+		CMP	EAX, 0
+		JAE	lowerok	;  offset >= 0?
+		PUSH	7
+		INT	3
+		lowerok: ;  offset >= 0
+		CMP	EDX, 0
+		JE	nocalc	;  pieces = 0?
+		DEC	EDX
+		IMUL	EDX, EBX	;  EDX := (pieces-1)*step	;
+		ADD	EDX, ECX	;  INC(EDX, piecelen)
+		ADD	EDX, EAX	;  INC(EDX, offset)
+		nocalc:
+		CMP	EDX, EDI
+		JBE	upperok	;  offset+(pieces-1)*step+piecelen <= upper?
+		PUSH	7
+		INT	3
+		upperok:
+		ADD	ESP, 20	;  adjust stack pointer(inline procedure!)
+	
+	END PatRangeCheck; 
+	PROCEDURE {FingerPrint(1857348743)}  - MoveB*(srcadr, destadr, len: LONGINT);
+	CODE {SYSTEM.i386}
+		MOV	ECX, [ESP]	;  len
+		MOV	EDI, [ESP+4]	;  destadr
+		MOV	ESI, [ESP+8]	;  srcadr
+		CMP	ESI, EDI
+		JAE	moveup	;  src adr greater then dest adr, no problem with moving up
+		MOV	EAX, ESI
+		ADD	EAX, ECX
+		CMP	EAX, EDI
+		JBE	moveup	;  no overlap, no problem, move up
+		MOV	ESI, EAX
+		ADD	EDI, ECX
+		DEC	ESI
+		DEC	EDI
+		STD	;  move down since overlap occured
+		REP
+		MOVSB
+		JMP	done
+		moveup:
+		CLD
+		MOV	BL, CL
+		SHR	ECX, 2
+		AND	BL, 00000003H	;  rest to move after 4 byte move
+		REP
+		MOVSD	;  move 4 bytes each step
+		MOV	CL, BL
+		REP
+		MOVSB	;  move rest in one byte steps
+		done:
+		ADD	ESP, 12	;  adjust stack pointer(inline procedure!)
+	
+	END MoveB; 
+	PROCEDURE ^ MoveBPat*(srcadr, destadr, srcstep, deststep, piecelen, pieces: LONGINT); 
+	PROCEDURE ^ FillB*(adr: LONGINT; byte: SYSTEM.BYTE; count: LONGINT); 
+	PROCEDURE ^ FillBPat*(adr: LONGINT; byte: SYSTEM.BYTE; step, piecelen, pieces: LONGINT); 
+	PROCEDURE ^ FillW*(adr: LONGINT; word: Word; count: LONGINT); 
+	PROCEDURE ^ FillWPat*(adr: LONGINT; word: Word; step, piecelen, pieces: LONGINT); 
+	PROCEDURE ^ FillD*(adr: LONGINT; dword: DWord; count: LONGINT); 
+	PROCEDURE ^ FillDPat*(adr: LONGINT; dword: DWord; step, piecelen, pieces: LONGINT); 
+	PROCEDURE ^ FillQ*(adr: LONGINT; qword: QWord; count: LONGINT); 
+	PROCEDURE ^ FillG*(adr: LONGINT; VAR data: ARRAY OF SYSTEM.BYTE; count: LONGINT); 
+	PROCEDURE ^ FillGPat*(adr: LONGINT; VAR data: ARRAY OF SYSTEM.BYTE; step, piecelen, pieces: LONGINT); 
+	PROCEDURE ^ Fill*(adr: LONGINT; VAR data: ARRAY OF SYSTEM.BYTE; len: LONGINT); 
+	PROCEDURE ^ FillPat*(adr: LONGINT; VAR data: ARRAY OF SYSTEM.BYTE; step, piecelen, pieces: LONGINT); 
+BEGIN
+END Array1dBytes.

lin32/bin/Array1dCplx.SymU

@@ -0,0 +1,125 @@
+MODULE Array1dCplx;
+	IMPORT SYSTEM, Array1dBytes, NbrCplx, NbrRe, NbrRat, NbrInt, DataErrors, Array1dInt, Array1dRat, Array1dRe;
+CONST 
+	assertSrcIndexCheck* = 1000; 
+	assertDestIndexCheck* = 1001; 
+	sz = SIZEOF(Value); 
+TYPE 
+	Value* = NbrCplx.Complex; 
+
+	RealValue* = NbrRe.Real; 
+
+	Array* = POINTER TO ARRAY OF Value; 
+
+	Index* = LONGINT; 
+
+	Map* = PROCEDURE {DELEGATE}(VAR i: Value); 
+
+	PROCEDURE ^ Copy*(VAR x: ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ CreateCopy*(VAR x: ARRAY OF Value): Array; 
+	PROCEDURE ^ CopyPat*(VAR x: ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ CreateCopyPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): Array; 
+	PROCEDURE ^ Fill*(x: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ FillPat*(x: Value; VAR res: ARRAY OF Value; offset, step, piecelen, pieces: Index); 
+	PROCEDURE ^ Negate*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ NegatePat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index); 
+	PROCEDURE ^ Abs*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ AbsPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index); 
+	PROCEDURE ^ AddAA*(VAR x, y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ SubtractAA*(VAR x, y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ MultAA*(VAR x, y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ ScalarProduct*(VAR x, y: ARRAY OF Value; VAR res: Value; offset, len: Index); 
+	PROCEDURE ^ DivAA*(VAR x, y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ EqualsAA*(VAR x, y: ARRAY OF Value; offset, len: Index): BOOLEAN; 
+	PROCEDURE ^ AddAV*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ AddAVPat*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ SubtractAV*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ SubtractAVPat*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ SubtractVA*(VAR x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ SubtractVAPat*(x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ MultAV*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ MultAVPat*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ DivAV*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ DivAVPat*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ DivVA*(x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ DivVAPat*(x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ ApplyMap*(map: Map; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ ApplyMapPat*(map: Map; VAR res: ARRAY OF Value; offset, step, piecelen, pieces: Index); 
+	PROCEDURE ^ MeanSsq*(VAR x: ARRAY OF Value; offset, len: Index; VAR mean: Value; VAR ssq: RealValue); 
+	PROCEDURE ^ HammingWeight*(VAR x: ARRAY OF Value; offset, len: Index): Index; 
+	PROCEDURE ^ HammingWeightPat*(map: Map; VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): Index; 
+	PROCEDURE ^ HammingDist*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): Index; 
+	PROCEDURE ^ L1Norm*(VAR x: ARRAY OF Value; offset, len: Index): RealValue; 
+	PROCEDURE ^ L1NormPat*(map: Map; VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): RealValue; 
+	PROCEDURE ^ L1Dist*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): RealValue; 
+	PROCEDURE ^ L2NormSq*(VAR x: ARRAY OF Value; offset, len: Index): NbrRe.Real; 
+	PROCEDURE ^ L2Norm*(VAR x: ARRAY OF Value; offset, len: Index): NbrRe.Real; 
+	PROCEDURE ^ L2NormPatSq*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): NbrRe.Real; 
+	PROCEDURE ^ L2NormPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): NbrRe.Real; 
+	PROCEDURE ^ L2DistSq*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): NbrRe.Real; 
+	PROCEDURE ^ L2Dist*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): NbrRe.Real; 
+	PROCEDURE ^ LInftyNorm*(VAR x: ARRAY OF Value; offset, len: Index): RealValue; 
+	PROCEDURE ^ LInftyNormPat*(map: Map; VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): RealValue; 
+	PROCEDURE ^ LInftyDist*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): RealValue; 
+	PROCEDURE ^ MinIndex(x, y: Index): Index; 
+	PROCEDURE ^ SetLen*(VAR a: Array; len: Index); 
+	PROCEDURE ^ RemoveBlock*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ InsertBlock*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ ShiftBlock*(VAR x: ARRAY OF Value; from, to, len: Index); 
+	PROCEDURE ^ RemovePat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: LONGINT): Array; 
+	PROCEDURE ^ Remove*(VAR x: ARRAY OF Value; offset, len: LONGINT): Array; 
+	PROCEDURE ^ InsertPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: LONGINT): Array; 
+	PROCEDURE ^ Insert*(VAR x: ARRAY OF Value; offset, len: LONGINT): Array; 
+	PROCEDURE ^ GetPieces*(VAR a: ARRAY OF Value; offset, step, piecelen: LONGINT): LONGINT; 
+	PROCEDURE ^ SortByIndex*(VAR x: ARRAY OF Value; VAR index: ARRAY OF Index; offset, len: Index); 
+	OPERATOR ^ "-"-(x: Array): Array; 
+	OPERATOR ^ "~"-(x: Array): Array; 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF Value); 
+	OPERATOR ^ ":="-(VAR l: Array; r: Array1dRe.Array); 
+	OPERATOR ^ ":="-(VAR l: Array; r: Array1dRat.Array); 
+	OPERATOR ^ ":="-(VAR l: Array; r: Array1dInt.Array); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF NbrRe.Real); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF NbrRat.Rational); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF NbrInt.Integer); 
+	OPERATOR ^ "="-(l: Array; VAR r: ARRAY OF Value): BOOLEAN; 
+	OPERATOR ^ "="-(VAR l: ARRAY OF Value; r: Array): BOOLEAN; 
+	OPERATOR ^ ":="-(VAR l: Array; r: Value); 
+	OPERATOR ^ "+"-(l, r: Array): Array; 
+	OPERATOR ^ "+"-(l: Array; r: Array1dRe.Array): Array; 
+	OPERATOR ^ "+"-(l: Array1dRe.Array; r: Array): Array; 
+	OPERATOR ^ "+"-(l: Array; r: Array1dRat.Array): Array; 
+	OPERATOR ^ "+"-(l: Array1dRat.Array; r: Array): Array; 
+	OPERATOR ^ "+"-(l: Array; r: Array1dInt.Array): Array; 
+	OPERATOR ^ "+"-(l: Array1dInt.Array; r: Array): Array; 
+	OPERATOR ^ "+"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "+"-(r: Value; l: Array): Array; 
+	OPERATOR ^ "-"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "-"-(l: Value; r: Array): Array; 
+	OPERATOR ^ "-"-(l, r: Array): Array; 
+	OPERATOR ^ "-"-(l: Array; r: Array1dRe.Array): Array; 
+	OPERATOR ^ "-"-(l: Array1dRe.Array; r: Array): Array; 
+	OPERATOR ^ "-"-(l: Array; r: Array1dRat.Array): Array; 
+	OPERATOR ^ "-"-(l: Array1dRat.Array; r: Array): Array; 
+	OPERATOR ^ "-"-(l: Array; r: Array1dInt.Array): Array; 
+	OPERATOR ^ "-"-(l: Array1dInt.Array; r: Array): Array; 
+	OPERATOR ^ "*"-(l, r: Array): Value; 
+	OPERATOR ^ "*"-(l: Array; r: Array1dRe.Array): NbrCplx.Complex; 
+	OPERATOR ^ "*"-(l: Array1dRe.Array; r: Array): NbrCplx.Complex; 
+	OPERATOR ^ "*"-(l: Array; r: Array1dRat.Array): NbrCplx.Complex; 
+	OPERATOR ^ "*"-(l: Array1dRat.Array; r: Array): NbrCplx.Complex; 
+	OPERATOR ^ "*"-(l: Array; r: Array1dInt.Array): NbrCplx.Complex; 
+	OPERATOR ^ "*"-(l: Array1dInt.Array; r: Array): NbrCplx.Complex; 
+	OPERATOR ^ "*"-(l: Value; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "*"-(l: NbrRe.Real; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: NbrRe.Real): Array; 
+	OPERATOR ^ "*"-(l: NbrRat.Rational; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: NbrRat.Rational): Array; 
+	OPERATOR ^ "*"-(l: NbrInt.Integer; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: NbrInt.Integer): Array; 
+	OPERATOR ^ "/"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "/"-(l: Array; r: NbrRe.Real): Array; 
+	OPERATOR ^ "/"-(l: Array; r: NbrRat.Rational): Array; 
+	OPERATOR ^ "/"-(l: Array; r: NbrInt.Integer): Array; 
+BEGIN
+END Array1dCplx.

lin32/bin/Array1dInt.SymU

@@ -0,0 +1,113 @@
+MODULE Array1dInt;
+	IMPORT SYSTEM, Array1dBytes, DataErrors, NbrInt, NbrInt64, NbrRe;
+CONST 
+	sz = SIZEOF(Value); 
+TYPE 
+	Value* = NbrInt.Integer; 
+
+	LongerValue* = NbrInt64.Integer; 
+
+	ShorterValue* = INTEGER; 
+
+	RealValue* = NbrRe.Real; 
+
+	Array* = POINTER TO ARRAY OF Value; 
+
+	Index* = LONGINT; 
+
+	Map* = PROCEDURE {DELEGATE}(VAR i: Value); 
+
+	PROCEDURE ^ Copy*(VAR x: ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ CreateCopy*(VAR x: ARRAY OF Value): Array; 
+	PROCEDURE ^ CopyPat*(VAR x: ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ CreateCopyPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): Array; 
+	PROCEDURE ^ Fill*(x: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ FillPat*(x: Value; VAR res: ARRAY OF Value; offset, step, piecelen, pieces: Index); 
+	PROCEDURE ^ Negate*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ NegatePat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index); 
+	PROCEDURE ^ Abs*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ AbsPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index); 
+	PROCEDURE ^ AddAA*(VAR x, y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ SubtractAA*(VAR x, y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ MultAA*(VAR x, y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ ScalarProduct*(VAR x, y: ARRAY OF Value; VAR res: Value; xoffset, yoffset, len: Index); 
+	PROCEDURE ^ ScalarProductPat*(VAR x, y: ARRAY OF Value; VAR res: Value; xoffset, yoffset, xstep, ystep, piecelen, pieces: Index); 
+	PROCEDURE ^ ModAA*(VAR x, y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ DivAA*(VAR x, y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ EqualsAA*(VAR x, y: ARRAY OF Value; offset, len: Index): BOOLEAN; 
+	PROCEDURE ^ AddAV*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ AddAVPat*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ SubtractAV*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ SubtractAVPat*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ SubtractVA*(VAR x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ SubtractVAPat*(x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ MultAV*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ MultAVPat*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ DivAV*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ DivAVPat*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ DivVA*(x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ DivVAPat*(x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ ModAV*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ ModAVPat*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ ModVA*(x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ ModVAPat*(x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ ApplyMap*(map: Map; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ ApplyMapPat*(map: Map; VAR res: ARRAY OF Value; offset, step, piecelen, pieces: Index); 
+	PROCEDURE ^ Min*(VAR x: ARRAY OF Value; offset, len: Index; VAR minpos: Index): Value; 
+	PROCEDURE ^ Max*(VAR x: ARRAY OF Value; offset, len: Index; VAR maxpos: Index): Value; 
+	PROCEDURE ^ MinMax*(VAR x: ARRAY OF Value; offset, len: Index; VAR min, max: Value; minpos, maxpos: Index); 
+	PROCEDURE ^ MinMaxPat*(map: Map; VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index; VAR min, max: Value; minpos, maxpos: Index); 
+	PROCEDURE ^ MeanSsq*(VAR x: ARRAY OF Value; offset, len: Index; VAR mean, ssq: RealValue); 
+	PROCEDURE ^ kSmallestModify*(k: Index; VAR a: ARRAY OF Value; len: LONGINT): Value; 
+	PROCEDURE ^ kSmallest*(k: Index; VAR a: ARRAY OF Value; len: LONGINT): Value; 
+	PROCEDURE ^ Median*(VAR a: ARRAY OF Value; len: LONGINT): Value; 
+	PROCEDURE ^ HammingWeight*(VAR x: ARRAY OF Value; offset, len: Index): Index; 
+	PROCEDURE ^ HammingWeightPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): Index; 
+	PROCEDURE ^ HammingDist*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): Index; 
+	PROCEDURE ^ L1Norm*(VAR x: ARRAY OF Value; offset, len: Index): Value; 
+	PROCEDURE ^ L1NormPat*(map: Map; VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): Value; 
+	PROCEDURE ^ L1Dist*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): Value; 
+	PROCEDURE ^ L2NormSq*(VAR x: ARRAY OF Value; offset, len: Index): NbrRe.Real; 
+	PROCEDURE ^ L2Norm*(VAR x: ARRAY OF Value; offset, len: Index): NbrRe.Real; 
+	PROCEDURE ^ L2NormPatSq*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): NbrRe.Real; 
+	PROCEDURE ^ L2NormPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): NbrRe.Real; 
+	PROCEDURE ^ L2DistSq*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): NbrRe.Real; 
+	PROCEDURE ^ L2Dist*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): NbrRe.Real; 
+	PROCEDURE ^ LInftyNorm*(VAR x: ARRAY OF Value; offset, len: Index): Value; 
+	PROCEDURE ^ LInftyNormPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): Value; 
+	PROCEDURE ^ LInftyDist*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): Value; 
+	PROCEDURE ^ MinIndex(x, y: Index): Index; 
+	PROCEDURE ^ SetLen*(VAR a: Array; len: Index); 
+	PROCEDURE ^ RemoveBlock*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ InsertBlock*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ ShiftBlock*(VAR x: ARRAY OF Value; from, to, len: Index); 
+	PROCEDURE ^ RemovePat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: LONGINT): Array; 
+	PROCEDURE ^ Remove*(VAR x: ARRAY OF Value; offset, len: LONGINT): Array; 
+	PROCEDURE ^ InsertPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: LONGINT): Array; 
+	PROCEDURE ^ Insert*(VAR x: ARRAY OF Value; offset, len: LONGINT): Array; 
+	PROCEDURE ^ GetPieces*(VAR a: ARRAY OF Value; offset, step, piecelen: LONGINT): LONGINT; 
+	PROCEDURE ^ Long*(VAR x: ARRAY OF Value; res: ARRAY OF LongerValue; len: Index); 
+	PROCEDURE ^ Short*(VAR x: ARRAY OF Value; res: ARRAY OF ShorterValue; len: Index); 
+	PROCEDURE ^ Sort*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ SortWithIndex*(VAR x: ARRAY OF Value; VAR index: ARRAY OF Index; offset, len: Index); 
+	PROCEDURE ^ SortByIndex*(VAR x: ARRAY OF Value; VAR index: ARRAY OF Index; offset, len: Index); 
+	OPERATOR ^ "-"-(x: Array): Array; 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF Value); 
+	OPERATOR ^ "="-(l: Array; VAR r: ARRAY OF Value): BOOLEAN; 
+	OPERATOR ^ "="-(VAR l: ARRAY OF Value; r: Array): BOOLEAN; 
+	OPERATOR ^ ":="-(VAR l: Array; r: Value); 
+	OPERATOR ^ "+"-(l, r: Array): Array; 
+	OPERATOR ^ "+"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "+"-(r: Value; l: Array): Array; 
+	OPERATOR ^ "-"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "-"-(l: Value; r: Array): Array; 
+	OPERATOR ^ "-"-(l, r: Array): Array; 
+	OPERATOR ^ "*"-(l, r: Array): Value; 
+	OPERATOR ^ "*"-(l: Value; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "DIV"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "DIV"-(l: Value; r: Array): Array; 
+	OPERATOR ^ "MOD"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "MOD"-(l: Value; r: Array): Array; 
+BEGIN
+END Array1dInt.

lin32/bin/Array1dRat.SymU

@@ -0,0 +1,108 @@
+MODULE Array1dRat;
+	IMPORT SYSTEM, Array1dBytes, NbrRat, DataErrors, NbrInt, Array1dInt, NbrRe;
+CONST 
+	sz = SIZEOF(Value); 
+TYPE 
+	Value* = NbrRat.Rational; 
+
+	Array* = POINTER TO ARRAY OF Value; 
+
+	Index* = LONGINT; 
+
+	Map* = PROCEDURE {DELEGATE}(VAR i: Value); 
+
+	PROCEDURE ^ Copy*(VAR x: ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ CreateCopy*(VAR x: ARRAY OF Value): Array; 
+	PROCEDURE ^ CopyPat*(VAR x: ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ CreateCopyPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): Array; 
+	PROCEDURE ^ Fill*(x: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ FillPat*(x: Value; VAR res: ARRAY OF Value; offset, step, piecelen, pieces: Index); 
+	PROCEDURE ^ Negate*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ NegatePat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index); 
+	PROCEDURE ^ Abs*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ AbsPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index); 
+	PROCEDURE ^ AddAA*(VAR x, y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ SubtractAA*(VAR x, y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ MultAA*(VAR x, y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ ScalarProduct*(VAR x, y: ARRAY OF Value; VAR res: Value; xoffset, yoffset, len: Index); 
+	PROCEDURE ^ ScalarProductPat*(VAR x, y: ARRAY OF Value; VAR res: Value; xoffset, yoffset, xstep, ystep, piecelen, pieces: Index); 
+	PROCEDURE ^ DivAA*(VAR x, y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ EqualsAA*(VAR x, y: ARRAY OF Value; offset, len: Index): BOOLEAN; 
+	PROCEDURE ^ AddAV*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ AddAVPat*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ SubtractAV*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ SubtractAVPat*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ SubtractVA*(VAR x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ SubtractVAPat*(x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ MultAV*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ MultAVPat*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ DivAV*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ DivAVPat*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ DivVA*(x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ DivVAPat*(x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ ApplyMap*(map: Map; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ ApplyMapPat*(map: Map; VAR res: ARRAY OF Value; offset, step, piecelen, pieces: Index); 
+	PROCEDURE ^ Min*(VAR x: ARRAY OF Value; offset, len: Index; VAR minpos: Index): Value; 
+	PROCEDURE ^ Max*(VAR x: ARRAY OF Value; offset, len: Index; VAR maxpos: Index): Value; 
+	PROCEDURE ^ MinMax*(VAR x: ARRAY OF Value; offset, len: Index; VAR min, max: Value; minpos, maxpos: Index); 
+	PROCEDURE ^ MinMaxPat*(map: Map; VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index; VAR min, max: Value; minpos, maxpos: Index); 
+	PROCEDURE ^ MeanSsq*(VAR x: ARRAY OF Value; offset, len: Index; VAR mean, ssq: Value); 
+	PROCEDURE ^ kSmallestModify*(k: Index; VAR a: ARRAY OF Value; len: LONGINT): Value; 
+	PROCEDURE ^ kSmallest*(k: Index; VAR a: ARRAY OF Value; len: LONGINT): Value; 
+	PROCEDURE ^ Median*(VAR a: ARRAY OF Value; len: LONGINT): Value; 
+	PROCEDURE ^ HammingWeight*(VAR x: ARRAY OF Value; offset, len: Index): Index; 
+	PROCEDURE ^ HammingWeightPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): Index; 
+	PROCEDURE ^ HammingDist*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): Index; 
+	PROCEDURE ^ L1Norm*(VAR x: ARRAY OF Value; offset, len: Index): Value; 
+	PROCEDURE ^ L1NormPat*(map: Map; VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): Value; 
+	PROCEDURE ^ L1Dist*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): Value; 
+	PROCEDURE ^ L2NormSq*(VAR x: ARRAY OF Value; offset, len: Index): NbrRe.Real; 
+	PROCEDURE ^ L2Norm*(VAR x: ARRAY OF Value; offset, len: Index): NbrRe.Real; 
+	PROCEDURE ^ L2NormPatSq*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): NbrRe.Real; 
+	PROCEDURE ^ L2NormPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): NbrRe.Real; 
+	PROCEDURE ^ L2DistSq*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): NbrRe.Real; 
+	PROCEDURE ^ L2Dist*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): NbrRe.Real; 
+	PROCEDURE ^ LInftyNorm*(VAR x: ARRAY OF Value; offset, len: Index): Value; 
+	PROCEDURE ^ LInftyNormPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): Value; 
+	PROCEDURE ^ LInftyDist*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): Value; 
+	PROCEDURE ^ MinIndex(x, y: Index): Index; 
+	PROCEDURE ^ SetLen*(VAR a: Array; len: Index); 
+	PROCEDURE ^ RemoveBlock*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ InsertBlock*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ ShiftBlock*(VAR x: ARRAY OF Value; from, to, len: Index); 
+	PROCEDURE ^ RemovePat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: LONGINT): Array; 
+	PROCEDURE ^ Remove*(VAR x: ARRAY OF Value; offset, len: LONGINT): Array; 
+	PROCEDURE ^ InsertPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: LONGINT): Array; 
+	PROCEDURE ^ Insert*(VAR x: ARRAY OF Value; offset, len: LONGINT): Array; 
+	PROCEDURE ^ GetPieces*(VAR a: ARRAY OF Value; offset, step, piecelen: LONGINT): LONGINT; 
+	PROCEDURE ^ Sort*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ SortWithIndex*(VAR x: ARRAY OF Value; VAR index: ARRAY OF Index; offset, len: Index); 
+	PROCEDURE ^ SortByIndex*(VAR x: ARRAY OF Value; VAR index: ARRAY OF Index; offset, len: Index); 
+	OPERATOR ^ "-"-(x: Array): Array; 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF Value); 
+	OPERATOR ^ ":="-(VAR l: Array; r: Array1dInt.Array); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF NbrInt.Integer); 
+	OPERATOR ^ "="-(l: Array; VAR r: ARRAY OF Value): BOOLEAN; 
+	OPERATOR ^ "="-(VAR l: ARRAY OF Value; r: Array): BOOLEAN; 
+	OPERATOR ^ ":="-(VAR l: Array; r: Value); 
+	OPERATOR ^ "+"-(l, r: Array): Array; 
+	OPERATOR ^ "+"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "+"-(r: Value; l: Array): Array; 
+	OPERATOR ^ "+"-(l: Array; r: Array1dInt.Array): Array; 
+	OPERATOR ^ "+"-(l: Array1dInt.Array; r: Array): Array; 
+	OPERATOR ^ "-"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "-"-(l: Value; r: Array): Array; 
+	OPERATOR ^ "-"-(l, r: Array): Array; 
+	OPERATOR ^ "-"-(l: Array; r: Array1dInt.Array): Array; 
+	OPERATOR ^ "-"-(l: Array1dInt.Array; r: Array): Array; 
+	OPERATOR ^ "*"-(l, r: Array): Value; 
+	OPERATOR ^ "*"-(l: Array; r: Array1dInt.Array): NbrRat.Rational; 
+	OPERATOR ^ "*"-(l: Array1dInt.Array; r: Array): NbrRat.Rational; 
+	OPERATOR ^ "*"-(l: Value; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "*"-(l: NbrInt.Integer; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: NbrInt.Integer): Array; 
+	OPERATOR ^ "/"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "/"-(l: Array; r: NbrInt.Integer): Array; 
+BEGIN
+END Array1dRat.

lin32/bin/Array1dRe.SymU

@@ -0,0 +1,124 @@
+MODULE Array1dRe;
+	IMPORT SYSTEM, Array1dBytes, NbrRe, DataErrors, Array1dInt, Array1dRat, NbrInt, NbrRat;
+CONST 
+	sz = SIZEOF(Value); 
+TYPE 
+	Value* = NbrRe.Real; 
+
+	LongerValue* = LONGREAL; 
+
+	RealValue* = NbrRe.Real; 
+
+	Array* = POINTER TO ARRAY OF Value; 
+
+	Index* = LONGINT; 
+
+	Map* = PROCEDURE {DELEGATE}(VAR i: Value); 
+
+	PROCEDURE ^ Copy*(VAR x: ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ CreateCopy*(VAR x: ARRAY OF Value): Array; 
+	PROCEDURE ^ CopyPat*(VAR x: ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ CreateCopyPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): Array; 
+	PROCEDURE ^ Fill*(x: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ FillPat*(x: Value; VAR res: ARRAY OF Value; offset, step, piecelen, pieces: Index); 
+	PROCEDURE ^ Negate*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ NegatePat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index); 
+	PROCEDURE ^ Abs*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ AbsPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index); 
+	PROCEDURE ^ AddAA*(VAR x, y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ SubtractAA*(VAR x, y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ MultAA*(VAR x, y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ ScalarProduct*(VAR x, y: ARRAY OF Value; VAR res: Value; xoffset, yoffset, len: Index); 
+	PROCEDURE ^ ScalarProductPat*(VAR x, y: ARRAY OF Value; VAR res: Value; xoffset, yoffset, xstep, ystep, piecelen, pieces: Index); 
+	PROCEDURE ^ DivAA*(VAR x, y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ EqualsAA*(VAR x, y: ARRAY OF Value; offset, len: Index): BOOLEAN; 
+	PROCEDURE ^ AddAV*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ AddAVPat*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ SubtractAV*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ SubtractAVPat*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ SubtractVA*(VAR x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ SubtractVAPat*(x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ MultAV*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ MultAVPat*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ DivAV*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ DivAVPat*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ DivVA*(x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ DivVAPat*(x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ ApplyMap*(map: Map; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ ApplyMapPat*(map: Map; VAR res: ARRAY OF Value; offset, step, piecelen, pieces: Index); 
+	PROCEDURE ^ Min*(VAR x: ARRAY OF Value; offset, len: Index; VAR minpos: Index): Value; 
+	PROCEDURE ^ Max*(VAR x: ARRAY OF Value; offset, len: Index; VAR maxpos: Index): Value; 
+	PROCEDURE ^ MinMax*(VAR x: ARRAY OF Value; offset, len: Index; VAR min, max: Value; minpos, maxpos: Index); 
+	PROCEDURE ^ MinMaxPat*(map: Map; VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index; VAR min, max: Value; minpos, maxpos: Index); 
+	PROCEDURE ^ MeanSsq*(VAR x: ARRAY OF Value; offset, len: Index; VAR mean, ssq: Value); 
+	PROCEDURE ^ kSmallestModify*(k: Index; VAR a: ARRAY OF Value; len: LONGINT): Value; 
+	PROCEDURE ^ kSmallest*(k: Index; VAR a: ARRAY OF Value; len: LONGINT): Value; 
+	PROCEDURE ^ Median*(VAR a: ARRAY OF Value; len: LONGINT): Value; 
+	PROCEDURE ^ HammingWeight*(VAR x: ARRAY OF Value; offset, len: Index): Index; 
+	PROCEDURE ^ HammingWeightPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): Index; 
+	PROCEDURE ^ HammingDist*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): Index; 
+	PROCEDURE ^ L1Norm*(VAR x: ARRAY OF Value; offset, len: Index): Value; 
+	PROCEDURE ^ L1NormPat*(map: Map; VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): Value; 
+	PROCEDURE ^ L1Dist*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): Value; 
+	PROCEDURE ^ L2NormSq*(VAR x: ARRAY OF Value; offset, len: Index): NbrRe.Real; 
+	PROCEDURE ^ L2Norm*(VAR x: ARRAY OF Value; offset, len: Index): NbrRe.Real; 
+	PROCEDURE ^ L2NormPatSq*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): NbrRe.Real; 
+	PROCEDURE ^ L2NormPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): NbrRe.Real; 
+	PROCEDURE ^ L2DistSq*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): NbrRe.Real; 
+	PROCEDURE ^ L2Dist*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): NbrRe.Real; 
+	PROCEDURE ^ LInftyNorm*(VAR x: ARRAY OF Value; offset, len: Index): Value; 
+	PROCEDURE ^ LInftyNormPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): Value; 
+	PROCEDURE ^ LInftyDist*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): Value; 
+	PROCEDURE ^ MinIndex(x, y: Index): Index; 
+	PROCEDURE ^ SetLen*(VAR a: Array; len: Index); 
+	PROCEDURE ^ RemoveBlock*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ InsertBlock*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ ShiftBlock*(VAR x: ARRAY OF Value; from, to, len: Index); 
+	PROCEDURE ^ RemovePat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: LONGINT): Array; 
+	PROCEDURE ^ Remove*(VAR x: ARRAY OF Value; offset, len: LONGINT): Array; 
+	PROCEDURE ^ InsertPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: LONGINT): Array; 
+	PROCEDURE ^ Insert*(VAR x: ARRAY OF Value; offset, len: LONGINT): Array; 
+	PROCEDURE ^ GetPieces*(VAR a: ARRAY OF Value; offset, step, piecelen: LONGINT): LONGINT; 
+	PROCEDURE ^ Long*(VAR x: ARRAY OF Value; res: ARRAY OF LongerValue; len: Index); 
+	PROCEDURE ^ Sort*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ SortWithIndex*(VAR x: ARRAY OF Value; VAR index: ARRAY OF Index; offset, len: Index); 
+	PROCEDURE ^ SortByIndex*(VAR x: ARRAY OF Value; VAR index: ARRAY OF Index; offset, len: Index); 
+	OPERATOR ^ "-"-(x: Array): Array; 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF Value); 
+	OPERATOR ^ ":="-(VAR l: Array; r: Array1dRat.Array); 
+	OPERATOR ^ ":="-(VAR l: Array; r: Array1dInt.Array); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF NbrRat.Rational); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF NbrInt.Integer); 
+	OPERATOR ^ "="-(l: Array; VAR r: ARRAY OF Value): BOOLEAN; 
+	OPERATOR ^ "="-(VAR l: ARRAY OF Value; r: Array): BOOLEAN; 
+	OPERATOR ^ ":="-(VAR l: Array; r: Value); 
+	OPERATOR ^ "+"-(l, r: Array): Array; 
+	OPERATOR ^ "+"-(l: Array; r: Array1dRat.Array): Array; 
+	OPERATOR ^ "+"-(l: Array1dRat.Array; r: Array): Array; 
+	OPERATOR ^ "+"-(l: Array; r: Array1dInt.Array): Array; 
+	OPERATOR ^ "+"-(l: Array1dInt.Array; r: Array): Array; 
+	OPERATOR ^ "+"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "+"-(r: Value; l: Array): Array; 
+	OPERATOR ^ "-"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "-"-(l: Value; r: Array): Array; 
+	OPERATOR ^ "-"-(l, r: Array): Array; 
+	OPERATOR ^ "-"-(l: Array; r: Array1dRat.Array): Array; 
+	OPERATOR ^ "-"-(l: Array1dRat.Array; r: Array): Array; 
+	OPERATOR ^ "-"-(l: Array; r: Array1dInt.Array): Array; 
+	OPERATOR ^ "-"-(l: Array1dInt.Array; r: Array): Array; 
+	OPERATOR ^ "*"-(l, r: Array): Value; 
+	OPERATOR ^ "*"-(l: Array; r: Array1dRat.Array): NbrRe.Real; 
+	OPERATOR ^ "*"-(l: Array1dRat.Array; r: Array): NbrRe.Real; 
+	OPERATOR ^ "*"-(l: Array; r: Array1dInt.Array): NbrRe.Real; 
+	OPERATOR ^ "*"-(l: Array1dInt.Array; r: Array): NbrRe.Real; 
+	OPERATOR ^ "*"-(l: Value; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "*"-(l: NbrRat.Rational; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: NbrRat.Rational): Array; 
+	OPERATOR ^ "*"-(l: NbrInt.Integer; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: NbrInt.Integer): Array; 
+	OPERATOR ^ "/"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "/"-(l: Array; r: NbrRat.Rational): Array; 
+	OPERATOR ^ "/"-(l: Array; r: NbrInt.Integer): Array; 
+BEGIN
+END Array1dRe.

lin32/bin/Array2dCplx.SymU

@@ -0,0 +1,77 @@
+MODULE Array2dCplx;
+	IMPORT SYSTEM, Array1dBytes, NbrInt, NbrRat, NbrRe, NbrCplx, Array1dRe, Array1d := Array1dCplx, Array1dInt, Array2dInt, Array1dRat, Array2dRat, Array2dRe, Array1dCplx, ArrayXd := ArrayXdCplx, DataErrors;
+CONST 
+TYPE 
+	Value* = Array1d.Value; 
+
+	RealValue* = NbrRe.Real; 
+
+	Array* = ArrayXd.Array2; 
+
+	Index* = NbrInt.Integer; 
+
+	PROCEDURE ^ Copy*(VAR src: ARRAY OF ARRAY OF Value; VAR dest: ARRAY OF ARRAY OF Value; srcx, srcy, destx, desty, w, h: Index); 
+	PROCEDURE ^ Fill*(val: Value; VAR res: ARRAY OF ARRAY OF Value; x, y, w, h: Index); 
+	PROCEDURE ^ MeanSsq*(VAR s: ARRAY OF ARRAY OF Value; x, y, w, h: Index; VAR mean: Value; VAR ssq: RealValue); 
+	PROCEDURE ^ CopyRow*(y: Index; VAR s: ARRAY OF ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ CopyCol*(x: Index; VAR s: ARRAY OF ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ CopyToRow*(VAR s: ARRAY OF Value; y: Index; VAR res: ARRAY OF ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ CopyToCol*(VAR s: ARRAY OF Value; x: Index; VAR res: ARRAY OF ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ Row*(y: Index; VAR s: ARRAY OF ARRAY OF Value): Array1d.Array; 
+	PROCEDURE ^ Col*(x: Index; VAR s: ARRAY OF ARRAY OF Value): Array1d.Array; 
+	PROCEDURE ^ Transposed*(VAR s: ARRAY OF ARRAY OF Value): Array; 
+	PROCEDURE ^ SwapRows*(VAR s: ARRAY OF ARRAY OF Value; y1, y2: Index); 
+	PROCEDURE ^ SwapCols*(VAR s: ARRAY OF ARRAY OF Value; x1, x2: Index); 
+	OPERATOR ^ "-"-(x: Array): Array; 
+	OPERATOR ^ "~"-(x: Array): Array; 
+	OPERATOR ^ ":="-(VAR l: Array; r: Value); 
+	OPERATOR ^ ":="-(VAR l: Array; r: Array2dRe.Array); 
+	OPERATOR ^ ":="-(VAR l: Array; r: Array2dRat.Array); 
+	OPERATOR ^ ":="-(VAR l: Array; r: Array2dInt.Array); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF ARRAY OF NbrCplx.Complex); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF ARRAY OF NbrRe.Real); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF ARRAY OF NbrRat.Rational); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF ARRAY OF NbrInt.Integer); 
+	OPERATOR ^ "+"-(l, r: Array): Array; 
+	OPERATOR ^ "+"-(l: Array; r: Array2dRe.Array): Array; 
+	OPERATOR ^ "+"-(l: Array2dRe.Array; r: Array): Array; 
+	OPERATOR ^ "+"-(l: Array; r: Array2dRat.Array): Array; 
+	OPERATOR ^ "+"-(l: Array2dRat.Array; r: Array): Array; 
+	OPERATOR ^ "+"-(l: Array; r: Array2dInt.Array): Array; 
+	OPERATOR ^ "+"-(l: Array2dInt.Array; r: Array): Array; 
+	OPERATOR ^ "-"-(l, r: Array): Array; 
+	OPERATOR ^ "-"-(l: Array; r: Array2dRe.Array): Array; 
+	OPERATOR ^ "-"-(l: Array2dRe.Array; r: Array): Array; 
+	OPERATOR ^ "-"-(l: Array; r: Array2dRat.Array): Array; 
+	OPERATOR ^ "-"-(l: Array2dRat.Array; r: Array): Array; 
+	OPERATOR ^ "-"-(l: Array; r: Array2dInt.Array): Array; 
+	OPERATOR ^ "-"-(l: Array2dInt.Array; r: Array): Array; 
+	OPERATOR ^ "*"-(l, r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: Array2dRe.Array): Array; 
+	OPERATOR ^ "*"-(l: Array2dRe.Array; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: Array2dRat.Array): Array; 
+	OPERATOR ^ "*"-(l: Array2dRat.Array; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: Array2dInt.Array): Array; 
+	OPERATOR ^ "*"-(l: Array2dInt.Array; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: Array1dCplx.Array): Array1dCplx.Array; 
+	OPERATOR ^ "*"-(l: Array; r: Array1dRe.Array): Array1dCplx.Array; 
+	OPERATOR ^ "*"-(l: Array; r: Array1dRat.Array): Array1dCplx.Array; 
+	OPERATOR ^ "*"-(l: Array; r: Array1dInt.Array): Array1dCplx.Array; 
+	OPERATOR ^ "*"-(l: Array1dCplx.Array; r: Array): Array1dCplx.Array; 
+	OPERATOR ^ "*"-(l: Array1dRe.Array; r: Array): Array1dCplx.Array; 
+	OPERATOR ^ "*"-(l: Array1dRat.Array; r: Array): Array1dCplx.Array; 
+	OPERATOR ^ "*"-(l: Array1dInt.Array; r: Array): Array1dCplx.Array; 
+	OPERATOR ^ "*"-(l: NbrCplx.Complex; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: NbrCplx.Complex): Array; 
+	OPERATOR ^ "*"-(l: NbrRe.Real; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: NbrRe.Real): Array; 
+	OPERATOR ^ "*"-(l: NbrRat.Rational; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: NbrRat.Rational): Array; 
+	OPERATOR ^ "*"-(l: NbrInt.Integer; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: NbrInt.Integer): Array; 
+	OPERATOR ^ "/"-(l: Array; r: NbrCplx.Complex): Array; 
+	OPERATOR ^ "/"-(l: Array; r: NbrRe.Real): Array; 
+	OPERATOR ^ "/"-(l: Array; r: NbrRat.Rational): Array; 
+	OPERATOR ^ "/"-(l: Array; r: NbrInt.Integer): Array; 
+BEGIN
+END Array2dCplx.

lin32/bin/Array2dInt.SymU

@@ -0,0 +1,41 @@
+MODULE Array2dInt;
+	IMPORT SYSTEM, Array1dBytes, NbrInt, NbrRe, ArrayXd := ArrayXdInt, Array1d := Array1dInt, DataErrors;
+CONST 
+TYPE 
+	Value* = ArrayXd.Value; 
+
+	RealValue* = NbrRe.Real; 
+
+	Array* = POINTER TO ARRAY OF ARRAY OF Value; 
+
+	Index* = NbrInt.Integer; 
+
+	PROCEDURE ^ Copy*(VAR src: ARRAY OF ARRAY OF Value; VAR dest: ARRAY OF ARRAY OF Value; srcx, srcy, destx, desty, w, h: Index); 
+	PROCEDURE ^ Fill*(val: Value; VAR res: ARRAY OF ARRAY OF Value; x, y, w, h: Index); 
+	PROCEDURE ^ MinMax*(VAR s: ARRAY OF ARRAY OF Value; x, y, w, h: Index; VAR min, max: Value; VAR minx, miny, maxx, maxy: Index); 
+	PROCEDURE ^ kSmallest*(k: Index; VAR s: ARRAY OF ARRAY OF Value; x, y, w, h: Index): Value; 
+	PROCEDURE ^ Median*(VAR s: ARRAY OF ARRAY OF Value; x, y, w, h: Index): Value; 
+	PROCEDURE ^ MeanSsq*(VAR s: ARRAY OF ARRAY OF Value; x, y, w, h: Index; VAR mean, ssq: RealValue); 
+	PROCEDURE ^ CopyRow*(y: Index; VAR s: ARRAY OF ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ CopyCol*(x: Index; VAR s: ARRAY OF ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ CopyToRow*(VAR s: ARRAY OF Value; y: Index; VAR res: ARRAY OF ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ CopyToCol*(VAR s: ARRAY OF Value; x: Index; VAR res: ARRAY OF ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ Row*(y: Index; VAR s: ARRAY OF ARRAY OF Value): ArrayXd.Array1; 
+	PROCEDURE ^ Col*(x: Index; VAR s: ARRAY OF ARRAY OF Value): ArrayXd.Array1; 
+	PROCEDURE ^ Transposed*(VAR s: ARRAY OF ARRAY OF Value): Array; 
+	PROCEDURE ^ SwapRows*(VAR s: ARRAY OF ARRAY OF Value; y1, y2: Index); 
+	PROCEDURE ^ SwapCols*(VAR s: ARRAY OF ARRAY OF Value; x1, x2: Index); 
+	OPERATOR ^ "-"-(x: Array): Array; 
+	OPERATOR ^ ":="-(VAR l: Array; r: Value); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF ARRAY OF Value); 
+	OPERATOR ^ "+"-(l, r: Array): Array; 
+	OPERATOR ^ "-"-(l, r: Array): Array; 
+	OPERATOR ^ "*"-(l, r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: ArrayXd.Array1): ArrayXd.Array1; 
+	OPERATOR ^ "*"-(l: ArrayXd.Array1; r: Array): ArrayXd.Array1; 
+	OPERATOR ^ "*"-(l: Value; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "DIV"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "MOD"-(l: Array; r: Value): Array; 
+BEGIN
+END Array2dInt.

lin32/bin/Array2dRat.SymU

@@ -0,0 +1,53 @@
+MODULE Array2dRat;
+	IMPORT SYSTEM, Array1dBytes, NbrInt, NbrRat, NbrRe, Array1d := Array1dRat, ArrayXd := ArrayXdRat, Array1dInt, Array2dInt, DataErrors;
+CONST 
+TYPE 
+	Value* = Array1d.Value; 
+
+	RealValue* = NbrRe.Real; 
+
+	Array* = ArrayXd.Array2; 
+
+	Index* = NbrInt.Integer; 
+
+	PROCEDURE ^ Copy*(VAR src: ARRAY OF ARRAY OF Value; VAR dest: ARRAY OF ARRAY OF Value; srcx, srcy, destx, desty, w, h: Index); 
+	PROCEDURE ^ Fill*(val: Value; VAR res: ARRAY OF ARRAY OF Value; x, y, w, h: Index); 
+	PROCEDURE ^ MinMax*(VAR s: ARRAY OF ARRAY OF Value; x, y, w, h: Index; VAR min, max: Value; VAR minx, miny, maxx, maxy: Index); 
+	PROCEDURE ^ kSmallest*(k: Index; VAR s: ARRAY OF ARRAY OF Value; x, y, w, h: Index): Value; 
+	PROCEDURE ^ Median*(VAR s: ARRAY OF ARRAY OF Value; x, y, w, h: Index): Value; 
+	PROCEDURE ^ MeanSsq*(VAR s: ARRAY OF ARRAY OF Value; x, y, w, h: Index; VAR mean, ssq: RealValue); 
+	PROCEDURE ^ CopyRow*(y: Index; VAR s: ARRAY OF ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ CopyCol*(x: Index; VAR s: ARRAY OF ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ CopyToRow*(VAR s: ARRAY OF Value; y: Index; VAR res: ARRAY OF ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ CopyToCol*(VAR s: ARRAY OF Value; x: Index; VAR res: ARRAY OF ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ Row*(y: Index; VAR s: ARRAY OF ARRAY OF Value): Array1d.Array; 
+	PROCEDURE ^ Col*(x: Index; VAR s: ARRAY OF ARRAY OF Value): Array1d.Array; 
+	PROCEDURE ^ Transposed*(VAR s: ARRAY OF ARRAY OF Value): Array; 
+	PROCEDURE ^ SwapRows*(VAR s: ARRAY OF ARRAY OF Value; y1, y2: Index); 
+	PROCEDURE ^ SwapCols*(VAR s: ARRAY OF ARRAY OF Value; x1, x2: Index); 
+	OPERATOR ^ "-"-(x: Array): Array; 
+	OPERATOR ^ ":="-(VAR l: Array; r: Value); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF ARRAY OF Value); 
+	OPERATOR ^ ":="-(VAR l: Array; r: Array2dInt.Array); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF ARRAY OF NbrInt.Integer); 
+	OPERATOR ^ "+"-(l, r: Array): Array; 
+	OPERATOR ^ "+"-(l: Array; r: Array2dInt.Array): Array; 
+	OPERATOR ^ "+"-(l: Array2dInt.Array; r: Array): Array; 
+	OPERATOR ^ "-"-(l, r: Array): Array; 
+	OPERATOR ^ "-"-(l: Array; r: Array2dInt.Array): Array; 
+	OPERATOR ^ "-"-(l: Array2dInt.Array; r: Array): Array; 
+	OPERATOR ^ "*"-(l, r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: Array2dInt.Array): Array; 
+	OPERATOR ^ "*"-(l: Array2dInt.Array; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: Array1d.Array): Array1d.Array; 
+	OPERATOR ^ "*"-(l: Array1d.Array; r: Array): Array1d.Array; 
+	OPERATOR ^ "*"-(l: Array; r: Array1dInt.Array): Array1d.Array; 
+	OPERATOR ^ "*"-(l: Array1dInt.Array; r: Array): Array1d.Array; 
+	OPERATOR ^ "*"-(l: Value; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "*"-(l: NbrInt.Integer; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: NbrInt.Integer): Array; 
+	OPERATOR ^ "/"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "/"-(l: Array; r: NbrInt.Integer): Array; 
+BEGIN
+END Array2dRat.

lin32/bin/Array2dRe.SymU

@@ -0,0 +1,64 @@
+MODULE Array2dRe;
+	IMPORT SYSTEM, Array1dBytes, NbrInt, NbrRat, NbrRe, Array1d := Array1dRe, ArrayXd := ArrayXdRe, Array1dInt, Array2dInt, Array1dRat, Array2dRat, Array1dRe, DataErrors;
+CONST 
+TYPE 
+	Value* = Array1d.Value; 
+
+	Array* = ArrayXd.Array2; 
+
+	Index* = NbrInt.Integer; 
+
+	PROCEDURE ^ Copy*(VAR src: ARRAY OF ARRAY OF Value; VAR dest: ARRAY OF ARRAY OF Value; srcx, srcy, destx, desty, w, h: Index); 
+	PROCEDURE ^ Fill*(val: Value; VAR res: ARRAY OF ARRAY OF Value; x, y, w, h: Index); 
+	PROCEDURE ^ MinMax*(VAR s: ARRAY OF ARRAY OF Value; x, y, w, h: Index; VAR min, max: Value; VAR minx, miny, maxx, maxy: Index); 
+	PROCEDURE ^ kSmallest*(k: Index; VAR s: ARRAY OF ARRAY OF Value; x, y, w, h: Index): Value; 
+	PROCEDURE ^ Median*(VAR s: ARRAY OF ARRAY OF Value; x, y, w, h: Index): Value; 
+	PROCEDURE ^ MeanSsq*(VAR s: ARRAY OF ARRAY OF Value; x, y, w, h: Index; VAR mean, ssq: Value); 
+	PROCEDURE ^ CopyRow*(y: Index; VAR s: ARRAY OF ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ CopyCol*(x: Index; VAR s: ARRAY OF ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ CopyToRow*(VAR s: ARRAY OF Value; y: Index; VAR res: ARRAY OF ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ CopyToCol*(VAR s: ARRAY OF Value; x: Index; VAR res: ARRAY OF ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ Row*(y: Index; VAR s: ARRAY OF ARRAY OF Value): Array1d.Array; 
+	PROCEDURE ^ Col*(x: Index; VAR s: ARRAY OF ARRAY OF Value): Array1d.Array; 
+	PROCEDURE ^ Transposed*(VAR s: ARRAY OF ARRAY OF Value): Array; 
+	PROCEDURE ^ SwapRows*(VAR s: ARRAY OF ARRAY OF Value; y1, y2: Index); 
+	PROCEDURE ^ SwapCols*(VAR s: ARRAY OF ARRAY OF Value; x1, x2: Index); 
+	OPERATOR ^ "-"-(x: Array): Array; 
+	OPERATOR ^ ":="-(VAR l: Array; r: Value); 
+	OPERATOR ^ ":="-(VAR l: Array; r: Array2dRat.Array); 
+	OPERATOR ^ ":="-(VAR l: Array; r: Array2dInt.Array); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF ARRAY OF NbrRe.Real); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF ARRAY OF NbrRat.Rational); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF ARRAY OF NbrInt.Integer); 
+	OPERATOR ^ "+"-(l, r: Array): Array; 
+	OPERATOR ^ "+"-(l: Array; r: Array2dRat.Array): Array; 
+	OPERATOR ^ "+"-(l: Array2dRat.Array; r: Array): Array; 
+	OPERATOR ^ "+"-(l: Array; r: Array2dInt.Array): Array; 
+	OPERATOR ^ "+"-(l: Array2dInt.Array; r: Array): Array; 
+	OPERATOR ^ "-"-(l, r: Array): Array; 
+	OPERATOR ^ "-"-(l: Array; r: Array2dRat.Array): Array; 
+	OPERATOR ^ "-"-(l: Array2dRat.Array; r: Array): Array; 
+	OPERATOR ^ "-"-(l: Array; r: Array2dInt.Array): Array; 
+	OPERATOR ^ "-"-(l: Array2dInt.Array; r: Array): Array; 
+	OPERATOR ^ "*"-(l, r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: Array2dRat.Array): Array; 
+	OPERATOR ^ "*"-(l: Array2dRat.Array; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: Array2dInt.Array): Array; 
+	OPERATOR ^ "*"-(l: Array2dInt.Array; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: Array1dRe.Array): Array1dRe.Array; 
+	OPERATOR ^ "*"-(l: Array; r: Array1dRat.Array): Array1dRe.Array; 
+	OPERATOR ^ "*"-(l: Array; r: Array1dInt.Array): Array1dRe.Array; 
+	OPERATOR ^ "*"-(l: Array1dRe.Array; r: Array): Array1dRe.Array; 
+	OPERATOR ^ "*"-(l: Array1dRat.Array; r: Array): Array1dRe.Array; 
+	OPERATOR ^ "*"-(l: Array1dInt.Array; r: Array): Array1dRe.Array; 
+	OPERATOR ^ "*"-(l: NbrRe.Real; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: NbrRe.Real): Array; 
+	OPERATOR ^ "*"-(l: NbrRat.Rational; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: NbrRat.Rational): Array; 
+	OPERATOR ^ "*"-(l: NbrInt.Integer; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: NbrInt.Integer): Array; 
+	OPERATOR ^ "/"-(l: Array; r: NbrRe.Real): Array; 
+	OPERATOR ^ "/"-(l: Array; r: NbrRat.Rational): Array; 
+	OPERATOR ^ "/"-(l: Array; r: NbrInt.Integer): Array; 
+BEGIN
+END Array2dRe.

lin32/bin/ArrayXdBytes.SymU

@@ -0,0 +1,231 @@
+MODULE ArrayXdBytes;
+	IMPORT SYSTEM, Array1dBytes, dbgOut := KernelLog, DataIO;
+CONST 
+	strongIndexChecking = TRUE; 
+	debug = FALSE; 
+TYPE 
+	Index* = LONGINT; 
+
+	IndexArray* = POINTER TO ARRAY OF Index; 
+
+	Address* = LONGINT; 
+
+	ArrayMemoryStructure* = OBJECT 
+	VAR 
+		baseadr: Index; 
+		bytes-: Index; 
+		dim-: Index; 
+		len-: IndexArray; 
+		diminc-: IndexArray; 
+		elementsize: Index; 
+		origin-: IndexArray; 
+		adrwoffset: Index; 
+	END ArrayMemoryStructure; 
+
+	Enumerator* = OBJECT 
+	VAR 
+		dim: LONGINT; 
+		mem: ArrayMemoryStructure; 
+		adr-, size-: LONGINT; 
+		lncdim: LONGINT; 
+		pos-, origin, len: IndexArray; 
+
+		PROCEDURE ^  & Init*(mem: ArrayMemoryStructure; enumorigin, enumlen: IndexArray; block: BOOLEAN); 
+		PROCEDURE ^ Next*(): BOOLEAN; 
+	END Enumerator; 
+
+	Array* = OBJECT (ArrayMemoryStructure)
+	VAR 
+		protector: ANY; 
+		permutation-: IndexArray; 
+		bc-: SHORTINT; 
+		f0, f1, f2, f3: Index; 
+		o0-, o1-, o2-, o3-, l0-, l1-, l2-, l3-: Index; 
+
+		PROCEDURE ^ dbgWriteInfo*; 
+		PROCEDURE ^ GetInfo*(VAR elementsize: LONGINT); 
+		PROCEDURE ^ SetBoundaryCondition*(c: SHORTINT); 
+		PROCEDURE ^ Allocate*(size: LONGINT; VAR baseadr: LONGINT; VAR protector: ANY); 
+		PROCEDURE ^ ValidateCache*; 
+		PROCEDURE ^ Init(newdim: LONGINT); 
+		PROCEDURE ^  & NewXdB*(neworigin, newlen: IndexArray); 
+		PROCEDURE ^ AlikeX*(): Array; 
+		PROCEDURE ^ CopyX*(): Array; 
+		PROCEDURE ^ NewRangeX*(neworigin, newlen: IndexArray; preservedata: BOOLEAN); 
+		PROCEDURE ^ OptimizeForAccess*(order: ARRAY OF Index; preservedata: BOOLEAN); 
+		PROCEDURE ^ PermuteDimensions*(permutation: IndexArray; rearrangeMemory: BOOLEAN); 
+		PROCEDURE ^ DeleteElements*(dimension, first, length: Index); 
+		PROCEDURE ^ InsertElements*(dimension, first, length: Index); 
+		PROCEDURE ^ ToggleElements*(dimension: Index; pos1, pos2: Index); 
+		PROCEDURE ^ PermuteElements*(dimension: Index; permutation: ARRAY OF Index); 
+		PROCEDURE ^ MirrorDimension*(dimension: Index); 
+		PROCEDURE ^ BlockCopy*(dimension, from, to, length: Index); 
+		PROCEDURE ^ BlockMove*(dimension, from, to, length: Index); 
+		PROCEDURE ^ LoadXd*(VAR R: DataIO.Reader); 
+		PROCEDURE ^ StoreXd*(VAR W: DataIO.Writer; storeRawData: BOOLEAN); 
+	END Array; 
+
+	Rectangle = OBJECT 
+	VAR 
+		origin, len, destpos, destlen: IndexArray; 
+		next: Rectangle; 
+	END Rectangle; 
+
+	BoundaryEnum* = OBJECT 
+	VAR 
+		root: Rectangle; 
+
+		PROCEDURE ^  & Init*(a: Array; origin, len: IndexArray); 
+		PROCEDURE ^ Get*(VAR origin, len: IndexArray): BOOLEAN; 
+	END BoundaryEnum; 
+
+	PROCEDURE ^ StoreMemory(W: DataIO.Writer; baseadr: LONGINT; len: LONGINT); 
+	PROCEDURE ^ ReadMemory(R: DataIO.Reader; baseadr: LONGINT; size: LONGINT; VAR len: LONGINT); 
+	PROCEDURE ^ Min(l, r: LONGINT): LONGINT; 
+	PROCEDURE ^ CheckIndexArray(dim: Index; VAR a: IndexArray); 
+	PROCEDURE ^ CopyIndexArray(src: ARRAY OF Index; dest: IndexArray); 
+	PROCEDURE ^ Intersect*(org1, len1, org2, len2: IndexArray; VAR org, len: IndexArray): BOOLEAN; 
+	PROCEDURE {FingerPrint(-269175839)}  - CheckLEQ*(lesseq, than: LONGINT);
+	CODE {SYSTEM.i386}
+		MOV	ECX, [ESP]	;  than
+		MOV	EBX, [ESP+4]	;  less
+		CMP	EBX, ECX
+		JLE	ok
+		PUSH	7
+		INT	3
+		ok:
+		ADD	ESP, 8
+	
+	END CheckLEQ; 
+	PROCEDURE {FingerPrint(-238922078)}  - CheckLE*(lesseq, than: LONGINT);
+	CODE {SYSTEM.i386}
+		MOV	ECX, [ESP]	;  than
+		MOV	EBX, [ESP+4]	;  less
+		CMP	EBX, ECX
+		JL	ok
+		PUSH	7
+		INT	3
+		ok:
+		ADD	ESP, 8
+	
+	END CheckLE; 
+	PROCEDURE {FingerPrint(-2019807603)}  - CheckEQ*(equals, this: LONGINT);
+	CODE {SYSTEM.i386}
+		MOV	ECX, [ESP]	;  this
+		MOV	EBX, [ESP+4]	;  equals
+		CMP	EBX, ECX
+		JE	ok
+		PUSH	7
+		INT	3
+		ok:
+		ADD	ESP, 8
+	
+	END CheckEQ; 
+	PROCEDURE ^ CheckPermutation(dim: LONGINT; VAR permutation: ARRAY OF LONGINT): BOOLEAN; 
+	PROCEDURE ^ CompletePermutation(beginning: ARRAY OF LONGINT; full: ARRAY OF LONGINT): BOOLEAN; 
+	PROCEDURE ^ ApplyPermutation(permutation: ARRAY OF Index; VAR array: ARRAY OF Index); 
+	PROCEDURE ^ IdentityPermutation(dim: LONGINT): IndexArray; 
+	PROCEDURE ^ ComputeIncrease(len: IndexArray; permutation: IndexArray; elementsize: LONGINT; diminc: IndexArray); 
+	PROCEDURE ^ AMSCopyDescr(src: ArrayMemoryStructure; dest: ArrayMemoryStructure); 
+	PROCEDURE ^ EnumArrayPart(mem: ArrayMemoryStructure; pos, len: IndexArray; chunks: BOOLEAN): Enumerator; 
+	PROCEDURE ^ TraverseMemory*(proc: Address; mem: ArrayMemoryStructure); 
+	PROCEDURE ^ TraverseMemory2*(proc: Address; srcmem, destmem: ArrayMemoryStructure); 
+	PROCEDURE ^ TraverseMemory3*(proc: Address; leftmem, rightmem, destmem: ArrayMemoryStructure); 
+	PROCEDURE ^ TraverseAndCopy(src, dest: Enumerator); 
+	PROCEDURE ^ CopyDataByCoordinateTraversal*(srcmem, destmem: ArrayMemoryStructure); 
+	PROCEDURE ^ CopyDataRaw*(srcmem, destmem: ArrayMemoryStructure); 
+	PROCEDURE ^ CopyDataPositionPreserving*(srcmem, destmem: ArrayMemoryStructure); 
+	PROCEDURE ^ MakeMemoryStructure*(dim: LONGINT; origin, len: IndexArray; elementsize: Index; baseadr: Address): ArrayMemoryStructure; 
+	PROCEDURE ^ MakeContinuousMemStruct*(adr, elements, elementsize: LONGINT; VAR memory: ArrayMemoryStructure); 
+	PROCEDURE ^ CheckEqDimensions*(l, r: Array); 
+	PROCEDURE ^ ToggleDimensions*(a: Array; d1, d2: LONGINT; rearrangeMemory: BOOLEAN); 
+	PROCEDURE ^ dbgS(s: ARRAY OF CHAR); 
+	PROCEDURE ^ dbgSI(s: ARRAY OF CHAR; i: LONGINT); 
+	PROCEDURE ^ dbgSISI(s: ARRAY OF CHAR; i: LONGINT; s2: ARRAY OF CHAR; i2: LONGINT); 
+	PROCEDURE ^ dbgSISISI(s: ARRAY OF CHAR; i: LONGINT; s2: ARRAY OF CHAR; i2: LONGINT; s3: ARRAY OF CHAR; i3: LONGINT); 
+	PROCEDURE ^ dbgWriteMemoryInfo*(a: ArrayMemoryStructure); 
+	PROCEDURE ^ Adr1*(a: Array; x: Index): Index; 
+	PROCEDURE ^ Adr2*(a: Array; x, y: Index): Index; 
+	PROCEDURE ^ Adr3*(a: Array; x, y, z: Index): Index; 
+	PROCEDURE ^ Adr4*(a: Array; x, y, z, t: Index): Index; 
+	PROCEDURE ^ AdrX*(a: ArrayMemoryStructure; VAR b: ARRAY OF Index; dim: Index): Index; 
+	PROCEDURE ^ Index1*(x: LONGINT): IndexArray; 
+	PROCEDURE ^ Array1*(x: LONGINT): IndexArray; 
+	PROCEDURE ^ Index2*(x, y: LONGINT): IndexArray; 
+	PROCEDURE ^ Array2*(x, y: LONGINT): IndexArray; 
+	PROCEDURE ^ Array3*(x, y, z: LONGINT): IndexArray; 
+	PROCEDURE ^ Index3*(x, y, z: LONGINT): IndexArray; 
+	PROCEDURE ^ Index4*(x, y, z, t: LONGINT): IndexArray; 
+	PROCEDURE ^ Array4*(x, y, z, t: LONGINT): IndexArray; 
+	PROCEDURE ^ IndexX*(VAR a: ARRAY OF LONGINT): IndexArray; 
+	PROCEDURE ^ IndexCpy*(src: IndexArray): IndexArray; 
+	PROCEDURE ^ Get1*(a: Array; x: Index; VAR v: ARRAY OF SYSTEM.BYTE); 
+	PROCEDURE ^ Get2*(a: Array; x, y: Index; VAR v: ARRAY OF SYSTEM.BYTE); 
+	PROCEDURE ^ Get3*(a: Array; x, y, z: Index; VAR v: ARRAY OF SYSTEM.BYTE); 
+	PROCEDURE ^ Get4*(a: Array; x, y, z, t: Index; VAR v: ARRAY OF SYSTEM.BYTE); 
+	PROCEDURE ^ GetX*(a: Array; VAR b: ARRAY OF Index; dim: Index; VAR v: ARRAY OF SYSTEM.BYTE); 
+	PROCEDURE ^ Set1*(a: Array; x: Index; VAR v: ARRAY OF SYSTEM.BYTE); 
+	PROCEDURE ^ Set2*(a: Array; x, y: Index; VAR v: ARRAY OF SYSTEM.BYTE); 
+	PROCEDURE ^ Set3*(a: Array; x, y, z: Index; VAR v: ARRAY OF SYSTEM.BYTE); 
+	PROCEDURE ^ Set4*(a: Array; x, y, z, t: Index; VAR v: ARRAY OF SYSTEM.BYTE); 
+	PROCEDURE ^ SetX*(a: Array; VAR b: ARRAY OF Index; dim: Index; VAR v: ARRAY OF SYSTEM.BYTE); 
+	PROCEDURE ^ CopyArrayPartToArrayPart*(srcmem, destmem: ArrayMemoryStructure; srcpos, srclen, destpos, destlen: IndexArray); 
+	PROCEDURE ^ FillArrayPart*(mem: ArrayMemoryStructure; pos, len: IndexArray; val: ARRAY OF SYSTEM.BYTE); 
+	PROCEDURE ^ CopyArrayToMemory*(srcmem: ArrayMemoryStructure; destadr: Index; nrelems: Index); 
+	PROCEDURE ^ CopyMemoryToArray*(srcadr: Index; destmem: ArrayMemoryStructure; nrelems: Index); 
+	PROCEDURE ^ CopyArrayPartToMemory*(srcmem: ArrayMemoryStructure; destadr: Index; srcpos, srclen: IndexArray; destlen: Index); 
+	PROCEDURE ^ CopyMemoryToArrayPart*(srcadr: Index; destmem: ArrayMemoryStructure; srclen: Index; destpos, destlen: IndexArray); 
+	PROCEDURE {FingerPrint(-677094810)}  - InBounds*(origin, len: Index; idx: Index): BOOLEAN;
+	CODE {SYSTEM.i386}
+		; if (idx < origin) or (idx-origin >= len) then return false end;
+		; return true;
+		; AL=1 : TRUE; AL=0: FALSE
+		MOV	EAX, [ESP]	;  EAX := idx
+		MOV	EBX, [ESP+4]	;  EBX := len
+		MOV	ECX, [ESP+8]	;  ECX := origin
+		CMP	EAX, ECX	;
+		JL	outbound	;  idx < origin: outbound
+		SUB	EAX, ECX
+		CMP	EAX, EBX
+		JGE	outbound	;  (idx-origin) >= len
+		MOV	AL, 1
+		JMP	done	;
+		outbound:
+		MOV	AL, 0
+		done:
+		ADD	ESP, 12
+	
+	END InBounds; 
+	PROCEDURE {FingerPrint(1387277801)}  - PeriodicBounds*(origin, len: Index; idx: Index): Index;
+	CODE {SYSTEM.i386}
+		; DEC( idx, origin );  idx := idx MOD len;  INC( idx, origin );
+
+		; modulus:
+		; a := b MOD c; 	c -> EBX	; b -> EAX
+
+		; CDQ
+		; IDIV EBX
+		; CMP     EDX,0
+		; JNL     2
+		; ADD     EDX,EBX
+
+		; EDX -> a
+
+		MOV	EAX, [ESP]	;  EAX := idx
+		SUB	EAX, [ESP+8]	;  EAX := EAX-origin
+		MOV	EBX, [ESP+4]	;  EBX := len
+		CDQ
+		IDIV	EBX
+		CMP	EDX, 0
+		JNL	2
+		ADD	EDX, EBX
+		MOV	EAX, EDX
+		ADD	EAX, [ESP+8]
+		ADD	ESP, 12
+	
+	END PeriodicBounds; 
+	PROCEDURE ^ MirrorOnB*(origin, len: Index; idx: Index): Index; 
+	PROCEDURE ^ MirrorOffB*(origin, len: Index; idx: Index): Index; 
+	PROCEDURE ^ TestB*; 
+BEGIN
+END ArrayXdBytes.

lin32/bin/ArrayXdCplx.SymU

@@ -0,0 +1,157 @@
+MODULE ArrayXdCplx;
+	IMPORT SYSTEM, NbrInt, ArrayXdBytes, Array1d := Array1dCplx, NbrCplx, dbgOut := KernelLog, DataErrors, Array1dInt, ArrayXdRat, ArrayXdRe, DataIO;
+CONST 
+	generic* = 0; 
+	vector* = 1; 
+	matrix* = 2; 
+	cube* = 3; 
+	hcube* = 4; 
+	VERSION* = 1; 
+	StrictBoundaryC* = 0; 
+	AbsorbingBoundaryC* = 1; 
+	PeriodicBoundaryC* = 2; 
+	SymmetricOnBoundaryC* = 3; 
+	SymmetricOffBoundaryC* = 4; 
+	AntisymmetricOnBoundaryC* = 5; 
+	AntisymmetricOffBoundaryC* = 6; 
+TYPE 
+	Value* = Array1d.Value; 
+
+	Index* = LONGINT; 
+
+	Array1* = Array1d.Array; 
+
+	IntValue* = Array1dInt.Value; 
+
+	Array2* = POINTER TO ARRAY OF ARRAY OF Value; 
+
+	Array3* = POINTER TO ARRAY OF ARRAY OF ARRAY OF Value; 
+
+	Array4* = POINTER TO ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value; 
+
+	Map* = Array1d.Map; 
+
+	Array* = OBJECT {EXCLUSIVE} (ArrayXdBytes.Array)
+	VAR 
+		data-: Array1; 
+
+		PROCEDURE ^ Allocate*(size: LONGINT; VAR adr: Index; VAR ptr: ANY); 
+		PROCEDURE ^ GetInfo*(VAR elementsize: Index); 
+		PROCEDURE ^ AlikeX*(): ArrayXdBytes.Array; 
+		PROCEDURE ^ Read*(R: DataIO.Reader); 
+		PROCEDURE ^ Write*(W: DataIO.Writer); 
+		PROCEDURE ^ Type*(): SHORTINT; 
+		PROCEDURE ^ Get1*(x: Index): Value; 
+		PROCEDURE ^ Set1*(x: Index; v: Value); 
+		PROCEDURE ^ Get2*(x, y: Index): Value; 
+		PROCEDURE ^ Set2*(x, y: Index; v: Value); 
+		PROCEDURE ^ Get3*(x, y, z: Index): Value; 
+		PROCEDURE ^ Set3*(x, y, z: Index; v: Value); 
+		PROCEDURE ^ Get4*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ Set4*(x, y, z, t: Index; v: Value); 
+		PROCEDURE ^ GetX*(VAR x: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ SetX*(VAR x: ARRAY OF Index; dim: Index; v: Value); 
+		PROCEDURE ^ Get1BAbsorbing*(x: Index): Value; 
+		PROCEDURE ^ Get2BAbsorbing*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BAbsorbing*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BAbsorbing*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBAbsorbing*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BPeriodic*(x: Index): Value; 
+		PROCEDURE ^ Get2BPeriodic*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BPeriodic*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BPeriodic*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBPeriodic*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BSymmetricOffB*(x: Index): Value; 
+		PROCEDURE ^ Get2BSymmetricOffB*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BSymmetricOffB*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BSymmetricOffB*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBSymmetricOffB*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BSymmetricOnB*(x: Index): Value; 
+		PROCEDURE ^ Get2BSymmetricOnB*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BSymmetricOnB*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BSymmetricOnB*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBSymmetricOnB*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BAntisymmetricOffB*(x: Index): Value; 
+		PROCEDURE ^ Get2BAntisymmetricOffB*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BAntisymmetricOffB*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BAntisymmetricOffB*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBAntisymmetricOffB*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BAntisymmetricOnB*(x: Index): Value; 
+		PROCEDURE ^ Get2BAntisymmetricOnB*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BAntisymmetricOnB*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BAntisymmetricOnB*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBAntisymmetricOnB*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ CopyToArray*(dest: Array; srcpos, srclen, destpos, destlen: ArrayXdBytes.IndexArray); 
+		PROCEDURE ^ MapAll*(m: Array1d.Map); 
+		PROCEDURE ^ Negate*; 
+		PROCEDURE ^ Add*(x: Array); 
+		PROCEDURE ^ Subtract*(x: Array); 
+		PROCEDURE ^ Multiply*(a: Value); 
+		PROCEDURE ^ Divide*(a: Value); 
+		PROCEDURE ^ dbgWrite*; 
+	END Array; 
+VAR 
+	zero: Value; 
+
+	PROCEDURE ^ New1d*(ox, w: Index): Array; 
+	PROCEDURE ^ New2d*(ox, w, oy, h: Index): Array; 
+	PROCEDURE ^ New3d*(ox, w, oy, h, oz, d: Index): Array; 
+	PROCEDURE ^ New4d*(ox, w, oy, h, oz, d, ot, dt: Index): Array; 
+	PROCEDURE ^ CopyVecToVec*(src, dest: Array; srcx, destx, len: Index); 
+	PROCEDURE ^ CopyMtxToVec*(src, dest: Array; dim: Index; srcx, srcy, destx, len: Index); 
+	PROCEDURE ^ CopyVecToMtx*(src, dest: Array; dim: Index; srcx, destx, desty, len: Index); 
+	PROCEDURE ^ CopyCubeToVec*(src, dest: Array; dim: Index; srcx, srcy, srcz, destx, len: Index); 
+	PROCEDURE ^ CopyVecToCube*(src, dest: Array; dim: Index; srcx, destx, desty, destz, len: Index); 
+	PROCEDURE ^ CopyHCubeToVec*(src, dest: Array; dim: Index; srcx, srcy, srcz, srct, destx, len: Index); 
+	PROCEDURE ^ CopyVecToHCube*(src, dest: Array; dim: Index; srcx, destx, desty, destz, destt, len: Index); 
+	PROCEDURE ^ CopyMtxToMtx*(src, dest: Array; srcx, srcy, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyCubeToMtx*(src, dest: Array; dimx, dimy: Index; srcx, srcy, srcz, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyMtxToCube*(src, dest: Array; dimx, dimy: Index; srcx, srcy, destx, desty, destz, lenx, leny: Index); 
+	PROCEDURE ^ CopyHCubeToMtx*(src, dest: Array; dimx, dimy: Index; srcx, srcy, srcz, srct, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyMtxToHCube*(src, dest: Array; dimx, dimy: Index; srcx, srcy, destx, desty, destz, destt, lenx, leny: Index); 
+	PROCEDURE ^ CopyCubeToCube*(src, dest: Array; srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyHCubeToCube*(src, dest: Array; dimx, dimy, dimz: Index; srcx, srcy, srcz, srct, destx, desty, destz, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyCubeToHCube*(src, dest: Array; dimx, dimy, dimz: Index; srcx, srcy, srcz, destx, desty, destz, destt, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyHCubeToHCube*(src, dest: Array; srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index); 
+	PROCEDURE ^ CopyArrayToVec*(VAR src: ARRAY OF Value; dest: Array; srcx, destx, len: Index); 
+	PROCEDURE ^ CopyVecToArray*(src: Array; VAR dest: ARRAY OF Value; srcx, destx, len: Index); 
+	PROCEDURE ^ CopyArrayToMtx*(VAR src: ARRAY OF ARRAY OF Value; dest: Array; srcx, srcy, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyMtxToArray*(src: Array; VAR dest: ARRAY OF ARRAY OF Value; srcx, srcy, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyArrayToCube*(VAR src: ARRAY OF ARRAY OF ARRAY OF Value; dest: Array; srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyCubeToArray*(src: Array; VAR dest: ARRAY OF ARRAY OF ARRAY OF Value; srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyArrayToHCube*(VAR src: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value; dest: Array; srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index); 
+	PROCEDURE ^ CopyHCubeToArray*(src: Array; VAR dest: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value; srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index); 
+	PROCEDURE ^ CopyArrayToArrayPartB*(src: Array; dest: ArrayXdBytes.ArrayMemoryStructure; boundaryCondition: SHORTINT; srcpos, srclen, destpos, destlen: ArrayXdBytes.IndexArray); 
+	OPERATOR ^ ":="-(VAR l: Array1; r: Array); 
+	OPERATOR ^ ":="-(VAR l: Array2; r: Array); 
+	OPERATOR ^ ":="-(VAR l: Array3; r: Array); 
+	PROCEDURE ^ Fill*(l: Array; r: Value); 
+	OPERATOR ^ ":="-(VAR l: Array; r: Value); 
+	OPERATOR ^ ":="-(VAR l: Array; r: ArrayXdRe.Value); 
+	OPERATOR ^ ":="-(VAR l: Array; r: ArrayXdRat.Value); 
+	OPERATOR ^ ":="-(VAR l: Array; r: IntValue); 
+	PROCEDURE ^ Add*(l, r, res: Array); 
+	OPERATOR ^ "+"-(l, r: Array): Array; 
+	PROCEDURE ^ Sub*(l, r, res: Array); 
+	OPERATOR ^ "-"-(l, r: Array): Array; 
+	PROCEDURE ^ Mul*(l, r, res: Array); 
+	PROCEDURE ^ Div*(l, r, res: Array); 
+	PROCEDURE ^ AddAV*(l: Array; r: Value; res: Array); 
+	OPERATOR ^ "+"(l: Array; r: IntValue): Array; 
+	OPERATOR ^ "+"(l: IntValue; r: Array): Array; 
+	PROCEDURE ^ MulAV*(l: Array; r: Value; res: Array); 
+	OPERATOR ^ "*"(l: Array; r: IntValue): Array; 
+	OPERATOR ^ "*"(l: IntValue; r: Array): Array; 
+	PROCEDURE ^ DivAV*(l: Array; r: Value; res: Array); 
+	PROCEDURE ^ DivVA*(l: Value; r: Array; res: Array); 
+	PROCEDURE ^ SubAV*(l: Array; r: Value; res: Array); 
+	PROCEDURE ^ SubVA*(l: Value; r: Array; res: Array); 
+	OPERATOR ^ "-"-(l: Value; r: Array): Array; 
+	OPERATOR ^ "-"-(l: IntValue; r: Array): Array; 
+	PROCEDURE ^ LoadArray(R: DataIO.Reader; VAR obj: OBJECT); 
+	PROCEDURE ^ StoreArray(W: DataIO.Writer; obj: OBJECT); 
+	PROCEDURE ^ Register; 
+	PROCEDURE ^ Load*(R: DataIO.Reader; VAR obj: Array); 
+	PROCEDURE ^ Store*(W: DataIO.Writer; obj: Array); 
+BEGIN
+END ArrayXdCplx.

lin32/bin/ArrayXdInt.SymU

@@ -0,0 +1,155 @@
+MODULE ArrayXdInt;
+	IMPORT SYSTEM, NbrInt, ArrayXdBytes, Array1d := Array1dInt, dbgOut := KernelLog, DataErrors, DataIO;
+CONST 
+	generic* = 0; 
+	vector* = 1; 
+	matrix* = 2; 
+	cube* = 3; 
+	hcube* = 4; 
+	VERSION* = 1; 
+	StrictBoundaryC* = 0; 
+	AbsorbingBoundaryC* = 1; 
+	PeriodicBoundaryC* = 2; 
+	SymmetricOnBoundaryC* = 3; 
+	SymmetricOffBoundaryC* = 4; 
+	AntisymmetricOnBoundaryC* = 5; 
+	AntisymmetricOffBoundaryC* = 6; 
+TYPE 
+	Value* = Array1d.Value; 
+
+	Index* = LONGINT; 
+
+	Array1* = Array1d.Array; 
+
+	Array2* = POINTER TO ARRAY OF ARRAY OF Value; 
+
+	Array3* = POINTER TO ARRAY OF ARRAY OF ARRAY OF Value; 
+
+	Array4* = POINTER TO ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value; 
+
+	Map* = Array1d.Map; 
+
+	Array* = OBJECT {EXCLUSIVE} (ArrayXdBytes.Array)
+	VAR 
+		data-: Array1; 
+
+		PROCEDURE ^ Allocate*(size: LONGINT; VAR adr: Index; VAR ptr: ANY); 
+		PROCEDURE ^ GetInfo*(VAR elementsize: Index); 
+		PROCEDURE ^ AlikeX*(): ArrayXdBytes.Array; 
+		PROCEDURE ^ Read*(R: DataIO.Reader); 
+		PROCEDURE ^ Write*(W: DataIO.Writer); 
+		PROCEDURE ^ Type*(): SHORTINT; 
+		PROCEDURE ^ Get1*(x: Index): Value; 
+		PROCEDURE ^ Set1*(x: Index; v: Value); 
+		PROCEDURE ^ Get2*(x, y: Index): Value; 
+		PROCEDURE ^ Set2*(x, y: Index; v: Value); 
+		PROCEDURE ^ Get3*(x, y, z: Index): Value; 
+		PROCEDURE ^ Set3*(x, y, z: Index; v: Value); 
+		PROCEDURE ^ Get4*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ Set4*(x, y, z, t: Index; v: Value); 
+		PROCEDURE ^ GetX*(VAR x: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ SetX*(VAR x: ARRAY OF Index; dim: Index; v: Value); 
+		PROCEDURE ^ Get1BAbsorbing*(x: Index): Value; 
+		PROCEDURE ^ Get2BAbsorbing*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BAbsorbing*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BAbsorbing*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBAbsorbing*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BPeriodic*(x: Index): Value; 
+		PROCEDURE ^ Get2BPeriodic*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BPeriodic*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BPeriodic*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBPeriodic*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BSymmetricOffB*(x: Index): Value; 
+		PROCEDURE ^ Get2BSymmetricOffB*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BSymmetricOffB*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BSymmetricOffB*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBSymmetricOffB*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BSymmetricOnB*(x: Index): Value; 
+		PROCEDURE ^ Get2BSymmetricOnB*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BSymmetricOnB*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BSymmetricOnB*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBSymmetricOnB*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BAntisymmetricOffB*(x: Index): Value; 
+		PROCEDURE ^ Get2BAntisymmetricOffB*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BAntisymmetricOffB*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BAntisymmetricOffB*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBAntisymmetricOffB*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BAntisymmetricOnB*(x: Index): Value; 
+		PROCEDURE ^ Get2BAntisymmetricOnB*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BAntisymmetricOnB*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BAntisymmetricOnB*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBAntisymmetricOnB*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ CopyToArray*(dest: Array; srcpos, srclen, destpos, destlen: ArrayXdBytes.IndexArray); 
+		PROCEDURE ^ MapAll*(m: Array1d.Map); 
+		PROCEDURE ^ Negate*; 
+		PROCEDURE ^ Add*(x: Array); 
+		PROCEDURE ^ Subtract*(x: Array); 
+		PROCEDURE ^ Multiply*(a: Value); 
+		PROCEDURE ^ Divide*(a: Value); 
+		PROCEDURE ^ Modulus*(a: Value); 
+		PROCEDURE ^ dbgWrite*; 
+	END Array; 
+
+	PROCEDURE ^ New1d*(ox, w: Index): Array; 
+	PROCEDURE ^ New2d*(ox, w, oy, h: Index): Array; 
+	PROCEDURE ^ New3d*(ox, w, oy, h, oz, d: Index): Array; 
+	PROCEDURE ^ New4d*(ox, w, oy, h, oz, d, ot, dt: Index): Array; 
+	PROCEDURE ^ CopyVecToVec*(src, dest: Array; srcx, destx, len: Index); 
+	PROCEDURE ^ CopyMtxToVec*(src, dest: Array; dim: Index; srcx, srcy, destx, len: Index); 
+	PROCEDURE ^ CopyVecToMtx*(src, dest: Array; dim: Index; srcx, destx, desty, len: Index); 
+	PROCEDURE ^ CopyCubeToVec*(src, dest: Array; dim: Index; srcx, srcy, srcz, destx, len: Index); 
+	PROCEDURE ^ CopyVecToCube*(src, dest: Array; dim: Index; srcx, destx, desty, destz, len: Index); 
+	PROCEDURE ^ CopyHCubeToVec*(src, dest: Array; dim: Index; srcx, srcy, srcz, srct, destx, len: Index); 
+	PROCEDURE ^ CopyVecToHCube*(src, dest: Array; dim: Index; srcx, destx, desty, destz, destt, len: Index); 
+	PROCEDURE ^ CopyMtxToMtx*(src, dest: Array; srcx, srcy, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyCubeToMtx*(src, dest: Array; dimx, dimy: Index; srcx, srcy, srcz, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyMtxToCube*(src, dest: Array; dimx, dimy: Index; srcx, srcy, destx, desty, destz, lenx, leny: Index); 
+	PROCEDURE ^ CopyHCubeToMtx*(src, dest: Array; dimx, dimy: Index; srcx, srcy, srcz, srct, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyMtxToHCube*(src, dest: Array; dimx, dimy: Index; srcx, srcy, destx, desty, destz, destt, lenx, leny: Index); 
+	PROCEDURE ^ CopyCubeToCube*(src, dest: Array; srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyHCubeToCube*(src, dest: Array; dimx, dimy, dimz: Index; srcx, srcy, srcz, srct, destx, desty, destz, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyCubeToHCube*(src, dest: Array; dimx, dimy, dimz: Index; srcx, srcy, srcz, destx, desty, destz, destt, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyHCubeToHCube*(src, dest: Array; srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index); 
+	PROCEDURE ^ CopyArrayToVec*(VAR src: ARRAY OF Value; dest: Array; srcx, destx, len: Index); 
+	PROCEDURE ^ CopyVecToArray*(src: Array; VAR dest: ARRAY OF Value; srcx, destx, len: Index); 
+	PROCEDURE ^ CopyArrayToMtx*(VAR src: ARRAY OF ARRAY OF Value; dest: Array; srcx, srcy, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyMtxToArray*(src: Array; VAR dest: ARRAY OF ARRAY OF Value; srcx, srcy, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyArrayToCube*(VAR src: ARRAY OF ARRAY OF ARRAY OF Value; dest: Array; srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyCubeToArray*(src: Array; VAR dest: ARRAY OF ARRAY OF ARRAY OF Value; srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyArrayToHCube*(VAR src: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value; dest: Array; srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index); 
+	PROCEDURE ^ CopyHCubeToArray*(src: Array; VAR dest: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value; srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index); 
+	PROCEDURE ^ CopyArrayToArrayPartB*(src: Array; dest: ArrayXdBytes.ArrayMemoryStructure; boundaryCondition: SHORTINT; srcpos, srclen, destpos, destlen: ArrayXdBytes.IndexArray); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF ARRAY OF ARRAY OF Value); 
+	OPERATOR ^ ":="-(VAR l: Array1; r: Array); 
+	OPERATOR ^ ":="-(VAR l: Array2; r: Array); 
+	OPERATOR ^ ":="-(VAR l: Array3; r: Array); 
+	PROCEDURE ^ Fill*(l: Array; r: Value); 
+	OPERATOR ^ ":="-(VAR l: Array; r: Value); 
+	PROCEDURE ^ Add*(l, r, res: Array); 
+	OPERATOR ^ "+"-(l, r: Array): Array; 
+	PROCEDURE ^ Sub*(l, r, res: Array); 
+	OPERATOR ^ "-"-(l, r: Array): Array; 
+	PROCEDURE ^ Mul*(l, r, res: Array); 
+	PROCEDURE ^ Div*(l, r, res: Array); 
+	PROCEDURE ^ Mod*(l, r, res: Array); 
+	PROCEDURE ^ AddAV*(l: Array; r: Value; res: Array); 
+	OPERATOR ^ "+"(l: Array; r: Value): Array; 
+	OPERATOR ^ "+"(l: Value; r: Array): Array; 
+	PROCEDURE ^ MulAV*(l: Array; r: Value; res: Array); 
+	OPERATOR ^ "*"(l: Array; r: Value): Array; 
+	OPERATOR ^ "*"(l: Value; r: Array): Array; 
+	PROCEDURE ^ DivAV*(l: Array; r: Value; res: Array); 
+	PROCEDURE ^ DivVA*(l: Value; r: Array; res: Array); 
+	PROCEDURE ^ ModAV*(l: Array; r: Value; res: Array); 
+	PROCEDURE ^ ModVA*(l: Value; r: Array; res: Array); 
+	PROCEDURE ^ SubAV*(l: Array; r: Value; res: Array); 
+	PROCEDURE ^ SubVA*(l: Value; r: Array; res: Array); 
+	OPERATOR ^ "-"-(l: Value; r: Array): Array; 
+	PROCEDURE ^ LoadArray(R: DataIO.Reader; VAR obj: OBJECT); 
+	PROCEDURE ^ StoreArray(W: DataIO.Writer; obj: OBJECT); 
+	PROCEDURE ^ Register; 
+	PROCEDURE ^ Load*(R: DataIO.Reader; VAR obj: Array); 
+	PROCEDURE ^ Store*(W: DataIO.Writer; obj: Array); 
+BEGIN
+END ArrayXdInt.

lin32/bin/ArrayXdRat.SymU

@@ -0,0 +1,154 @@
+MODULE ArrayXdRat;
+	IMPORT SYSTEM, NbrInt, ArrayXdBytes, Array1d := Array1dRat, dbgOut := KernelLog, NbrRat, DataErrors, Array1dInt, DataIO;
+CONST 
+	generic* = 0; 
+	vector* = 1; 
+	matrix* = 2; 
+	cube* = 3; 
+	hcube* = 4; 
+	VERSION* = 1; 
+	StrictBoundaryC* = 0; 
+	AbsorbingBoundaryC* = 1; 
+	PeriodicBoundaryC* = 2; 
+	SymmetricOnBoundaryC* = 3; 
+	SymmetricOffBoundaryC* = 4; 
+	AntisymmetricOnBoundaryC* = 5; 
+	AntisymmetricOffBoundaryC* = 6; 
+TYPE 
+	Value* = Array1d.Value; 
+
+	Index* = LONGINT; 
+
+	Array1* = Array1d.Array; 
+
+	IntValue* = Array1dInt.Value; 
+
+	Array2* = POINTER TO ARRAY OF ARRAY OF Value; 
+
+	Array3* = POINTER TO ARRAY OF ARRAY OF ARRAY OF Value; 
+
+	Array4* = POINTER TO ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value; 
+
+	Map* = Array1d.Map; 
+
+	Array* = OBJECT {EXCLUSIVE} (ArrayXdBytes.Array)
+	VAR 
+		data-: Array1; 
+
+		PROCEDURE ^ Allocate*(size: LONGINT; VAR adr: Index; VAR ptr: ANY); 
+		PROCEDURE ^ GetInfo*(VAR elementsize: Index); 
+		PROCEDURE ^ AlikeX*(): ArrayXdBytes.Array; 
+		PROCEDURE ^ Read*(R: DataIO.Reader); 
+		PROCEDURE ^ Write*(W: DataIO.Writer); 
+		PROCEDURE ^ Type*(): SHORTINT; 
+		PROCEDURE ^ Get1*(x: Index): Value; 
+		PROCEDURE ^ Set1*(x: Index; v: Value); 
+		PROCEDURE ^ Get2*(x, y: Index): Value; 
+		PROCEDURE ^ Set2*(x, y: Index; v: Value); 
+		PROCEDURE ^ Get3*(x, y, z: Index): Value; 
+		PROCEDURE ^ Set3*(x, y, z: Index; v: Value); 
+		PROCEDURE ^ Get4*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ Set4*(x, y, z, t: Index; v: Value); 
+		PROCEDURE ^ GetX*(VAR x: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ SetX*(VAR x: ARRAY OF Index; dim: Index; v: Value); 
+		PROCEDURE ^ Get1BAbsorbing*(x: Index): Value; 
+		PROCEDURE ^ Get2BAbsorbing*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BAbsorbing*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BAbsorbing*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBAbsorbing*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BPeriodic*(x: Index): Value; 
+		PROCEDURE ^ Get2BPeriodic*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BPeriodic*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BPeriodic*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBPeriodic*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BSymmetricOffB*(x: Index): Value; 
+		PROCEDURE ^ Get2BSymmetricOffB*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BSymmetricOffB*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BSymmetricOffB*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBSymmetricOffB*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BSymmetricOnB*(x: Index): Value; 
+		PROCEDURE ^ Get2BSymmetricOnB*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BSymmetricOnB*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BSymmetricOnB*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBSymmetricOnB*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BAntisymmetricOffB*(x: Index): Value; 
+		PROCEDURE ^ Get2BAntisymmetricOffB*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BAntisymmetricOffB*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BAntisymmetricOffB*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBAntisymmetricOffB*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BAntisymmetricOnB*(x: Index): Value; 
+		PROCEDURE ^ Get2BAntisymmetricOnB*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BAntisymmetricOnB*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BAntisymmetricOnB*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBAntisymmetricOnB*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ CopyToArray*(dest: Array; srcpos, srclen, destpos, destlen: ArrayXdBytes.IndexArray); 
+		PROCEDURE ^ MapAll*(m: Array1d.Map); 
+		PROCEDURE ^ Negate*; 
+		PROCEDURE ^ Add*(x: Array); 
+		PROCEDURE ^ Subtract*(x: Array); 
+		PROCEDURE ^ Multiply*(a: Value); 
+		PROCEDURE ^ Divide*(a: Value); 
+		PROCEDURE ^ dbgWrite*; 
+	END Array; 
+VAR 
+	zero: Value; 
+
+	PROCEDURE ^ New1d*(ox, w: Index): Array; 
+	PROCEDURE ^ New2d*(ox, w, oy, h: Index): Array; 
+	PROCEDURE ^ New3d*(ox, w, oy, h, oz, d: Index): Array; 
+	PROCEDURE ^ New4d*(ox, w, oy, h, oz, d, ot, dt: Index): Array; 
+	PROCEDURE ^ CopyVecToVec*(src, dest: Array; srcx, destx, len: Index); 
+	PROCEDURE ^ CopyMtxToVec*(src, dest: Array; dim: Index; srcx, srcy, destx, len: Index); 
+	PROCEDURE ^ CopyVecToMtx*(src, dest: Array; dim: Index; srcx, destx, desty, len: Index); 
+	PROCEDURE ^ CopyCubeToVec*(src, dest: Array; dim: Index; srcx, srcy, srcz, destx, len: Index); 
+	PROCEDURE ^ CopyVecToCube*(src, dest: Array; dim: Index; srcx, destx, desty, destz, len: Index); 
+	PROCEDURE ^ CopyHCubeToVec*(src, dest: Array; dim: Index; srcx, srcy, srcz, srct, destx, len: Index); 
+	PROCEDURE ^ CopyVecToHCube*(src, dest: Array; dim: Index; srcx, destx, desty, destz, destt, len: Index); 
+	PROCEDURE ^ CopyMtxToMtx*(src, dest: Array; srcx, srcy, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyCubeToMtx*(src, dest: Array; dimx, dimy: Index; srcx, srcy, srcz, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyMtxToCube*(src, dest: Array; dimx, dimy: Index; srcx, srcy, destx, desty, destz, lenx, leny: Index); 
+	PROCEDURE ^ CopyHCubeToMtx*(src, dest: Array; dimx, dimy: Index; srcx, srcy, srcz, srct, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyMtxToHCube*(src, dest: Array; dimx, dimy: Index; srcx, srcy, destx, desty, destz, destt, lenx, leny: Index); 
+	PROCEDURE ^ CopyCubeToCube*(src, dest: Array; srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyHCubeToCube*(src, dest: Array; dimx, dimy, dimz: Index; srcx, srcy, srcz, srct, destx, desty, destz, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyCubeToHCube*(src, dest: Array; dimx, dimy, dimz: Index; srcx, srcy, srcz, destx, desty, destz, destt, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyHCubeToHCube*(src, dest: Array; srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index); 
+	PROCEDURE ^ CopyArrayToVec*(VAR src: ARRAY OF Value; dest: Array; srcx, destx, len: Index); 
+	PROCEDURE ^ CopyVecToArray*(src: Array; VAR dest: ARRAY OF Value; srcx, destx, len: Index); 
+	PROCEDURE ^ CopyArrayToMtx*(VAR src: ARRAY OF ARRAY OF Value; dest: Array; srcx, srcy, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyMtxToArray*(src: Array; VAR dest: ARRAY OF ARRAY OF Value; srcx, srcy, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyArrayToCube*(VAR src: ARRAY OF ARRAY OF ARRAY OF Value; dest: Array; srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyCubeToArray*(src: Array; VAR dest: ARRAY OF ARRAY OF ARRAY OF Value; srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyArrayToHCube*(VAR src: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value; dest: Array; srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index); 
+	PROCEDURE ^ CopyHCubeToArray*(src: Array; VAR dest: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value; srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index); 
+	PROCEDURE ^ CopyArrayToArrayPartB*(src: Array; dest: ArrayXdBytes.ArrayMemoryStructure; boundaryCondition: SHORTINT; srcpos, srclen, destpos, destlen: ArrayXdBytes.IndexArray); 
+	OPERATOR ^ ":="-(VAR l: Array1; r: Array); 
+	OPERATOR ^ ":="-(VAR l: Array2; r: Array); 
+	OPERATOR ^ ":="-(VAR l: Array3; r: Array); 
+	PROCEDURE ^ Fill*(l: Array; r: Value); 
+	PROCEDURE ^ Add*(l, r, res: Array); 
+	OPERATOR ^ "+"-(l, r: Array): Array; 
+	PROCEDURE ^ Sub*(l, r, res: Array); 
+	OPERATOR ^ "-"-(l, r: Array): Array; 
+	PROCEDURE ^ Mul*(l, r, res: Array); 
+	PROCEDURE ^ Div*(l, r, res: Array); 
+	PROCEDURE ^ AddAV*(l: Array; r: Value; res: Array); 
+	OPERATOR ^ "+"(l: Array; r: IntValue): Array; 
+	OPERATOR ^ "+"(l: IntValue; r: Array): Array; 
+	PROCEDURE ^ MulAV*(l: Array; r: Value; res: Array); 
+	OPERATOR ^ "*"(l: Array; r: IntValue): Array; 
+	OPERATOR ^ "*"(l: IntValue; r: Array): Array; 
+	PROCEDURE ^ DivAV*(l: Array; r: Value; res: Array); 
+	PROCEDURE ^ DivVA*(l: Value; r: Array; res: Array); 
+	OPERATOR ^ "/"(l: IntValue; r: Array): Array; 
+	PROCEDURE ^ SubAV*(l: Array; r: Value; res: Array); 
+	PROCEDURE ^ SubVA*(l: Value; r: Array; res: Array); 
+	OPERATOR ^ "-"-(l: Value; r: Array): Array; 
+	OPERATOR ^ "-"-(l: IntValue; r: Array): Array; 
+	PROCEDURE ^ LoadArray(R: DataIO.Reader; VAR obj: OBJECT); 
+	PROCEDURE ^ StoreArray(W: DataIO.Writer; obj: OBJECT); 
+	PROCEDURE ^ Register; 
+	PROCEDURE ^ Load*(R: DataIO.Reader; VAR obj: Array); 
+	PROCEDURE ^ Store*(W: DataIO.Writer; obj: Array); 
+BEGIN
+END ArrayXdRat.

lin32/bin/ArrayXdRe.SymU

@@ -0,0 +1,156 @@
+MODULE ArrayXdRe;
+	IMPORT SYSTEM, NbrInt, NbrRe, ArrayXdBytes, Array1d := Array1dRe, dbgOut := KernelLog, DataErrors, Array1dInt, ArrayXdRat, DataIO;
+CONST 
+	generic* = 0; 
+	vector* = 1; 
+	matrix* = 2; 
+	cube* = 3; 
+	hcube* = 4; 
+	VERSION* = 1; 
+	StrictBoundaryC* = 0; 
+	AbsorbingBoundaryC* = 1; 
+	PeriodicBoundaryC* = 2; 
+	SymmetricOnBoundaryC* = 3; 
+	SymmetricOffBoundaryC* = 4; 
+	AntisymmetricOnBoundaryC* = 5; 
+	AntisymmetricOffBoundaryC* = 6; 
+TYPE 
+	Value* = Array1d.Value; 
+
+	Index* = LONGINT; 
+
+	Array1* = Array1d.Array; 
+
+	IntValue* = Array1dInt.Value; 
+
+	Array2* = POINTER TO ARRAY OF ARRAY OF Value; 
+
+	Array3* = POINTER TO ARRAY OF ARRAY OF ARRAY OF Value; 
+
+	Array4* = POINTER TO ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value; 
+
+	Map* = Array1d.Map; 
+
+	Array* = OBJECT {EXCLUSIVE} (ArrayXdBytes.Array)
+	VAR 
+		data-: Array1; 
+
+		PROCEDURE ^ Allocate*(size: LONGINT; VAR adr: Index; VAR ptr: ANY); 
+		PROCEDURE ^ GetInfo*(VAR elementsize: Index); 
+		PROCEDURE ^ AlikeX*(): ArrayXdBytes.Array; 
+		PROCEDURE ^ Read*(R: DataIO.Reader); 
+		PROCEDURE ^ Write*(W: DataIO.Writer); 
+		PROCEDURE ^ Type*(): SHORTINT; 
+		PROCEDURE ^ Get1*(x: Index): Value; 
+		PROCEDURE ^ Set1*(x: Index; v: Value); 
+		PROCEDURE ^ Get2*(x, y: Index): Value; 
+		PROCEDURE ^ Set2*(x, y: Index; v: Value); 
+		PROCEDURE ^ Get3*(x, y, z: Index): Value; 
+		PROCEDURE ^ Set3*(x, y, z: Index; v: Value); 
+		PROCEDURE ^ Get4*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ Set4*(x, y, z, t: Index; v: Value); 
+		PROCEDURE ^ GetX*(VAR x: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ SetX*(VAR x: ARRAY OF Index; dim: Index; v: Value); 
+		PROCEDURE ^ Get1BAbsorbing*(x: Index): Value; 
+		PROCEDURE ^ Get2BAbsorbing*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BAbsorbing*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BAbsorbing*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBAbsorbing*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BPeriodic*(x: Index): Value; 
+		PROCEDURE ^ Get2BPeriodic*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BPeriodic*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BPeriodic*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBPeriodic*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BSymmetricOffB*(x: Index): Value; 
+		PROCEDURE ^ Get2BSymmetricOffB*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BSymmetricOffB*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BSymmetricOffB*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBSymmetricOffB*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BSymmetricOnB*(x: Index): Value; 
+		PROCEDURE ^ Get2BSymmetricOnB*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BSymmetricOnB*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BSymmetricOnB*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBSymmetricOnB*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BAntisymmetricOffB*(x: Index): Value; 
+		PROCEDURE ^ Get2BAntisymmetricOffB*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BAntisymmetricOffB*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BAntisymmetricOffB*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBAntisymmetricOffB*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BAntisymmetricOnB*(x: Index): Value; 
+		PROCEDURE ^ Get2BAntisymmetricOnB*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BAntisymmetricOnB*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BAntisymmetricOnB*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBAntisymmetricOnB*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ CopyToArray*(dest: Array; srcpos, srclen, destpos, destlen: ArrayXdBytes.IndexArray); 
+		PROCEDURE ^ MapAll*(m: Array1d.Map); 
+		PROCEDURE ^ Negate*; 
+		PROCEDURE ^ Add*(x: Array); 
+		PROCEDURE ^ Subtract*(x: Array); 
+		PROCEDURE ^ Multiply*(a: Value); 
+		PROCEDURE ^ Divide*(a: Value); 
+		PROCEDURE ^ dbgWrite*; 
+	END Array; 
+
+	PROCEDURE ^ New1d*(ox, w: Index): Array; 
+	PROCEDURE ^ New2d*(ox, w, oy, h: Index): Array; 
+	PROCEDURE ^ New3d*(ox, w, oy, h, oz, d: Index): Array; 
+	PROCEDURE ^ New4d*(ox, w, oy, h, oz, d, ot, dt: Index): Array; 
+	PROCEDURE ^ CopyVecToVec*(src, dest: Array; srcx, destx, len: Index); 
+	PROCEDURE ^ CopyMtxToVec*(src, dest: Array; dim: Index; srcx, srcy, destx, len: Index); 
+	PROCEDURE ^ CopyVecToMtx*(src, dest: Array; dim: Index; srcx, destx, desty, len: Index); 
+	PROCEDURE ^ CopyCubeToVec*(src, dest: Array; dim: Index; srcx, srcy, srcz, destx, len: Index); 
+	PROCEDURE ^ CopyVecToCube*(src, dest: Array; dim: Index; srcx, destx, desty, destz, len: Index); 
+	PROCEDURE ^ CopyHCubeToVec*(src, dest: Array; dim: Index; srcx, srcy, srcz, srct, destx, len: Index); 
+	PROCEDURE ^ CopyVecToHCube*(src, dest: Array; dim: Index; srcx, destx, desty, destz, destt, len: Index); 
+	PROCEDURE ^ CopyMtxToMtx*(src, dest: Array; srcx, srcy, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyCubeToMtx*(src, dest: Array; dimx, dimy: Index; srcx, srcy, srcz, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyMtxToCube*(src, dest: Array; dimx, dimy: Index; srcx, srcy, destx, desty, destz, lenx, leny: Index); 
+	PROCEDURE ^ CopyHCubeToMtx*(src, dest: Array; dimx, dimy: Index; srcx, srcy, srcz, srct, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyMtxToHCube*(src, dest: Array; dimx, dimy: Index; srcx, srcy, destx, desty, destz, destt, lenx, leny: Index); 
+	PROCEDURE ^ CopyCubeToCube*(src, dest: Array; srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyHCubeToCube*(src, dest: Array; dimx, dimy, dimz: Index; srcx, srcy, srcz, srct, destx, desty, destz, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyCubeToHCube*(src, dest: Array; dimx, dimy, dimz: Index; srcx, srcy, srcz, destx, desty, destz, destt, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyHCubeToHCube*(src, dest: Array; srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index); 
+	PROCEDURE ^ CopyArrayToVec*(VAR src: ARRAY OF Value; dest: Array; srcx, destx, len: Index); 
+	PROCEDURE ^ CopyVecToArray*(src: Array; VAR dest: ARRAY OF Value; srcx, destx, len: Index); 
+	PROCEDURE ^ CopyArrayToMtx*(VAR src: ARRAY OF ARRAY OF Value; dest: Array; srcx, srcy, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyMtxToArray*(src: Array; VAR dest: ARRAY OF ARRAY OF Value; srcx, srcy, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyArrayToCube*(VAR src: ARRAY OF ARRAY OF ARRAY OF Value; dest: Array; srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyCubeToArray*(src: Array; VAR dest: ARRAY OF ARRAY OF ARRAY OF Value; srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyArrayToHCube*(VAR src: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value; dest: Array; srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index); 
+	PROCEDURE ^ CopyHCubeToArray*(src: Array; VAR dest: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value; srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index); 
+	PROCEDURE ^ CopyArrayToArrayPartB*(src: Array; dest: ArrayXdBytes.ArrayMemoryStructure; boundaryCondition: SHORTINT; srcpos, srclen, destpos, destlen: ArrayXdBytes.IndexArray); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF ARRAY OF ARRAY OF Value); 
+	OPERATOR ^ ":="-(VAR l: Array1; r: Array); 
+	OPERATOR ^ ":="-(VAR l: Array2; r: Array); 
+	OPERATOR ^ ":="-(VAR l: Array3; r: Array); 
+	PROCEDURE ^ Fill*(l: Array; r: Value); 
+	OPERATOR ^ ":="-(VAR l: Array; r: Value); 
+	OPERATOR ^ ":="-(VAR l: Array; r: ArrayXdRat.Value); 
+	OPERATOR ^ ":="-(VAR l: Array; r: IntValue); 
+	PROCEDURE ^ Add*(l, r, res: Array); 
+	OPERATOR ^ "+"-(l, r: Array): Array; 
+	PROCEDURE ^ Sub*(l, r, res: Array); 
+	OPERATOR ^ "-"-(l, r: Array): Array; 
+	PROCEDURE ^ Mul*(l, r, res: Array); 
+	PROCEDURE ^ Div*(l, r, res: Array); 
+	PROCEDURE ^ AddAV*(l: Array; r: Value; res: Array); 
+	OPERATOR ^ "+"(l: Array; r: Value): Array; 
+	OPERATOR ^ "+"(l: Value; r: Array): Array; 
+	PROCEDURE ^ MulAV*(l: Array; r: Value; res: Array); 
+	OPERATOR ^ "*"(l: Array; r: Value): Array; 
+	OPERATOR ^ "*"(l: Value; r: Array): Array; 
+	PROCEDURE ^ DivAV*(l: Array; r: Value; res: Array); 
+	PROCEDURE ^ DivVA*(l: Value; r: Array; res: Array); 
+	PROCEDURE ^ SubAV*(l: Array; r: Value; res: Array); 
+	PROCEDURE ^ SubVA*(l: Value; r: Array; res: Array); 
+	OPERATOR ^ "-"-(l: Value; r: Array): Array; 
+	OPERATOR ^ "-"-(l: IntValue; r: Array): Array; 
+	PROCEDURE ^ LoadArray(R: DataIO.Reader; VAR obj: OBJECT); 
+	PROCEDURE ^ StoreArray(W: DataIO.Writer; obj: OBJECT); 
+	PROCEDURE ^ Register; 
+	PROCEDURE ^ Load*(R: DataIO.Reader; VAR obj: Array); 
+	PROCEDURE ^ Store*(W: DataIO.Writer; obj: Array); 
+BEGIN
+END ArrayXdRe.

lin32/bin/Attributes.SymU

@@ -0,0 +1,35 @@
+MODULE Attributes;
+CONST 
+	Invalid =  -1; 
+	InitialAttributeArraySize = 16; 
+TYPE 
+	Attribute* = RECORD 
+		object: ANY; 
+		flags-: SET; 
+		data-: ANY; 
+	END; 
+
+	AttributeArray = POINTER TO ARRAY OF Attribute; 
+
+	Attributes* = OBJECT 
+	VAR 
+		attributes: AttributeArray; 
+		nofAttributes: LONGINT; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ ResizeArrayIfNecessary; 
+		PROCEDURE ^ AddObject(object: ANY; flags: SET; data: ANY); 
+		PROCEDURE ^ RemoveObject(object: ANY; hint: LONGINT); 
+		PROCEDURE ^ GetIndexOf(object: ANY): LONGINT; 
+		PROCEDURE ^ Get*(object: ANY): Attribute; 
+		PROCEDURE ^ Set*(object: ANY; flags: SET; data: ANY); 
+		PROCEDURE ^ GetFlags*(object: ANY): SET; 
+		PROCEDURE ^ SetFlags*(object: ANY; flags: SET); 
+		PROCEDURE ^ Include*(object: ANY; flag: LONGINT); 
+		PROCEDURE ^ Exclude*(object: ANY; flag: LONGINT); 
+		PROCEDURE ^ GetData*(object: ANY): ANY; 
+		PROCEDURE ^ SetData*(object, data: ANY); 
+		PROCEDURE ^ Clear*; 
+	END Attributes; 
+BEGIN
+END Attributes.

lin32/bin/Autostart.SymU

@@ -0,0 +1,8 @@
+MODULE Autostart;
+	IMPORT XML, XMLObjects, Commands, Configuration, KernelLog;
+CONST 
+	Trace = TRUE; 
+
+	PROCEDURE ^ Run*; 
+BEGIN
+END Autostart.

lin32/bin/BIT.SymU

@@ -0,0 +1,55 @@
+MODULE BIT;
+	IMPORT S := SYSTEM;
+CONST 
+	rbo = FALSE; 
+	risc = FALSE; 
+TYPE 
+	SHORTCARD* = SHORTINT; 
+
+	CARDINAL* = INTEGER; 
+
+	LONGCARD* = LONGINT; 
+
+	PROCEDURE ^ CXOR*(x, y: CHAR): CHAR; 
+	PROCEDURE ^ SXOR*(x, y: SHORTINT): SHORTINT; 
+	PROCEDURE ^ IXOR*(x, y: INTEGER): INTEGER; 
+	PROCEDURE ^ LXOR*(x, y: LONGINT): LONGINT; 
+	PROCEDURE ^ COR*(x, y: CHAR): CHAR; 
+	PROCEDURE ^ SOR*(x, y: SHORTINT): SHORTINT; 
+	PROCEDURE ^ IOR*(x, y: INTEGER): INTEGER; 
+	PROCEDURE ^ LOR*(x, y: LONGINT): LONGINT; 
+	PROCEDURE ^ CAND*(x, y: CHAR): CHAR; 
+	PROCEDURE ^ SAND*(x, y: SHORTINT): SHORTINT; 
+	PROCEDURE ^ IAND*(x, y: INTEGER): INTEGER; 
+	PROCEDURE ^ LAND*(x, y: LONGINT): LONGINT; 
+	PROCEDURE ^ CLSH*(x: CHAR; n: SHORTINT): CHAR; 
+	PROCEDURE ^ SLSH*(x: SHORTINT; n: SHORTINT): SHORTINT; 
+	PROCEDURE ^ ILSH*(x: INTEGER; n: SHORTINT): INTEGER; 
+	PROCEDURE ^ LLSH*(x: LONGINT; n: SHORTINT): LONGINT; 
+	PROCEDURE ^ CROT*(x: CHAR; n: SHORTINT): CHAR; 
+	PROCEDURE ^ SROT*(x: SHORTINT; n: SHORTINT): SHORTINT; 
+	PROCEDURE ^ IROT*(x: INTEGER; n: SHORTINT): INTEGER; 
+	PROCEDURE ^ LROT*(x: LONGINT; n: SHORTINT): LONGINT; 
+	PROCEDURE ^ ISWAP*(x: INTEGER): INTEGER; 
+	PROCEDURE ^ LSWAP*(x: LONGINT): LONGINT; 
+	PROCEDURE ^ CBIT*(x: CHAR; n: SHORTINT): BOOLEAN; 
+	PROCEDURE ^ BIT*(x: LONGINT; n: SHORTINT): BOOLEAN; 
+	PROCEDURE ^ CSETBIT*(VAR x: CHAR; n: SHORTINT); 
+	PROCEDURE ^ SSETBIT*(VAR x: SHORTINT; n: SHORTINT); 
+	PROCEDURE ^ ISETBIT*(VAR x: INTEGER; n: SHORTINT); 
+	PROCEDURE ^ LSETBIT*(VAR x: LONGINT; n: SHORTINT); 
+	PROCEDURE ^ CCLRBIT*(VAR x: CHAR; n: SHORTINT); 
+	PROCEDURE ^ SCLRBIT*(VAR x: SHORTINT; n: SHORTINT); 
+	PROCEDURE ^ ICLRBIT*(VAR x: INTEGER; n: SHORTINT); 
+	PROCEDURE ^ LCLRBIT*(VAR x: LONGINT; n: SHORTINT); 
+	PROCEDURE ^ SLESS*(x, y: SHORTCARD): BOOLEAN; 
+	PROCEDURE ^ ILESS*(x, y: CARDINAL): BOOLEAN; 
+	PROCEDURE ^ LLESS*(x, y: LONGCARD): BOOLEAN; 
+	PROCEDURE ^ SLESSEQ*(x, y: SHORTCARD): BOOLEAN; 
+	PROCEDURE ^ ILESSEQ*(x, y: CARDINAL): BOOLEAN; 
+	PROCEDURE ^ LLESSEQ*(x, y: LONGCARD): BOOLEAN; 
+	PROCEDURE ^ SDIV*(x, y: SHORTCARD): SHORTCARD; 
+	PROCEDURE ^ IDIV*(x, y: CARDINAL): CARDINAL; 
+	PROCEDURE ^ LDIV*(x, y: LONGCARD): LONGCARD; 
+BEGIN
+END BIT.

lin32/bin/BMPCodec.SymU

@@ -0,0 +1,54 @@
+MODULE BMPCodec;
+	IMPORT Codecs, KernelLog, Streams, WMGraphics, Raster, Strings;
+CONST 
+	FileHeaderSize = 14; 
+	RGB = 0; 
+	RLE8 = 1; 
+	RLE4 = 2; 
+	BITFIELDS = 3; 
+TYPE 
+	BMPDecoder = OBJECT (Codecs.ImageDecoder)
+	VAR 
+		errors: BOOLEAN; 
+		in: Streams.Reader; 
+		size, reserved, offset, width, height, compression, colors, importantColors, col, redMask, greenMask, blueMask: LONGINT; 
+		planes, bpp: INTEGER; 
+		pal: Raster.Palette; 
+		img: Raster.Image; 
+		decoded: BOOLEAN; 
+
+		PROCEDURE ^ Error(x: ARRAY OF CHAR); 
+		PROCEDURE ^ Log(x: ARRAY OF CHAR); 
+		PROCEDURE ^ Open*(in: Streams.Reader; VAR res: LONGINT); 
+		PROCEDURE ^ GetImageInfo*(VAR width, height, format, maxProgressionLevel: LONGINT); 
+		PROCEDURE ^ SetProgressionLevel*(progressionLevel: LONGINT); 
+		PROCEDURE ^ GetNativeImage*(VAR img: Raster.Image); 
+		PROCEDURE ^ Render*(img: Raster.Image); 
+	END BMPDecoder; 
+
+	BMPEncoder* = OBJECT (Codecs.ImageEncoder)
+	VAR 
+		out: Streams.Writer; 
+
+		PROCEDURE ^ Open*(out: Streams.Writer); 
+		PROCEDURE ^ SetQuality*(quality: LONGINT); 
+		PROCEDURE ^ WriteImage*(img: Raster.Image; VAR res: LONGINT); 
+	END BMPEncoder; 
+
+	PROCEDURE ^ Unmask(val, mask, nbits: LONGINT): LONGINT; 
+	PROCEDURE ^ Load1(img: Raster.Image; w, h: LONGINT; VAR pal: Raster.Palette; r: Streams.Reader); 
+	PROCEDURE ^ Load4(img: Raster.Image; w, h, compression: LONGINT; pal: Raster.Palette; r: Streams.Reader); 
+	PROCEDURE ^ Load8(img: Raster.Image; w, h, compression: LONGINT; pal: Raster.Palette; r: Streams.Reader); 
+	PROCEDURE ^ Load16(img: Raster.Image; w, h, compression, rMask, gMask, bMask: LONGINT; r: Streams.Reader); 
+	PROCEDURE ^ Load24(img: Raster.Image; w, h: LONGINT; r: Streams.Reader); 
+	PROCEDURE ^ Load32(img: Raster.Image; w, h, compression, rMask, gMask, bMask: LONGINT; r: Streams.Reader); 
+	PROCEDURE ^ Store1(img: Raster.Image; w, h: LONGINT; out: Streams.Writer); 
+	PROCEDURE ^ Store4(img: Raster.Image; w, h: LONGINT; out: Streams.Writer); 
+	PROCEDURE ^ Store8(img: Raster.Image; w, h: LONGINT; out: Streams.Writer); 
+	PROCEDURE ^ Store16(img: Raster.Image; w, h, rMask, gMask, bMask: LONGINT; out: Streams.Writer); 
+	PROCEDURE ^ Store24(img: Raster.Image; w, h: LONGINT; out: Streams.Writer); 
+	PROCEDURE ^ Store32(img: Raster.Image; w, h, rMask, gMask, bMask: LONGINT; out: Streams.Writer); 
+	PROCEDURE ^ DecoderFactory*(): Codecs.ImageDecoder; 
+	PROCEDURE ^ EncoderFactory*(): Codecs.ImageEncoder; 
+BEGIN
+END BMPCodec.

lin32/bin/Base64.SymU

@@ -0,0 +1,11 @@
+MODULE Base64;
+	IMPORT Streams, KernelLog;
+VAR 
+	encTable: ARRAY 64 OF CHAR; 
+	decTable: ARRAY 128 OF INTEGER; 
+
+	PROCEDURE ^ Decode*(R: Streams.Reader; W: Streams.Writer); 
+	PROCEDURE ^ Encode*(R: Streams.Reader; W: Streams.Writer); 
+	PROCEDURE ^ InitTables; 
+BEGIN
+END Base64.

lin32/bin/Beep.SymU

@@ -0,0 +1,10 @@
+MODULE Beep;
+	IMPORT X11, Displays, XDisplay, Plugins;
+CONST 
+VAR 
+	disp: XDisplay.Display; 
+
+	PROCEDURE ^ Beep*(hz: LONGINT); 
+	PROCEDURE ^ GetDisplay; 
+BEGIN
+END Beep.

lin32/bin/BeepTest.SymU

@@ -0,0 +1,10 @@
+MODULE BeepTest;
+	IMPORT Beep, Kernel, KernelLog;
+CONST 
+VAR 
+	busy: BOOLEAN; 
+	timer: Kernel.Timer; 
+
+	PROCEDURE ^ Go*; 
+BEGIN
+END BeepTest.

lin32/bin/BenchSyntaxHighlighter.SymU

@@ -0,0 +1,16 @@
+MODULE BenchSyntaxHighlighter;
+	IMPORT Streams, Commands, Options, Dates, Strings, Files, Random, Texts, TextUtilities, SyntaxHighlighter;
+CONST 
+	DefaultHighlighterName = \"Oberon"\; 
+	DefaultNofIterations = 1000; 
+
+	PROCEDURE ^ Reader(reader: Texts.TextReader; nofIterations: LONGINT; out: Streams.Writer); 
+	PROCEDURE ^ Words(reader: Texts.TextReader; highlighter: SyntaxHighlighter.Highlighter; nofIterations: LONGINT; out: Streams.Writer); 
+	PROCEDURE ^ RebuildRegions(reader: Texts.TextReader; highlighter: SyntaxHighlighter.Highlighter; nofIterations: LONGINT; out: Streams.Writer); 
+	PROCEDURE ^ RegionLookup(reader: Texts.TextReader; highlighter: SyntaxHighlighter.Highlighter; nofIterations: LONGINT; out: Streams.Writer); 
+	PROCEDURE ^ Full(reader: Texts.TextReader; highlighter: SyntaxHighlighter.Highlighter; nofIterations: LONGINT; out: Streams.Writer); 
+	PROCEDURE ^ Indent(writer: Streams.Writer; width: LONGINT); 
+	PROCEDURE ^ Bench*(context: Commands.Context); 
+	PROCEDURE ^ TestScanner*(context: Commands.Context); 
+BEGIN
+END BenchSyntaxHighlighter.

lin32/bin/BenchTCP.SymU

@@ -0,0 +1,47 @@
+MODULE BenchTCP;
+	IMPORT Kernel, IP, KernelLog, TCP, DNS, Strings, Commands;
+CONST 
+	BufSize = 32768; 
+	CloseTimeout = 10000; 
+	EchoPort = 7; 
+	DiscardPort = 9; 
+	TimePort = 37; 
+	Header = \"BenchTCP: "\; 
+TYPE 
+	Bytes = POINTER TO ARRAY OF CHAR; 
+
+	Sender = OBJECT {EXCLUSIVE} 
+	VAR 
+		c: TCP.Connection; 
+		num, num0, res: LONGINT; 
+		buf: Bytes; 
+		done: BOOLEAN; 
+
+		PROCEDURE ^  & Init*(c: TCP.Connection; buf: Bytes; num: LONGINT); 
+		PROCEDURE ^ Join(): LONGINT; 
+	BEGIN{ACTIVE} 
+	END Sender; 
+
+	Tester = OBJECT {EXCLUSIVE} 
+	VAR 
+		c: TCP.Connection; 
+		num, num0, res, port, total, len: LONGINT; 
+		fip: IP.Adr; 
+		timer: Kernel.MilliTimer; 
+		sender: Sender; 
+		server: ARRAY 64 OF CHAR; 
+		time: HUGEINT; 
+
+		PROCEDURE ^  & Init*(CONST server: ARRAY OF CHAR; num, port: LONGINT); 
+	BEGIN{ACTIVE} 
+	END Tester; 
+VAR 
+	buf: Bytes; 
+
+	PROCEDURE ^ Message(CONST msg1, msg2: ARRAY OF CHAR; res: LONGINT); 
+	PROCEDURE ^ Report(ms, port, total: LONGINT; CONST msg: ARRAY OF CHAR); 
+	PROCEDURE ^ Discard*(context: Commands.Context); 
+	PROCEDURE ^ Echo*(context: Commands.Context); 
+	PROCEDURE ^ Time*(context: Commands.Context); 
+BEGIN
+END BenchTCP.

lin32/bin/BenchXML.SymU

@@ -0,0 +1,37 @@
+MODULE BenchXML;
+	IMPORT KernelLog, Streams, Modules, Commands, Options, Dates, Strings, Files, XML, XMLScanner, XMLParser;
+CONST 
+	DefaultNofTimes = 1000; 
+	DefaultNofWorkers = 1; 
+	Waiting = 0; 
+	Working = 1; 
+	Terminating = 2; 
+	Terminated = 3; 
+TYPE 
+	Worker = OBJECT {EXCLUSIVE} 
+	VAR 
+		file: Files.File; 
+		pooling: SET; 
+		nofTimes: LONGINT; 
+		state: LONGINT; 
+
+		PROCEDURE ^  & Init*(file: Files.File; nofTimes: LONGINT; pooling: SET); 
+		PROCEDURE ^ Start; 
+		PROCEDURE ^ Terminate; 
+		PROCEDURE ^ Parse; 
+	BEGIN{ACTIVE} 
+	END Worker; 
+VAR 
+	error: BOOLEAN; 
+	workers: POINTER TO ARRAY OF Worker; 
+	nofActiveWorkers: LONGINT; 
+
+	PROCEDURE ^ DecrementNofActiveWorkers; 
+	PROCEDURE ^ ParseFile(file: Files.File; pooling: SET): XML.Document; 
+	PROCEDURE ^ BenchParser*(context: Commands.Context); 
+	PROCEDURE ^ ToSeconds(nofDays, nofHours, nofMinutes, nofSeconds: LONGINT): LONGINT; 
+	PROCEDURE ^ DefaultReportError(pos, line, col: LONGINT; CONST msg: ARRAY OF CHAR); 
+	PROCEDURE ^ ShowUsage(out: Streams.Writer); 
+	PROCEDURE ^ Cleanup; 
+BEGIN
+END BenchXML.

lin32/bin/BimboMail.SymU

@@ -0,0 +1,31 @@
+MODULE BimboMail;
+	IMPORT Modules, WMGrids, WMStringGrids, MailStorage, WMGraphics, WMMessages, WMStandardComponents, WMComponents, WMEditors, Strings, TextUtilities, Texts, WM := WMWindowManager;
+CONST 
+	TempFilename = \"BimboMail.Temp"\; 
+TYPE 
+	KillerMsg = OBJECT 
+	END KillerMsg; 
+
+	Window* = OBJECT {EXCLUSIVE} (WMComponents.FormWindow)
+	VAR 
+		currentMailbox: MailStorage.Storage; 
+		messageList: WMStringGrids.StringGrid; 
+		messageText: WMEditors.Editor; 
+
+		PROCEDURE ^ CreateForm(): WMComponents.VisualComponent; 
+		PROCEDURE ^ SetMailbox(mb: MailStorage.Storage); 
+		PROCEDURE ^  & New*; 
+		PROCEDURE ^ GetTitleStr(col: LONGINT; VAR x: ARRAY OF CHAR); 
+		PROCEDURE ^ Close*; 
+		PROCEDURE ^ Handle*(VAR x: WMMessages.Message); 
+		PROCEDURE ^ MessageClick(sender, data: ANY); 
+	END Window; 
+VAR 
+	nofWindows: LONGINT; 
+
+	PROCEDURE ^ Open*; 
+	PROCEDURE ^ IncCount; 
+	PROCEDURE ^ DecCount; 
+	PROCEDURE ^ Cleanup; 
+BEGIN
+END BimboMail.

lin32/bin/BimboScanner.SymU

@@ -0,0 +1,145 @@
+MODULE BimboScanner;
+	IMPORT Trace, Texts, Streams, UTF8Strings, Strings;
+CONST 
+	Eot* = 0X; 
+	ObjectMarker = 20X; 
+	LF = 0AX; 
+	char* = 1; 
+	integer* = 2; 
+	longinteger* = 3; 
+	real* = 4; 
+	longreal* = 5; 
+	MaxHDig* = 8; 
+	MaxHHDig* = 16; 
+	MaxRExp* = 38; 
+	MaxLExp* = 308; 
+	null* = 0; 
+	times* = 1; 
+	slash* = 2; 
+	div* = 3; 
+	mod* = 4; 
+	and* = 5; 
+	plus* = 6; 
+	minus* = 7; 
+	or* = 8; 
+	eql* = 9; 
+	neq* = 10; 
+	lss* = 11; 
+	leq* = 12; 
+	gtr* = 13; 
+	geq* = 14; 
+	in* = 15; 
+	is* = 16; 
+	arrow* = 17; 
+	period* = 18; 
+	comma* = 19; 
+	colon* = 20; 
+	upto* = 21; 
+	rparen* = 22; 
+	rbrak* = 23; 
+	rbrace* = 24; 
+	of* = 25; 
+	then* = 26; 
+	do* = 27; 
+	to* = 28; 
+	by* = 29; 
+	lparen* = 30; 
+	lbrak* = 31; 
+	lbrace* = 32; 
+	not* = 33; 
+	becomes* = 34; 
+	number* = 35; 
+	nil* = 36; 
+	true* = 37; 
+	false* = 38; 
+	string* = 39; 
+	ident* = 40; 
+	semicolon* = 41; 
+	bar* = 42; 
+	end* = 43; 
+	else* = 44; 
+	elsif* = 45; 
+	until* = 46; 
+	if* = 47; 
+	case* = 48; 
+	while* = 49; 
+	repeat* = 50; 
+	for* = 51; 
+	loop* = 52; 
+	with* = 53; 
+	exit* = 54; 
+	passivate* = 55; 
+	return* = 56; 
+	refines* = 57; 
+	implements* = 58; 
+	array* = 59; 
+	definition* = 60; 
+	object* = 61; 
+	record* = 62; 
+	pointer* = 63; 
+	begin* = 64; 
+	code* = 65; 
+	const* = 66; 
+	type* = 67; 
+	var* = 68; 
+	procedure* = 69; 
+	import* = 70; 
+	module* = 71; 
+	eof* = 72; 
+	comment* = 73; 
+	newLine* = 74; 
+	question* = 75; 
+	finally* = 76; 
+TYPE 
+	StringMaker = OBJECT 
+	VAR 
+		length: LONGINT; 
+		data: Strings.String; 
+
+		PROCEDURE ^  & Init(initialSize: LONGINT); 
+		PROCEDURE ^ Add*(CONST buf: ARRAY OF CHAR; ofs, len: LONGINT; propagate: BOOLEAN; VAR res: LONGINT); 
+		PROCEDURE ^ Shorten(n: LONGINT); 
+		PROCEDURE ^ Clear*; 
+		PROCEDURE ^ GetWriter*(): Streams.Writer; 
+		PROCEDURE ^ GetLength*(): LONGINT; 
+		PROCEDURE ^ GetString*(): Strings.String; 
+	END StringMaker; 
+
+	Scanner* = OBJECT 
+	VAR 
+		buffer: Strings.String; 
+		pos-: LONGINT; 
+		ch-: CHAR; 
+		str-: ARRAY 1024 OF CHAR; 
+		sym-: LONGINT; 
+		numtyp-: INTEGER; 
+		intval-: LONGINT; 
+		longintval-: HUGEINT; 
+		realval-: REAL; 
+		lrlval-: LONGREAL; 
+		numStartPos, numEndPos: LONGINT; 
+		lastpos-, curpos-, errpos-: LONGINT; 
+		isNummer: BOOLEAN; 
+		commentStr-: StringMaker; 
+		cw: Streams.Writer; 
+
+		PROCEDURE ^  & Init; 
+		PROCEDURE ^ err(n: INTEGER); 
+		PROCEDURE ^ NextChar*; 
+		PROCEDURE ^ Str(VAR sym: LONGINT); 
+		PROCEDURE ^ Identifier(VAR sym: LONGINT); 
+		PROCEDURE ^ Number; 
+		PROCEDURE ^ GetNumAsString*(VAR val: ARRAY OF CHAR); 
+		PROCEDURE ^ Get(VAR s: LONGINT); 
+		PROCEDURE ^ Next*; 
+	END Scanner; 
+VAR 
+	reservedChar-, ignoredChar, newChar-: ARRAY 256 OF BOOLEAN; 
+
+	PROCEDURE ^ InitWithText*(t: Texts.Text; pos: LONGINT): Scanner; 
+	PROCEDURE ^ ExpandBuf(VAR oldBuf: Strings.String; newSize: LONGINT); 
+	PROCEDURE ^ InitReservedChars; 
+	PROCEDURE ^ InitNewChar; 
+	PROCEDURE ^ InitIgnoredChar; 
+BEGIN
+END BimboScanner.

lin32/bin/Bimso.SymU

@@ -0,0 +1,45 @@
+MODULE Bimso;
+	IMPORT Strings, WMGraphics, WMMessages, WMComponents, WMStandardComponents, Modules, KernelLog, WMRectangles, WMGraphicUtilities, Random, Kernel, WMDialogs, WM := WMWindowManager;
+CONST 
+	MaxLevel = 1000; 
+TYPE 
+	KillerMsg = OBJECT 
+	END KillerMsg; 
+
+	Window* = OBJECT {EXCLUSIVE} (WMComponents.FormWindow)
+	VAR 
+		b: ARRAY 4 OF WMStandardComponents.Button; 
+		startButton: WMStandardComponents.Button; 
+		start, alive: BOOLEAN; 
+		c, cflash: ARRAY 4 OF WMGraphics.Color; 
+		random: Random.Generator; 
+		game: ARRAY MaxLevel OF SHORTINT; 
+		level: LONGINT; 
+		step: LONGINT; 
+		error: BOOLEAN; 
+		timer: Kernel.Timer; 
+		s, levelStr: ARRAY 32 OF CHAR; 
+
+		PROCEDURE ^ CreateForm(): WMComponents.VisualComponent; 
+		PROCEDURE ^  & New*; 
+		PROCEDURE ^ Close*; 
+		PROCEDURE ^ Handle*(VAR x: WMMessages.Message); 
+		PROCEDURE ^ CreateLevel; 
+		PROCEDURE ^ ShowLevel; 
+		PROCEDURE ^ EnableInput; 
+		PROCEDURE ^ DisableInput; 
+		PROCEDURE ^ Evaluate(sender, data: ANY); 
+		PROCEDURE ^ Start(sender, data: ANY); 
+		PROCEDURE ^ Started; 
+		PROCEDURE ^ Play; 
+	BEGIN{ACTIVE} 
+	END Window; 
+VAR 
+	nofWindows: LONGINT; 
+
+	PROCEDURE ^ Open*; 
+	PROCEDURE ^ IncCount; 
+	PROCEDURE ^ DecCount; 
+	PROCEDURE ^ Cleanup; 
+BEGIN
+END Bimso.

lin32/bin/Bin2Hex.SymU

@@ -0,0 +1,12 @@
+MODULE Bin2Hex;
+	IMPORT Streams, Files, Commands;
+CONST 
+
+	PROCEDURE ^ Byte(VAR w: Streams.Writer; val: LONGINT); 
+	PROCEDURE ^ ExtendedAddressRecord*(VAR w: Streams.Writer; extadr: LONGINT); 
+	PROCEDURE ^ DataRecord*(VAR w: Streams.Writer; CONST data: ARRAY OF CHAR; len, offset: LONGINT); 
+	PROCEDURE ^ EndOfFileRecord*(VAR w: Streams.Writer); 
+	PROCEDURE ^ ConvertFile*(r: Streams.Reader; w: Streams.Writer; offset, maxlen: LONGINT); 
+	PROCEDURE ^ Convert*(context: Commands.Context); 
+BEGIN
+END Bin2Hex.

lin32/bin/BinToCode.SymU

@@ -0,0 +1,14 @@
+MODULE BinToCode;
+	IMPORT Files, Commands, Streams;
+CONST 
+	BufferAddressName = \"a"\; 
+	MaxBufferSize = 4; 
+TYPE 
+	Buffer = ARRAY MaxBufferSize OF CHAR; 
+VAR 
+	hexdigit: ARRAY 17 OF CHAR; 
+
+	PROCEDURE ^ WriteBuffer(w: Streams.Writer; CONST buffer: Buffer; offset, size: LONGINT); 
+	PROCEDURE ^ Convert*(context: Commands.Context); 
+BEGIN
+END BinToCode.

lin32/bin/BitSets.SymU

@@ -0,0 +1,27 @@
+MODULE BitSets;
+	IMPORT SYSTEM;
+CONST 
+	Elements = ((MAX(SET) - MIN(SET)) + 1); 
+TYPE 
+	Data = POINTER TO ARRAY OF SET; 
+
+	BitSet* = OBJECT 
+	VAR 
+		size: LONGINT; 
+		data: Data; 
+
+		PROCEDURE ^  & InitBitSet*(size: LONGINT); 
+		PROCEDURE ^ Zero*; 
+		PROCEDURE ^ Resize*(size: LONGINT); 
+		PROCEDURE ^ GetSize*(): LONGINT; 
+		PROCEDURE ^ SetBit*(pos: SIZE; value: BOOLEAN); 
+		PROCEDURE ^ GetBit*(pos: SIZE): BOOLEAN; 
+		PROCEDURE ^ SetBits*(startPos: SIZE; bits: LONGINT; value: HUGEINT); 
+		PROCEDURE ^ SetBytes*(startPos: SIZE; bytes: LONGINT; CONST values: ARRAY OF CHAR); 
+		PROCEDURE ^ GetBits*(startPos: SIZE; bits: LONGINT): LONGINT; 
+		PROCEDURE ^ CopyTo*(address: ADDRESS; bits: SIZE); 
+	END BitSet; 
+
+	PROCEDURE ^ CopyBits*(source: BitSet; sourcePos: SIZE; dest: BitSet; destPos, count: SIZE); 
+BEGIN
+END BitSets.

lin32/bin/BootConsole.SymU

@@ -0,0 +1,29 @@
+MODULE BootConsole;
+	IMPORT S := SYSTEM, Trace, Glue, Unix, Modules, Objects, Commands;
+CONST 
+TYPE 
+	Module = Modules.Module; 
+
+	CommandProc = PROCEDURE ; 
+
+	CommandThread = OBJECT {EXCLUSIVE} 
+	VAR 
+		mod, cmd: Modules.Name; 
+
+		PROCEDURE ^  & Init(CONST modName, cmdName: Modules.Name); 
+	BEGIN{ACTIVE} 
+	END CommandThread; 
+VAR 
+	appl: CommandThread; 
+
+	PROCEDURE ^ LoadModule(CONST name: Modules.Name); 
+	PROCEDURE ^ Command(CONST cmd: Modules.Name); 
+	PROCEDURE ^ ThisCommand(m: Module; CONST name: Modules.Name): CommandProc; 
+	PROCEDURE ^ Execute(CONST modName, procName: Modules.Name); 
+	PROCEDURE ^ CommandError(CONST cmd, msg: ARRAY OF CHAR); 
+	PROCEDURE ^ TryCommand(): BOOLEAN; 
+	PROCEDURE ^ InitializeCoreModules; 
+	PROCEDURE ^ StartSystem; 
+	PROCEDURE ^ InitSignalHandling; 
+BEGIN
+END BootConsole.

lin32/bin/BootManager.SymU

@@ -0,0 +1,7 @@
+MODULE BootManager;
+	IMPORT Commands, Files;
+CONST 
+
+	PROCEDURE ^ Split*(context: Commands.Context); 
+BEGIN
+END BootManager.

lin32/bin/BootShell.SymU

@@ -0,0 +1,121 @@
+MODULE BootShell;
+	IMPORT SYSTEM, KernelLog, Machine, Modules, Streams, Commands, Inputs, Strings, Locks;
+CONST 
+	Version = \"A2 Bootshell v1.0"\; 
+	LineWidth = 80; 
+	TraceHeight = 25; 
+	TraceBase = 753664; 
+	BufferHeight = 2048; 
+	BufferSize = (BufferHeight * LineWidth); 
+	TAB = 9X; 
+	CR = 0DX; 
+	LF = 0AX; 
+	SPACE = \" "\; 
+	Mode_Insert = 0; 
+	Mode_Overwrite = 1; 
+	Black = 0; 
+	Blue = 1; 
+	Green = 2; 
+	Cyan = 3; 
+	Red = 4; 
+	Magenta = 5; 
+	Brown = 6; 
+	White = 7; 
+	Gray = 8; 
+	LightBlue = 9; 
+	LightGreen = 10; 
+	LightCyan = 11; 
+	LightRed = 12; 
+	LightMagenta = 13; 
+	Yellow = 14; 
+	BrightWhite = 15; 
+TYPE 
+	CommandsString = POINTER TO RECORD 
+		prev, next: CommandsString; 
+		string: Strings.String; 
+	END; 
+
+	CommandHistoryObject = OBJECT 
+	VAR 
+		first, current: CommandsString; 
+
+		PROCEDURE ^ GetNextCommand(): Strings.String; 
+		PROCEDURE ^ GetPreviousCommand(): Strings.String; 
+		PROCEDURE ^ AddCommand(string: Strings.String); 
+		PROCEDURE ^  & Init*; 
+	END CommandHistoryObject; 
+
+	Character = RECORD 
+		ch: CHAR; 
+		color: SHORTINT; 
+	END; 
+
+	Line = ARRAY LineWidth OF Character; 
+
+	TextBuffer = OBJECT 
+	VAR 
+		defaultColor: SHORTINT; 
+		currentColor: SHORTINT; 
+		lines: ARRAY BufferHeight OF Line; 
+		firstLine, lastLine: LONGINT; 
+		firstLineShown: LONGINT; 
+		editStartPosition, editEndPosition: LONGINT; 
+		cursorPosition: LONGINT; 
+		mode: LONGINT; 
+		lock: Locks.RecursiveLock; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ Clear; 
+		PROCEDURE ^ SetColor(foreground, background: SHORTINT); 
+		PROCEDURE ^ SetEditStart; 
+		PROCEDURE ^ Send(CONST data: ARRAY OF CHAR; ofs, len: LONGINT; propagate: BOOLEAN; VAR res: LONGINT); 
+		PROCEDURE ^ String(CONST string: ARRAY OF CHAR); 
+		PROCEDURE ^ Char(ch: CHAR); 
+		PROCEDURE ^ CheckVisibility; 
+		PROCEDURE ^ NextLine; 
+		PROCEDURE ^ MoveCharactersToRight; 
+		PROCEDURE ^ MoveCharactersToLeft; 
+		PROCEDURE ^ CharInternal(ch: CHAR); 
+		PROCEDURE ^ DeleteCurrentLine; 
+		PROCEDURE ^ GetCurrentLine(): Strings.String; 
+		PROCEDURE ^ Home; 
+		PROCEDURE ^ End; 
+		PROCEDURE ^ Backspace; 
+		PROCEDURE ^ Delete; 
+		PROCEDURE ^ ScrollUp(nofLines: LONGINT); 
+		PROCEDURE ^ ScrollDown(nofLines: LONGINT); 
+		PROCEDURE ^ CursorLeft; 
+		PROCEDURE ^ CursorRight; 
+		PROCEDURE ^ Dump(out: Streams.Writer); 
+	END TextBuffer; 
+
+	Shell = OBJECT (Inputs.Sink)
+	VAR 
+		textBuffer: TextBuffer; 
+		history: CommandHistoryObject; 
+
+		PROCEDURE ^  & Init; 
+		PROCEDURE ^ Handle*(VAR msg: Inputs.Message); 
+		PROCEDURE ^ CommandHistory(next: BOOLEAN); 
+		PROCEDURE ^ Prompt; 
+		PROCEDURE ^ Execute; 
+		PROCEDURE ^ Quit; 
+	END Shell; 
+VAR 
+	shell: Shell; 
+
+	PROCEDURE ^ Subtract(position, value, bufferSize: LONGINT): LONGINT; 
+	PROCEDURE ^ Add(position, value, bufferSize: LONGINT): LONGINT; 
+	PROCEDURE ^ Difference(end, start, bufferSize: LONGINT): LONGINT; 
+	PROCEDURE ^ ClearLine(VAR line: Line; from, to: LONGINT; color: SHORTINT); 
+	PROCEDURE ^ IsWhitespace(ch: CHAR): BOOLEAN; 
+	PROCEDURE ^ Min(a, b: LONGINT): LONGINT; 
+	PROCEDURE ^ Invalidate(textBuffer: TextBuffer); 
+	PROCEDURE ^ Open*; 
+	PROCEDURE ^ Close*; 
+	PROCEDURE ^ Dump*(context: Commands.Context); 
+	PROCEDURE ^ UpdateCursor(textBuffer: TextBuffer); 
+	PROCEDURE ^ Cleanup; 
+	PROCEDURE ^ Init; 
+BEGIN
+END BootShell.

lin32/bin/CATServer.SymU

@@ -0,0 +1,24 @@
+MODULE CATServer;
+	IMPORT Modules, Streams, TCP, TCPServices, AosLog := TFLog, Performance;
+CONST 
+	CATPort = 9999; 
+TYPE 
+	CATAgent = OBJECT {EXCLUSIVE} (TCPServices.Agent)
+	VAR 
+		in: Streams.Reader; 
+		out: Streams.Writer; 
+		token: ARRAY 16 OF CHAR; 
+		x: LONGINT; 
+
+	BEGIN{ACTIVE} 
+	END CATAgent; 
+VAR 
+	cat: TCPServices.Service; 
+	log: AosLog.Log; 
+
+	PROCEDURE ^ NewCATAgent(c: TCP.Connection; s: TCPServices.Service): TCPServices.Agent; 
+	PROCEDURE ^ Start*; 
+	PROCEDURE ^ Stop*; 
+	PROCEDURE ^ Cleanup; 
+BEGIN
+END CATServer.

lin32/bin/CLUTs.SymU

@@ -0,0 +1,21 @@
+MODULE CLUTs;
+	IMPORT Streams;
+CONST 
+	colors* = 256; 
+TYPE 
+	CLUT* = RECORD 
+		col*: ARRAY colors OF LONGINT; 
+		size*: INTEGER; 
+		bits: INTEGER; 
+		cube: POINTER TO ARRAY OF CHAR; 
+	END; 
+
+	PROCEDURE ^ Set*(VAR clut: CLUT; n, col: LONGINT); 
+	PROCEDURE ^ Get*(VAR clut: CLUT; n: LONGINT; VAR col: LONGINT); 
+	PROCEDURE ^ Init*(VAR clut: CLUT; size, bits: LONGINT); 
+	PROCEDURE ^ Match*(VAR clut: CLUT; col: LONGINT): LONGINT; 
+	PROCEDURE ^ Copy*(from, to: CLUT); 
+	PROCEDURE ^ Write*(VAR w: Streams.Writer; VAR clut: CLUT); 
+	PROCEDURE ^ Read*(r: Streams.Reader; VAR clut: CLUT; size: LONGINT); 
+BEGIN
+END CLUTs.

lin32/bin/CPUID.SymU

@@ -0,0 +1,162 @@
+MODULE CPUID;
+	IMPORT SYSTEM, Streams, Commands, Options;
+CONST 
+	Intel* = 0; 
+	Amd* = 1; 
+	Other* = 2; 
+	PBE* = 31; 
+	IA64* = 30; 
+	TM* = 29; 
+	HTT* = 28; 
+	SS* = 27; 
+	SSE2* = 26; 
+	SSE* = 25; 
+	FXSR* = 24; 
+	MMX* = 23; 
+	ACPI* = 22; 
+	DS* = 21; 
+	CLFLUSH* = 19; 
+	PSN* = 18; 
+	PSE36* = 17; 
+	PAT* = 16; 
+	CMOV* = 15; 
+	MCA* = 14; 
+	PGE* = 13; 
+	MTRR* = 12; 
+	SysEnterSysExit* = 11; 
+	APIC* = 9; 
+	CMPXCH8B* = 8; 
+	MCE* = 7; 
+	PAE* = 6; 
+	MSR* = 5; 
+	TSC* = 4; 
+	PSE* = 3; 
+	DE* = 2; 
+	VME* = 1; 
+	FPU* = 0; 
+	SSE4_2* = 20; 
+	SSE4_1* = 19; 
+	DCA* = 18; 
+	PDCM* = 15; 
+	XTPR* = 14; 
+	CMPXCHG16B* = 13; 
+	CID* = 10; 
+	SSSE3* = 9; 
+	TM2* = 8; 
+	EST* = 7; 
+	SMX* = 6; 
+	VMX* = 5; 
+	DS_CPL* = 4; 
+	MONITOR* = 3; 
+	DTES64* = 2; 
+	SSE3* = 0; 
+	Amd3DNow* = 31; 
+	Amd3DNowExt* = 32; 
+	LM* = 29; 
+	RDTSCP* = 27; 
+	FFXSR* = 25; 
+	MmxExt* = 22; 
+	NX* = 20; 
+	SysCallSysRet* = 11; 
+	AltMovCr8* = 4; 
+	SVM* = 2; 
+	CmpLegacy* = 1; 
+	LahfSahf* = 0; 
+	AMD7_TscInvariant* = 8; 
+	AMD7_STC* = 5; 
+	AMD7_TM* = 4; 
+	AMD7_TTP* = 3; 
+	AMD7_VID* = 2; 
+	AMD7_FID* = 1; 
+	AMD7_TS* = 0; 
+TYPE 
+	CpuInformation* = RECORD 
+		cputype-: LONGINT; 
+		largestStandardFunction-: LONGINT; 
+		vendor-: ARRAY 13 OF CHAR; 
+		family-, model-, stepping-: LONGINT; 
+		type-: LONGINT; 
+		features-, features2-: SET; 
+		localApicId-, logicalProcessorCount-: LONGINT; 
+		clflushSize-: LONGINT; 
+		brandId-: LONGINT; 
+		largestExtendedFunction-: LONGINT; 
+		extFeatures-, extFeatures2-: SET; 
+		processorName-: ARRAY 48 OF CHAR; 
+		l1DataTlbAssociativity2M4M-: LONGINT; 
+		l1DataTlbSize2M4M-: LONGINT; 
+		l1InstrTlbAssociativity2M4M-: LONGINT; 
+		l1InstrTlbSize2M4M-: LONGINT; 
+		l1DataTlbAssociativity4K-: LONGINT; 
+		l1DataTlbSize4K-: LONGINT; 
+		l1InstrTlbAssociativity4K-: LONGINT; 
+		l1InstrTlbSize4K-: LONGINT; 
+		l1DcSize-: LONGINT; 
+		l1DcAssociativity-: LONGINT; 
+		l1DcLinesPerTag-: LONGINT; 
+		l1DcLineSize-: LONGINT; 
+		l1IcSize-: LONGINT; 
+		l1IcAssociativity-: LONGINT; 
+		l1IcLinesPerTag-: LONGINT; 
+		l1IcLineSize-: LONGINT; 
+		unifiedTlb-: BOOLEAN; 
+		l2DataTlbAssociativity2M4M-: LONGINT; 
+		l2DataTlbSize2M4M-: LONGINT; 
+		l2InstrTlbAssociativity2M4M-: LONGINT; 
+		l2InstrTlbSize2M4M-: LONGINT; 
+		l2DataTlbAssociativity4K-: LONGINT; 
+		l2DataTlbSize4K-: LONGINT; 
+		l2InstrTlbAssociativity4K-: LONGINT; 
+		l2InstrTlbSize4K-: LONGINT; 
+		l2CacheSize-: LONGINT; 
+		l2Associativity-: LONGINT; 
+		l2LinesPerTag-: LONGINT; 
+		l2LineSize-: LONGINT; 
+		powerManagement-: SET; 
+		linAddrSize-: LONGINT; 
+		physAddrSize-: LONGINT; 
+		apicIdCoreIdSize-: LONGINT; 
+		numberOfCores-: LONGINT; 
+		svmRev-: LONGINT; 
+		nasid-: LONGINT; 
+	END; 
+
+	PROCEDURE ^ CPUID(function: LONGINT; VAR eax, ebx, ecx, edx: SET); 
+	PROCEDURE ^ CpuIdSupported(): BOOLEAN; 
+	PROCEDURE ^ StandardFunction0(VAR cpuInfo: CpuInformation); 
+	PROCEDURE ^ StandardFunction1(VAR cpuInfo: CpuInformation); 
+	PROCEDURE ^ IntelStandardFunction4(wr: Streams.Writer); 
+	PROCEDURE ^ IntelStandardFunction5(w: Streams.Writer); 
+	PROCEDURE ^ IntelStandardFunction6(w: Streams.Writer); 
+	PROCEDURE ^ IntelStandardFunction9(w: Streams.Writer); 
+	PROCEDURE ^ IntelStandardFunction0A(w: Streams.Writer); 
+	PROCEDURE ^ ExtendedFunction0(VAR cpuInfo: CpuInformation); 
+	PROCEDURE ^ ExtendedFunction1(VAR cpuInfo: CpuInformation); 
+	PROCEDURE ^ ExtendedFunction2to4(VAR cpuInfo: CpuInformation); 
+	PROCEDURE ^ AmdExtendedFunction5(VAR cpuInfo: CpuInformation); 
+	PROCEDURE ^ AmdExtendedFunction6(VAR cpuInfo: CpuInformation); 
+	PROCEDURE ^ IntelExtendedFunction6(VAR cpuInfo: CpuInformation); 
+	PROCEDURE ^ AmdExtendedFunction7(VAR cpuInfo: CpuInformation); 
+	PROCEDURE ^ ExtendedFunction8(VAR cpuInfo: CpuInformation); 
+	PROCEDURE ^ AmdExtendedFunctionA(VAR cpuInfo: CpuInformation); 
+	PROCEDURE ^ GetString(VAR string: ARRAY OF CHAR; offset: LONGINT; register: SET); 
+	PROCEDURE ^ GetCpuInformation(VAR cpuInfo: CpuInformation); 
+	PROCEDURE ^ ShowExtFeatures2Amd(w: Streams.Writer; register: SET); 
+	PROCEDURE ^ ShowExtFeaturesAmd(w: Streams.Writer; register: SET); 
+	PROCEDURE ^ ShowPowerManagementAmd(w: Streams.Writer; register: SET); 
+	PROCEDURE ^ ShowLongModeAS(w: Streams.Writer; cpuInfo: CpuInformation); 
+	PROCEDURE ^ ShowFeatures2(w: Streams.Writer; register: SET); 
+	PROCEDURE ^ ShowFeatures(w: Streams.Writer; register: SET); 
+	PROCEDURE ^ ShowL1Associativity(w: Streams.Writer; value: LONGINT); 
+	PROCEDURE ^ ShowL2Associativity(w: Streams.Writer; value: LONGINT); 
+	PROCEDURE ^ AmdShowL1TlbAndCache(w: Streams.Writer; cpuInfo: CpuInformation); 
+	PROCEDURE ^ AmdShowL2TlbAndCache(w: Streams.Writer; cpuInfo: CpuInformation); 
+	PROCEDURE ^ AmdShowSVM(w: Streams.Writer; cpuInfo: CpuInformation); 
+	PROCEDURE ^ IntelShowCacheDescriptors(w: Streams.Writer); 
+	PROCEDURE ^ GetCacheIntel*(w: Streams.Writer; value: LONGINT; VAR s: ARRAY OF CHAR); 
+	PROCEDURE ^ IntelShowL2TlbAndCache(w: Streams.Writer; cpuInfo: CpuInformation); 
+	PROCEDURE ^ ShowDetailedCpuInformation(w: Streams.Writer; cpuInfo: CpuInformation); 
+	PROCEDURE ^ ShowCpuInformation(w: Streams.Writer; cpuInfo: CpuInformation); 
+	PROCEDURE ^ Show*(context: Commands.Context); 
+BEGIN
+END CPUID.

lin32/bin/CRC.SymU

@@ -0,0 +1,44 @@
+MODULE CRC;
+	IMPORT SYSTEM, Streams;
+CONST 
+	Init16 =  -1; 
+	Init32 = LONGINT(0FFFFFFFFH); 
+TYPE 
+	CRC16Stream* = OBJECT (Streams.Writer)
+	VAR 
+		crc*: INTEGER; 
+
+		PROCEDURE ^  & InitStream*; 
+		PROCEDURE ^ Send*(CONST buf: ARRAY OF CHAR; ofs, len: LONGINT; propagate: BOOLEAN; VAR res: LONGINT); 
+		PROCEDURE ^ SetCRC*(crc: INTEGER); 
+		PROCEDURE ^ GetCRC*(): INTEGER; 
+	END CRC16Stream; 
+
+	CRC32Stream* = OBJECT (Streams.Writer)
+	VAR 
+		crc: LONGINT; 
+
+		PROCEDURE ^  & InitStream*; 
+		PROCEDURE ^ Reset*; 
+		PROCEDURE ^ Send*(CONST buf: ARRAY OF CHAR; ofs, len: LONGINT; propagate: BOOLEAN; VAR res: LONGINT); 
+		PROCEDURE ^ SetCRC*(crc: LONGINT); 
+		PROCEDURE ^ GetCRC*(): LONGINT; 
+		PROCEDURE ^ GetUninvertedCRC*(): LONGINT; 
+	END CRC32Stream; 
+
+	CRC32* = OBJECT 
+	VAR 
+		crc: LONGINT; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ Char*(c: CHAR); 
+		PROCEDURE ^ Add*(i: LONGINT); 
+		PROCEDURE ^ Get*(): LONGINT; 
+	END CRC32; 
+VAR 
+	CRC16Table, CRC32Table: ARRAY 256 OF SET; 
+
+	PROCEDURE ^ InitTable16; 
+	PROCEDURE ^ InitTable32; 
+BEGIN
+END CRC.

lin32/bin/CSS2.SymU

@@ -0,0 +1,248 @@
+MODULE CSS2;
+	IMPORT Strings, Objects := XMLObjects;
+CONST 
+	Undefined* = 0; 
+	All* = 0; 
+	Aural* = 1; 
+	Braille* = 2; 
+	Embossed* = 3; 
+	Handheld* = 4; 
+	Print* = 5; 
+	Projection* = 6; 
+	Screen* = 7; 
+	TTY* = 8; 
+	TV* = 9; 
+	Descendant* = 1; 
+	Child* = 2; 
+	Sibling* = 3; 
+	Equal* = 1; 
+	Includes* = 2; 
+	Dashmatch* = 3; 
+	Slash* = 1; 
+	Comma* = 2; 
+	Minus* =  -1; 
+	Plus* = 1; 
+	IntNumber* = 1; 
+	RealNumber* = 2; 
+	Percent* = 3; 
+	IntDimension* = 4; 
+	RealDimension* = 5; 
+	Function* = 6; 
+	StringVal* = 7; 
+	StringIdent* = 8; 
+	URI* = 9; 
+	Color* = 10; 
+	Ident* = 11; 
+	UnicodeRange* = 12; 
+	em* = 1; 
+	ex* = 2; 
+	px* = 3; 
+	in* = 4; 
+	cm* = 5; 
+	mm* = 6; 
+	pt* = 7; 
+	pc* = 8; 
+	deg* = 9; 
+	grad* = 10; 
+	rad* = 11; 
+	ms* = 12; 
+	s* = 13; 
+	Hz* = 14; 
+	kHz* = 15; 
+	Left* = 1; 
+	Right* = 2; 
+	First* = 3; 
+TYPE 
+	String* = Strings.String; 
+
+	StyleSheet* = OBJECT 
+	VAR 
+		charSet: String; 
+		rulesets, pages, fontFaces: Objects.Collection; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ GetCharSet*(): String; 
+		PROCEDURE ^ SetCharSet*(VAR charSet: ARRAY OF CHAR); 
+		PROCEDURE ^ GetRuleSets*(): Objects.Enumerator; 
+		PROCEDURE ^ AddRuleSet*(rs: RuleSet); 
+		PROCEDURE ^ GetPages*(): Objects.Enumerator; 
+		PROCEDURE ^ AddPage*(page: Page); 
+		PROCEDURE ^ GetFontFaces*(): Objects.Enumerator; 
+		PROCEDURE ^ AddFontFace*(fontFace: FontFace); 
+	END StyleSheet; 
+
+	RuleSet* = OBJECT 
+	VAR 
+		selectors, declarations: Objects.Collection; 
+		hasImportantDeclarations, hasNotImportantDeclarations: BOOLEAN; 
+		media: SET; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ GetMedia*(): SET; 
+		PROCEDURE ^ IsMediumSupported*(medium: SHORTINT): BOOLEAN; 
+		PROCEDURE ^ AddMedium*(medium: SHORTINT); 
+		PROCEDURE ^ SetMedia*(media: SET); 
+		PROCEDURE ^ GetSelectors*(): Objects.Enumerator; 
+		PROCEDURE ^ AddSelector*(selector: Selector); 
+		PROCEDURE ^ GetDeclarations*(): Objects.Enumerator; 
+		PROCEDURE ^ AddDeclaration*(declaration: Declaration); 
+		PROCEDURE ^ HasImportantDeclarations*(): BOOLEAN; 
+		PROCEDURE ^ HasNotImportantDeclarations*(): BOOLEAN; 
+	END RuleSet; 
+
+	Selector* = OBJECT 
+	VAR 
+		a, b, c: LONGINT; 
+		simpleSelectors: Objects.Collection; 
+		lastSimpleSel: SimpleSelector; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ GetSpecifity*(VAR a, b, c: LONGINT); 
+		PROCEDURE ^ GetSimpleSelectors*(): Objects.Enumerator; 
+		PROCEDURE ^ AddSimpleSelector*(simpleSelector: SimpleSelector); 
+	END Selector; 
+
+	SimpleSelector* = OBJECT 
+	VAR 
+		next: SimpleSelector; 
+		combinator: SHORTINT; 
+		elementName: String; 
+		subSelectors: Objects.Collection; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ GetNext*(): SimpleSelector; 
+		PROCEDURE ^ GetCombinator*(): SHORTINT; 
+		PROCEDURE ^ SetCombinator*(combinator: SHORTINT); 
+		PROCEDURE ^ GetElementName*(): String; 
+		PROCEDURE ^ SetElementName*(VAR elementName: ARRAY OF CHAR); 
+		PROCEDURE ^ GetSubSelectors*(): Objects.Enumerator; 
+		PROCEDURE ^ AddSubSelector*(subSelector: SubSelector); 
+	END SimpleSelector; 
+
+	SubSelector* = OBJECT 
+	END SubSelector; 
+
+	Id* = OBJECT (SubSelector)
+	VAR 
+		value: String; 
+
+		PROCEDURE ^ GetValue*(): String; 
+		PROCEDURE ^ SetValue*(VAR value: ARRAY OF CHAR); 
+	END Id; 
+
+	Class* = OBJECT (SubSelector)
+	VAR 
+		value: String; 
+
+		PROCEDURE ^ GetValue*(): String; 
+		PROCEDURE ^ SetValue*(VAR value: ARRAY OF CHAR); 
+	END Class; 
+
+	Attribute* = OBJECT (SubSelector)
+	VAR 
+		name, value: String; 
+		relation: SHORTINT; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ GetName*(): String; 
+		PROCEDURE ^ SetName*(VAR name: ARRAY OF CHAR); 
+		PROCEDURE ^ GetRelation*(): SHORTINT; 
+		PROCEDURE ^ SetRelation*(relation: SHORTINT); 
+		PROCEDURE ^ GetValue*(): String; 
+		PROCEDURE ^ SetValue*(VAR value: ARRAY OF CHAR); 
+	END Attribute; 
+
+	Pseudo* = OBJECT (SubSelector)
+	VAR 
+		isLanguage: BOOLEAN; 
+		type: String; 
+
+		PROCEDURE ^ GetType*(): String; 
+		PROCEDURE ^ SetType*(VAR type: ARRAY OF CHAR); 
+		PROCEDURE ^ GetLanguage*(): String; 
+		PROCEDURE ^ IsLanguage*(): BOOLEAN; 
+		PROCEDURE ^ SetLanguage*(VAR language: ARRAY OF CHAR); 
+	END Pseudo; 
+
+	Declaration* = OBJECT 
+	VAR 
+		property: String; 
+		expr: Objects.Collection; 
+		important: BOOLEAN; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ GetProperty*(): String; 
+		PROCEDURE ^ SetProperty*(VAR property: ARRAY OF CHAR); 
+		PROCEDURE ^ GetTerms*(): Objects.Enumerator; 
+		PROCEDURE ^ AddTerm*(term: Term); 
+		PROCEDURE ^ RemoveTerm*(term: Term); 
+		PROCEDURE ^ IsImportant*(): BOOLEAN; 
+		PROCEDURE ^ SetImportant*(important: BOOLEAN); 
+	END Declaration; 
+
+	Term* = OBJECT 
+	VAR 
+		operator, unaryOperator: SHORTINT; 
+		type: SHORTINT; 
+		intVal: LONGINT; 
+		realVal: LONGREAL; 
+		stringVal: String; 
+		unit: SHORTINT; 
+		expr: Objects.Collection; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ GetOperator*(): SHORTINT; 
+		PROCEDURE ^ SetOperator*(operator: SHORTINT); 
+		PROCEDURE ^ GetUnaryOperator*(): SHORTINT; 
+		PROCEDURE ^ SetUnaryOperator*(unaryOperator: SHORTINT); 
+		PROCEDURE ^ GetType*(): SHORTINT; 
+		PROCEDURE ^ SetType*(type: SHORTINT); 
+		PROCEDURE ^ GetIntVal*(): LONGINT; 
+		PROCEDURE ^ SetIntVal*(intVal: LONGINT); 
+		PROCEDURE ^ GetRealVal*(): LONGREAL; 
+		PROCEDURE ^ SetRealVal*(realVal: LONGREAL); 
+		PROCEDURE ^ GetStringVal*(): String; 
+		PROCEDURE ^ SetStringVal*(VAR stringVal: ARRAY OF CHAR); 
+		PROCEDURE ^ IsStringIdent*(ident: ARRAY OF CHAR): BOOLEAN; 
+		PROCEDURE ^ IsIdent*(ident: LONGINT): BOOLEAN; 
+		PROCEDURE ^ GetUnit*(): SHORTINT; 
+		PROCEDURE ^ SetUnit*(unit: SHORTINT); 
+		PROCEDURE ^ IsLength*(): BOOLEAN; 
+		PROCEDURE ^ IsAngle*(): BOOLEAN; 
+		PROCEDURE ^ IsTime*(): BOOLEAN; 
+		PROCEDURE ^ IsFrequency*(): BOOLEAN; 
+		PROCEDURE ^ GetColor*(VAR r, g, b, a: CHAR); 
+		PROCEDURE ^ SetColor*(r, g, b, a: CHAR); 
+		PROCEDURE ^ GetTerms*(): Objects.Enumerator; 
+		PROCEDURE ^ AddTerm*(term: Term); 
+	END Term; 
+
+	Page* = OBJECT 
+	VAR 
+		selector: String; 
+		pseudoPage: SHORTINT; 
+		declarations: Objects.Collection; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ GetSelector*(): String; 
+		PROCEDURE ^ SetSelector*(VAR selector: ARRAY OF CHAR); 
+		PROCEDURE ^ GetPseudoPage*(): SHORTINT; 
+		PROCEDURE ^ SetPseudoPage*(pseudoPage: SHORTINT); 
+		PROCEDURE ^ GetDeclarations*(): Objects.Enumerator; 
+		PROCEDURE ^ AddDeclaration*(declaration: Declaration); 
+	END Page; 
+
+	FontFace* = OBJECT 
+	VAR 
+		declarations: Objects.Collection; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ GetDeclarations*(): Objects.Enumerator; 
+		PROCEDURE ^ AddDeclaration*(declaration: Declaration); 
+	END FontFace; 
+
+	PROCEDURE ^ IntToRGBA*(color: LONGINT; VAR r, g, b, a: CHAR); 
+	PROCEDURE ^ RGBAToInt*(r, g, b, a: CHAR; VAR color: LONGINT); 
+	PROCEDURE ^ NewString(VAR value: ARRAY OF CHAR): String; 
+BEGIN
+END CSS2.

lin32/bin/CSS2Parser.SymU

@@ -0,0 +1,40 @@
+MODULE CSS2Parser;
+	IMPORT KernelLog, Strings, Scanner := CSS2Scanner, XMLObjects, CSS2, Files;
+CONST 
+TYPE 
+	String = CSS2.String; 
+
+	Parser* = OBJECT 
+	VAR 
+		reportError*: PROCEDURE (pos, line, row: LONGINT; msg: ARRAY OF CHAR); 
+		scanner: Scanner.Scanner; 
+
+		PROCEDURE ^  & Init*(scanner: Scanner.Scanner); 
+		PROCEDURE ^ CheckSymbol(expectedSymbols: SET; errormsg: ARRAY OF CHAR): BOOLEAN; 
+		PROCEDURE ^ Error(msg: ARRAY OF CHAR); 
+		PROCEDURE ^ Parse*(): CSS2.StyleSheet; 
+		PROCEDURE ^ ParseImport(styleSheet: CSS2.StyleSheet); 
+		PROCEDURE ^ ParseMedia(styleSheet: CSS2.StyleSheet); 
+		PROCEDURE ^ ParsePage(): CSS2.Page; 
+		PROCEDURE ^ ParseFontFace(): CSS2.FontFace; 
+		PROCEDURE ^ ParseRuleSet(): CSS2.RuleSet; 
+		PROCEDURE ^ ParseSelector(): CSS2.Selector; 
+		PROCEDURE ^ ParseSimpleSelector(): CSS2.SimpleSelector; 
+		PROCEDURE ^ ParseId(): CSS2.Id; 
+		PROCEDURE ^ ParseClass(): CSS2.Class; 
+		PROCEDURE ^ ParseAttribute(): CSS2.Attribute; 
+		PROCEDURE ^ ParsePseudo(): CSS2.Pseudo; 
+		PROCEDURE ^ ParseDeclaration(): CSS2.Declaration; 
+		PROCEDURE ^ ParseTerm(): CSS2.Term; 
+		PROCEDURE ^ ParseRGB(hasAlpha: BOOLEAN): LONGINT; 
+		PROCEDURE ^ IgnoreKeyword; 
+	END Parser; 
+
+	PROCEDURE ^ GetMedium(mediumStr: ARRAY OF CHAR): SHORTINT; 
+	PROCEDURE ^ GetPseudoPage(pseudoPageStr: ARRAY OF CHAR): SHORTINT; 
+	PROCEDURE ^ GetTermUnit(unitStr: ARRAY OF CHAR): SHORTINT; 
+	PROCEDURE ^ ComputeRGB(VAR s: ARRAY OF CHAR): LONGINT; 
+	PROCEDURE ^ HexStrToInt(VAR str: ARRAY OF CHAR; VAR val: LONGINT); 
+	PROCEDURE ^ DefaultReportError(pos, line, row: LONGINT; msg: ARRAY OF CHAR); 
+BEGIN
+END CSS2Parser.

lin32/bin/CSS2Properties.SymU

@@ -0,0 +1,382 @@
+MODULE CSS2Properties;
+	IMPORT DynamicStrings, XMLObjects, CSS2, WMWindowManager, WMGraphics, Raster, GfxImages, GfxFonts, Gfx;
+CONST 
+	Aqua* = LONGINT(0FF00FFFFH); 
+	Black* = LONGINT(0FF000000H); 
+	Blue* = LONGINT(0FF0000FFH); 
+	Fuchsia* = LONGINT(0FFFF00FFH); 
+	Gray* = LONGINT(0FF808080H); 
+	Green* = LONGINT(0FF008000H); 
+	Lime* = LONGINT(0FF00FF00H); 
+	Maroon* = LONGINT(0FF800000H); 
+	Navy* = LONGINT(0FF000080H); 
+	Olive* = LONGINT(0FF808000H); 
+	Purple* = LONGINT(0FF800080H); 
+	Red* = LONGINT(0FFFF0000H); 
+	Silver* = LONGINT(0FFC0C0C0H); 
+	Teal* = LONGINT(0FF008080H); 
+	White* = LONGINT(0FFFFFFFFH); 
+	Yellow* = LONGINT(0FFFFFF00H); 
+	Transparent* = 0; 
+	XXSmall* = 0; 
+	XSmall* = 1; 
+	Small* = 2; 
+	Medium* = 3; 
+	Large* = 4; 
+	XLarge* = 5; 
+	XXLarge* = 6; 
+	Larger* = 7; 
+	Smaller* = 8; 
+	None* = 1; 
+	Inherit* = 2; 
+	Normal* = 3; 
+	Auto* = 4; 
+	Top* = 5; 
+	Center* = 6; 
+	Bottom* = 7; 
+	Left* = 8; 
+	Right* = 9; 
+	Repeat* = 5; 
+	NoRepeat* = 6; 
+	Collapse* = 5; 
+	Separate* = 6; 
+	Hidden* = 6; 
+	Dotted* = 7; 
+	Dashed* = 8; 
+	Solid* = 9; 
+	Double* = 10; 
+	Groove* = 11; 
+	Ridge* = 12; 
+	Inset* = 13; 
+	Outset* = 14; 
+	Thin* = 5; 
+	Thick* = 7; 
+	StaticPosition* = 5; 
+	Clear* = 5; 
+	OpenQuote* = 5; 
+	CloseQuote* = 6; 
+	NoOpenQuote* = 7; 
+	NoCloseQuote* = 8; 
+	Crosshair* = 5; 
+	Default* = 6; 
+	Pointer* = 7; 
+	Move* = 8; 
+	EResize* = 9; 
+	NEResize* = 10; 
+	NWResize* = 11; 
+	NResize* = 12; 
+	SEResize* = 13; 
+	SWResize* = 14; 
+	SResize* = 15; 
+	WResize* = 16; 
+	Text* = 17; 
+	Wait* = 18; 
+	Help* = 19; 
+	Ltr* = 5; 
+	Rtl* = 6; 
+	Inline* = 3; 
+	Block* = 4; 
+	ListItem* = 5; 
+	RunIn* = 6; 
+	Compact* = 7; 
+	Marker* = 8; 
+	Table* = 9; 
+	InlineTable* = 10; 
+	TableRowGroup* = 11; 
+	TableHeaderGroup* = 12; 
+	TableFooterGroup* = 13; 
+	TableRow* = 14; 
+	TableColumnGroup* = 15; 
+	TableColumn* = 16; 
+	TableCell* = 17; 
+	TableCaption* = 18; 
+	Show* = 5; 
+	Hide* = 6; 
+	Caption* = 5; 
+	Icon* = 6; 
+	Menu* = 7; 
+	MessageBox* = 8; 
+	SmallCaption* = 9; 
+	StatusBar* = 10; 
+	Wider* = 5; 
+	Narrower* = 6; 
+	UltraCondensed* = 7; 
+	ExtraCondensed* = 8; 
+	Condensed* = 9; 
+	SemiCondensed* = 10; 
+	SemiExpanded* = 11; 
+	Expanded* = 12; 
+	ExtraExpanded* = 13; 
+	UltraExpanded* = 14; 
+	Italic* = 5; 
+	Oblique* = 6; 
+	SmallCaps* = 5; 
+	Bold* = 5; 
+	Bolder* = 6; 
+	Lighter* = 7; 
+	Inside* = 5; 
+	Outside* = 6; 
+	Disc* = 5; 
+	Circle* = 6; 
+	Square* = 7; 
+	Decimal* = 8; 
+	DecimalLeadingZero* = 9; 
+	LowerRoman* = 10; 
+	UpperRoman* = 11; 
+	LowerGreek* = 12; 
+	LowerAlpha* = 13; 
+	LowerLatin* = 14; 
+	UpperAlpha* = 15; 
+	UpperLatin* = 16; 
+	Hebrew* = 17; 
+	Armenian* = 18; 
+	Georgian* = 19; 
+	CjkIdeographic* = 20; 
+	Hiragana* = 21; 
+	Katakana* = 22; 
+	HiraganaIroha* = 23; 
+	KatakanaIroha* = 24; 
+	Invert* = 122; 
+	Visible* = 7; 
+	Static* = 5; 
+	Relative* = 6; 
+	Absolute* = 7; 
+	Fixed* = 8; 
+	Scroll* = 9; 
+	Justify* = 10; 
+	Underline* = 5; 
+	Overline* = 6; 
+	LineThrough* = 7; 
+	Blink* = 8; 
+	Capitalize* = 5; 
+	Uppercase* = 6; 
+	Lowercase* = 7; 
+	Embed* = 5; 
+	BidiOverride* = 6; 
+	Baseline* = 8; 
+	Sub* = 9; 
+	Super* = 10; 
+	TextTop* = 11; 
+	Middle* = 12; 
+	TextBottom* = 13; 
+	Pre* = 5; 
+	Nowrap* = 6; 
+	DummyAuto = 0; 
+TYPE 
+	String = CSS2.String; 
+
+	Value* = RECORD 
+		specified: CSS2.Term; 
+	END; 
+
+	Color* = RECORD (Value)
+		computed*: RECORD 
+			r*, g*, b*, a*: CHAR; 
+		END; 
+	END; 
+
+	TRBLColor* = RECORD 
+		top*, right*, bottom*, left*: Color; 
+	END; 
+
+	Ident* = RECORD (Value)
+		computed*: SHORTINT; 
+	END; 
+
+	TRBLIdent* = RECORD 
+		top*, right*, bottom*, left*: Ident; 
+	END; 
+
+	Dim* = RECORD (Value)
+		computed*: LONGREAL; 
+	END; 
+
+	OrientDim* = RECORD 
+		horizontal*, vertical*: Dim; 
+	END; 
+
+	TRBLDim* = RECORD 
+		top*, right*, bottom*, left*: Dim; 
+	END; 
+
+	Bool* = RECORD (Value)
+		computed*: BOOLEAN; 
+	END; 
+
+	Img* = RECORD (Value)
+		computed*: GfxImages.Image; 
+	END; 
+
+	Cursor* = RECORD 
+		specified: XMLObjects.Collection; 
+		computed*: WMWindowManager.PointerInfo; 
+	END; 
+
+	Font* = RECORD (Value)
+		computed*: GfxFonts.Font; 
+	END; 
+
+	ImgTerm = OBJECT (CSS2.Term)
+	VAR 
+		img: GfxImages.Image; 
+	END ImgTerm; 
+
+	AllMediaProperties* = OBJECT 
+	VAR 
+		parent: AllMediaProperties; 
+		replaced, generated: BOOLEAN; 
+		counterIncrement*, counterReset*, display*: Ident; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ SetParent*(parent: AllMediaProperties); 
+		PROCEDURE ^ GetValue*(name: ARRAY OF CHAR): CSS2.Declaration; 
+		PROCEDURE ^ SetValue*(declaration: CSS2.Declaration); 
+		PROCEDURE ^ Initialize*; 
+		PROCEDURE ^ ComputeValues*; 
+		PROCEDURE ^ IsBlockLevelElement*(): BOOLEAN; 
+		PROCEDURE ^ IsInlineLevelElement*(): BOOLEAN; 
+	END AllMediaProperties; 
+
+	VisualProperties* = OBJECT (AllMediaProperties)
+	TYPE 
+		; 
+
+		; 
+
+		; 
+
+		; 
+
+		; 
+
+		; 
+
+		; 
+
+		; 
+	VAR 
+		dimensionChanged-: BOOLEAN; 
+		containingBlock: RECORD 
+			width, height: LONGREAL; 
+		END; 
+		ppi*: LONGREAL; 
+		backgroundAttachment*: Bool; 
+		backgroundColor*: Color; 
+		backgroundImage*: Img; 
+		backgroundPosition*: OrientDim; 
+		backgroundRepeat*: RECORD 
+			horizontal*, vertical*: Bool; 
+		END; 
+		borderCollapse*: Bool; 
+		borderSpacing*: OrientDim; 
+		borderColor*: TRBLColor; 
+		borderStyle*: TRBLIdent; 
+		borderWidth*, margin*, padding*: TRBLDim; 
+		top*, right*, bottom*, left*: Dim; 
+		height*, width*, maxHeight*, maxWidth*, minHeight*, minWidth*: Dim; 
+		captionSide*: Ident; 
+		clear*: RECORD 
+			left*, right*: Bool; 
+		END; 
+		clip*: TRBLDim; 
+		color*: Color; 
+		cursor*: Cursor; 
+		direction*: Bool; 
+		emptyCells*: Bool; 
+		float*: Ident; 
+		font*: Font; 
+		fontSize*: Dim; 
+		fontFamily*, fontSizeAdjust*, fontStyle*, fontWeight*: CSS2.Term; 
+		fontStretch*: Ident; 
+		fontVariant*: Bool; 
+		letterSpacing*, wordSpacing*: Dim; 
+		lineHeight*: Dim; 
+		listStyleImage*: Img; 
+		listStylePosition*: Bool; 
+		listStyleType*: Ident; 
+		markerOffset*: Dim; 
+		outlineColor*: Color; 
+		outlineStyle*: Ident; 
+		outlineWidth*: Dim; 
+		overflow*: Ident; 
+		position*: Ident; 
+		quotes*: RECORD (Value)
+		END; 
+		tableLayout*: Bool; 
+		textAlign*: Ident; 
+		textDecoration*: RECORD (Value)
+			computed*: SET; 
+		END; 
+		textIndent*: Dim; 
+		textShadow*: RECORD (Value)
+		END; 
+		textTransform*: Ident; 
+		unicodeBidi*: Ident; 
+		verticalAlign*: RECORD (Value)
+			computedLength*: LONGREAL; 
+			computed*: SHORTINT; 
+		END; 
+		visibility*: Ident; 
+		whiteSpace*: Ident; 
+		zIndex*: RECORD (Value)
+			computed*: LONGINT; 
+		END; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ SetParent*(parent: AllMediaProperties); 
+		PROCEDURE ^ GetValue*(name: ARRAY OF CHAR): CSS2.Declaration; 
+		PROCEDURE ^ SetValue*(declaration: CSS2.Declaration); 
+		PROCEDURE ^ Initialize*; 
+		PROCEDURE ^ ComputeValues*; 
+		PROCEDURE ^ ComputeDimensions*; 
+		PROCEDURE ^ ComputeWidthsAndMargins; 
+		PROCEDURE ^ ComputeHeightsAndMargins; 
+		PROCEDURE ^ ComputeFont; 
+		PROCEDURE ^ ComputeContainingBlock; 
+		PROCEDURE ^ IsPositioned(): BOOLEAN; 
+	END VisualProperties; 
+VAR 
+	AbsoluteFontSizes: ARRAY 7 OF SHORTINT; 
+	defaultColor*: LONGINT; 
+	defaultCursor*, crosshairCursor*, pointerCursor*, moveCursor*, eResizeCursor*, neResizeCursor*, nwResizeCursor*, nResizeCursor*, seResizeCursor*, swResizeCursor*, sResizeCursor*, wResizeCursor*, textCursor*, waitCursor*, helpCursor*: WMWindowManager.PointerInfo; 
+	defaultFont*, captionFont*, iconFont*, menuFont*, messageBoxFont*, smallCaptionFont*, statusBarFont*: GfxFonts.Font; 
+	thinBorder*, mediumBorder*, thickBorder*: LONGREAL; 
+	m: WMWindowManager.WindowManager; 
+
+	PROCEDURE ^ IsAutoSize*(size: Dim): BOOLEAN; 
+	PROCEDURE ^ IsAutoMargin*(margin: Dim): BOOLEAN; 
+	PROCEDURE ^ ChangeToIdent(identValue: SHORTINT): CSS2.Term; 
+	PROCEDURE ^ ChangeToStringIdent(VAR term: CSS2.Term; identValue: ARRAY OF CHAR); 
+	PROCEDURE ^ SetNil(VAR property: CSS2.Term; term: CSS2.Term): BOOLEAN; 
+	PROCEDURE ^ SetIdentOrInherit(VAR property: CSS2.Term; term: CSS2.Term): BOOLEAN; 
+	PROCEDURE ^ SetNone(VAR property: CSS2.Term; term: CSS2.Term): BOOLEAN; 
+	PROCEDURE ^ ChangeToIdentCollection(VAR collection: XMLObjects.Collection; identValue: SHORTINT); 
+	PROCEDURE ^ SetNilCollection(VAR collection: XMLObjects.Collection; term: CSS2.Term): BOOLEAN; 
+	PROCEDURE ^ SetIdentOrInheritCollection(VAR collection: XMLObjects.Collection; term: CSS2.Term): BOOLEAN; 
+	PROCEDURE ^ GetPixels(term: CSS2.Term; ppi: LONGREAL; font: GfxFonts.Font): LONGREAL; 
+	PROCEDURE ^ ChangeToPixel(pixelVal: LONGREAL): CSS2.Term; 
+	PROCEDURE ^ SetColor(VAR property: CSS2.Term; term: CSS2.Term; invertAllowed: BOOLEAN); 
+	PROCEDURE ^ IsBorderStyle(term: CSS2.Term): BOOLEAN; 
+	PROCEDURE ^ BorderStyle(VAR position: CSS2.Term; term: CSS2.Term); 
+	PROCEDURE ^ IsBorderWidth(term: CSS2.Term): BOOLEAN; 
+	PROCEDURE ^ BorderWidth(VAR position: CSS2.Term; term: CSS2.Term); 
+	PROCEDURE ^ BoxOffset(VAR position: CSS2.Term; term: CSS2.Term); 
+	PROCEDURE ^ ListStyleImage(VAR listStyleImage: CSS2.Term; term: CSS2.Term); 
+	PROCEDURE ^ ListStylePosition(VAR listStylePosition: CSS2.Term; term: CSS2.Term); 
+	PROCEDURE ^ ListStyleType(VAR listStyleType: CSS2.Term; term: CSS2.Term); 
+	PROCEDURE ^ MarginWidth(VAR position: CSS2.Term; term: CSS2.Term); 
+	PROCEDURE ^ MaxDimension(VAR dimension: CSS2.Term; term: CSS2.Term); 
+	PROCEDURE ^ MinDimension(VAR dimension: CSS2.Term; term: CSS2.Term); 
+	PROCEDURE ^ PaddingWidth(VAR position: CSS2.Term; term: CSS2.Term); 
+	PROCEDURE ^ ComputeBool(VAR property: Bool; parentProperty: Bool; trueIdent: LONGINT); 
+	PROCEDURE ^ ComputeColor(VAR property: Color; parentProperty, initial: Color); 
+	PROCEDURE ^ ComputeImg(VAR property: Img; parentProperty: Img); 
+	PROCEDURE ^ ComputeDim(VAR property: Dim; parentProperty: Dim; ppi, referenceDim: LONGREAL; font: GfxFonts.Font); 
+	PROCEDURE ^ ComputeIdent(VAR property: Ident; parentProperty: Ident); 
+	PROCEDURE ^ ComputeCursor(VAR property: Cursor; parentProperty: Cursor); 
+	PROCEDURE ^ SetZeroIfAutoSize(size: Dim); 
+	PROCEDURE ^ SetZeroIfAutoMargin(size: Dim); 
+	PROCEDURE ^ ToGfxColor*(color: Color): Gfx.Color; 
+	PROCEDURE ^ IntToColor(color: LONGINT): Color; 
+BEGIN
+END CSS2Properties.