Added Linux64G executable

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

Linux64G/a2.txt

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

Linux64G/bin/A2Sequencers.SymUu

@@ -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.

Linux64G/bin/AFM.SymUu

@@ -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.

Linux64G/bin/ASMAMD64.SymUu

@@ -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.

Linux64G/bin/ASN1.SymUu

@@ -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.

Linux64G/bin/ActiveTimers.SymUu

@@ -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.

Linux64G/bin/AlmSmtpReceiver.SymUu

@@ -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.

Linux64G/bin/AnimationCodec.SymUu

@@ -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.

Linux64G/bin/Archives.SymUu

@@ -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.

Linux64G/bin/Attributes.SymUu

@@ -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.

Linux64G/bin/Autostart.SymUu

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

Linux64G/bin/BIT.SymUu

@@ -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.

Linux64G/bin/BMPCodec.SymUu

@@ -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.

Linux64G/bin/Base64.SymUu

@@ -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.

Linux64G/bin/Beep.SymUu

@@ -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.

Linux64G/bin/BeepTest.SymUu

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

Linux64G/bin/BenchSyntaxHighlighter.SymUu

@@ -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.

Linux64G/bin/BenchTCP.SymUu

@@ -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.

Linux64G/bin/BenchXML.SymUu

@@ -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.

Linux64G/bin/BimboMail.SymUu

@@ -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.

Linux64G/bin/BimboScanner.SymUu

@@ -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.

Linux64G/bin/Bimso.SymUu

@@ -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.

Linux64G/bin/Bin2Hex.SymUu

@@ -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.

Linux64G/bin/BinToCode.SymUu

@@ -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.

Linux64G/bin/BitSets.SymUu

@@ -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.

Linux64G/bin/BootConsole.SymUu

@@ -0,0 +1,29 @@
+MODULE BootConsole;
+	IMPORT S := SYSTEM, Trace, Glue, Unix, Machine, Modules, Objects, Commands, KernelLog;
+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.

Linux64G/bin/BootManager.SymUu

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

Linux64G/bin/BootShell.SymUu

@@ -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.

Linux64G/bin/CATServer.SymUu

@@ -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.

Linux64G/bin/CLUTs.SymUu

@@ -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.

Linux64G/bin/CRC.SymUu

@@ -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.

Linux64G/bin/CSS2.SymUu

@@ -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.

Linux64G/bin/CSS2Parser.SymUu

@@ -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.

Linux64G/bin/CSS2Properties.SymUu

@@ -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.

Linux64G/bin/CSS2Scanner.SymUu

@@ -0,0 +1,80 @@
+MODULE CSS2Scanner;
+	IMPORT KernelLog, Strings, Streams, Files, DynamicStrings;
+CONST 
+	Null =  -2; 
+	Invalid* =  -1; 
+	Ident* = 0; 
+	AtKeyword* = 1; 
+	String* = 2; 
+	Hash* = 3; 
+	Important* = 4; 
+	Number* = 5; 
+	Percentage* = 6; 
+	Dimension* = 7; 
+	URI* = 8; 
+	Function* = 9; 
+	UnicodeRange* = 10; 
+	Cdo* = 11; 
+	Cdc* = 12; 
+	Slash* = 13; 
+	Comma* = 14; 
+	Greater* = 15; 
+	Plus* = 16; 
+	Minus* = 17; 
+	Asterisk* = 18; 
+	Semicolon* = 19; 
+	Colon* = 20; 
+	Dot* = 21; 
+	BracketOpen* = 22; 
+	BracketClose* = 23; 
+	ParenOpen* = 24; 
+	ParenClose* = 25; 
+	BraceOpen* = 26; 
+	BraceClose* = 27; 
+	Equal* = 28; 
+	Includes* = 29; 
+	Dashmatch* = 30; 
+	Eof* = 31; 
+	Undefined* = 0; 
+	Integer* = 1; 
+	Real* = 2; 
+TYPE 
+	Scanner* = OBJECT 
+	VAR 
+		sym-: LONGINT; 
+		numberType-: SHORTINT; 
+		intVal-: LONGINT; 
+		realVal-: LONGREAL; 
+		line-, row-, pos: LONGINT; 
+		reportError*: PROCEDURE (pos, line, row: LONGINT; msg: ARRAY OF CHAR); 
+		nextCh: CHAR; 
+		dynstr: DynamicStrings.DynamicString; 
+		f: Files.File; 
+		r: Files.Reader; 
+
+		PROCEDURE ^  & Init*(f: Files.File); 
+		PROCEDURE ^ Error(msg: ARRAY OF CHAR); 
+		PROCEDURE ^ NextCh; 
+		PROCEDURE ^ SkipWhiteSpace; 
+		PROCEDURE ^ ScanComment; 
+		PROCEDURE ^ ScanEscape(isString: BOOLEAN; VAR i: LONGINT); 
+		PROCEDURE ^ ScanIdent; 
+		PROCEDURE ^ ScanName; 
+		PROCEDURE ^ ScanString; 
+		PROCEDURE ^ ScanURL; 
+		PROCEDURE ^ ScanNumber; 
+		PROCEDURE ^ Scan*; 
+		PROCEDURE ^ GetStr*(): Strings.String; 
+		PROCEDURE ^ GetPos*(): LONGINT; 
+	END Scanner; 
+
+	PROCEDURE ^ IsWhiteSpace(ch: CHAR): BOOLEAN; 
+	PROCEDURE ^ IsNonAscii(ch: CHAR): BOOLEAN; 
+	PROCEDURE ^ IsEscape(ch: CHAR): BOOLEAN; 
+	PROCEDURE ^ IsNmStart(ch: CHAR): BOOLEAN; 
+	PROCEDURE ^ IsNmChar(ch: CHAR): BOOLEAN; 
+	PROCEDURE ^ IsDigit(ch: CHAR): BOOLEAN; 
+	PROCEDURE ^ HexStrToInt(VAR str: ARRAY OF CHAR; VAR val: LONGINT); 
+	PROCEDURE ^ DefaultReportError(pos, line, row: LONGINT; msg: ARRAY OF CHAR); 
+BEGIN
+END CSS2Scanner.

Linux64G/bin/CSV.SymUu

@@ -0,0 +1,58 @@
+MODULE CSV;
+	IMPORT Streams, Files, Strings;
+CONST 
+	CR = 0DX; 
+	LF = 0AX; 
+	TAB = 9X; 
+	SP = 20X; 
+TYPE 
+	Field* = OBJECT 
+	VAR 
+		next-: Field; 
+		string*: Strings.String; 
+	END Field; 
+
+	Line* = OBJECT 
+	VAR 
+		next-: Line; 
+		fields-: Field; 
+	END Line; 
+
+	Scanner* = OBJECT 
+	VAR 
+		r: Streams.Reader; 
+		buf: Strings.Buffer; 
+		bufw: Streams.Writer; 
+		csvFile: CSV; 
+
+		PROCEDURE ^  & Init*(file: CSV; r: Streams.Reader); 
+		PROCEDURE ^ Scan*; 
+		PROCEDURE ^ ScanLine*; 
+		PROCEDURE ^ ScanField*; 
+	END Scanner; 
+
+	CSV* = OBJECT 
+	VAR 
+		separator-: CHAR; 
+		escaper-: CHAR; 
+		quoteChars-: Strings.String; 
+		lines-: Line; 
+		curLine: Line; 
+		curField: Field; 
+
+		PROCEDURE ^  & Init*(CONST separator, escaper: CHAR; CONST quotes: ARRAY OF CHAR); 
+		PROCEDURE ^ NewLine*; 
+		PROCEDURE ^ AddField*(CONST str: ARRAY OF CHAR); 
+		PROCEDURE ^ NeedsQuotes*(CONST str: ARRAY OF CHAR): BOOLEAN; 
+		PROCEDURE ^ GetUnusedQuote*(CONST str: ARRAY OF CHAR): CHAR; 
+		PROCEDURE ^ Write*(out: Streams.Writer); 
+	END CSV; 
+
+	PROCEDURE ^ IsWhiteSpace*(CONST ch: CHAR): BOOLEAN; 
+	PROCEDURE ^ ContainsWhitespace*(CONST str: ARRAY OF CHAR): BOOLEAN; 
+	PROCEDURE ^ GetDefaultCSV*(): CSV; 
+	PROCEDURE ^ ScanFromFileName*(CONST fn: ARRAY OF CHAR; VAR csv: CSV); 
+	PROCEDURE ^ AppendCSVToFileName*(CONST fn: ARRAY OF CHAR; CONST csv: CSV); 
+	PROCEDURE ^ CompareCSVs*(a, b: CSV): BOOLEAN; 
+BEGIN
+END CSV.

Linux64G/bin/Caches.SymUu

@@ -0,0 +1,44 @@
+MODULE Caches;
+	IMPORT KernelLog, Objects, Disks;
+CONST 
+	LockedBit = 0; 
+	DirtyBit = 1; 
+	CacheUpdateTime = (5 * 1000); 
+	Trace = TRUE; 
+TYPE 
+	Buffer* = OBJECT 
+	VAR 
+		data*: POINTER TO ARRAY OF CHAR; 
+		dev*: Disks.Device; 
+		block*: LONGINT; 
+		state: SET; 
+		nextHash, prevHash, nextLRU, prevLRU, nextDirty: Buffer; 
+
+		PROCEDURE ^  & Init*(size: LONGINT); 
+	END Buffer; 
+
+	Cache* = OBJECT {EXCLUSIVE} 
+	VAR 
+		blockSize*: LONGINT; 
+		hashTable: POINTER TO ARRAY OF Buffer; 
+		lru: Buffer; 
+		lruClean: LONGINT; 
+		syncNow: BOOLEAN; 
+		timer: Objects.Timer; 
+
+		PROCEDURE ^ Acquire*(dev: Disks.Device; block: LONGINT; VAR buffer: Buffer; VAR valid: BOOLEAN); 
+		PROCEDURE ^ Release*(buffer: Buffer; modified, written: BOOLEAN); 
+		PROCEDURE ^ Synchronize*; 
+		PROCEDURE ^ AcquireDirty(VAR list: Buffer); 
+		PROCEDURE ^ ReleaseDirty(buffer: Buffer); 
+		PROCEDURE ^ AwaitSync; 
+		PROCEDURE ^ Hash(dev: Disks.Device; block: LONGINT): LONGINT; 
+		PROCEDURE ^ MoveBuffer(buf: Buffer; from, to: LONGINT); 
+		PROCEDURE ^ HandleTimeout; 
+		PROCEDURE ^  & Init*(blockSize, hashSize, cacheSize: LONGINT); 
+	BEGIN{ACTIVE, SAFE} 
+	END Cache; 
+
+	PROCEDURE ^ ReportError(dev: Disks.Device; block, num, res: LONGINT); 
+BEGIN
+END Caches.

Linux64G/bin/CharacterLineup.SymUu

@@ -0,0 +1,59 @@
+MODULE CharacterLineup;
+	IMPORT KernelLog, Modules, WMComponents, WMStandardComponents, WMEditors, Strings, UTF8Strings, WMGraphics, UnihanParser, WM := WMWindowManager, WMGrids, WMCCGFonts, WMRectangles;
+CONST 
+	MaxCharacterCode = 200000; 
+	NofCols = 25; 
+	MaxFilters = 8; 
+TYPE 
+	CharacterArray = POINTER TO ARRAY OF WMCCGFonts.Glyph; 
+
+	HistoEntry = RECORD 
+		ucs, freq: LONGINT; 
+	END; 
+
+	FilterHisto = POINTER TO ARRAY OF HistoEntry; 
+
+	Identifier = OBJECT {EXCLUSIVE} (WMComponents.FormWindow)
+	VAR 
+		mainPanel, toolbar, infobar, textInfoPanel, selectionPanel, filterPanel, paintBox: WMStandardComponents.Panel; 
+		characterEdit, pinyinEdit, mandarinEdit, cantoneseEdit, koreanEdit, definitionEdit, codeEdit: WMEditors.Editor; 
+		characters, filterComponents: WMGrids.GenericGrid; 
+		toggleFilter: WMStandardComponents.Button; 
+		curChar: LONGINT; 
+		fontinfo: WMCCGFonts.GenericFont; 
+		bigFont: WMGraphics.Font; 
+		charInfo: UnihanParser.Character; 
+		allCharacters: CharacterArray; 
+		nofCharacters: LONGINT; 
+		filtered: CharacterArray; 
+		filterArray: ARRAY MaxFilters OF LONGINT; 
+		nofFilters: LONGINT; 
+		nofInFilter: LONGINT; 
+		useFilter: BOOLEAN; 
+		relevantSubcomponents: FilterHisto; 
+
+		PROCEDURE ^  & New*; 
+		PROCEDURE ^ LoadAllCharacters; 
+		PROCEDURE ^ Update; 
+		PROCEDURE ^ IsComponentUsed(glyph: WMCCGFonts.Glyph; code: LONGINT): BOOLEAN; 
+		PROCEDURE ^ Filter(nofSubs: LONGINT; CONST subs: ARRAY OF LONGINT); 
+		PROCEDURE ^ ToggleFilter(sender, data: ANY); 
+		PROCEDURE ^ NewCharacter(sender, data: ANY); 
+		PROCEDURE ^ NewCode(sender, data: ANY); 
+		PROCEDURE ^ SelectChar(sender, data: ANY); 
+		PROCEDURE ^ FilterSelection(sender, data: ANY); 
+		PROCEDURE ^ IsInFilterArray(ucs: LONGINT): BOOLEAN; 
+		PROCEDURE ^ AddToFilter(ucs: LONGINT); 
+		PROCEDURE ^ RemoveFromFilter(ucs: LONGINT); 
+		PROCEDURE ^ PaintCharacter(canvas: WMGraphics.Canvas); 
+		PROCEDURE ^ Close*; 
+		PROCEDURE ^ DrawAll(canvas: WMGraphics.Canvas; w, h: LONGINT; state: SET; x, y: LONGINT); 
+		PROCEDURE ^ DrawFilterComponents(canvas: WMGraphics.Canvas; w, h: LONGINT; state: SET; x, y: LONGINT); 
+	END Identifier; 
+VAR 
+	winstance: Identifier; 
+
+	PROCEDURE ^ Open*; 
+	PROCEDURE ^ Cleanup; 
+BEGIN
+END CharacterLineup.

Linux64G/bin/Checksum.SymUu

@@ -0,0 +1,14 @@
+MODULE Checksum;
+	IMPORT Commands, Files, Streams, Hashes := CryptoHashes;
+CONST 
+VAR 
+	hexdigits: ARRAY 17 OF CHAR; 
+
+	PROCEDURE ^ MD5*(c: Commands.Context); 
+	PROCEDURE ^ SHA1*(c: Commands.Context); 
+	PROCEDURE ^ SHA3*(c: Commands.Context); 
+	PROCEDURE ^ Do(c: Commands.Context; h: Hashes.Hash); 
+	PROCEDURE ^ OpenNextFile(c: Commands.Context; VAR f: Files.File): BOOLEAN; 
+	PROCEDURE ^ ComputeHash(r: Files.Reader; h: Hashes.Hash; out: Streams.Writer); 
+BEGIN
+END Checksum.

Linux64G/bin/Clipboard.SymUu

@@ -0,0 +1,45 @@
+MODULE Clipboard;
+	IMPORT SYSTEM, Unix, Machine, X11, X11Api, Displays, XDisplay, Plugins, Log := KernelLog, Modules, Texts, TextUtilities, Strings, HostClipboard, Objects;
+CONST 
+	BufferSize = 8192; 
+TYPE 
+	Buffer = POINTER TO ARRAY BufferSize OF CHAR; 
+
+	Grabber = OBJECT {EXCLUSIVE} 
+	CONST 
+		HSize = 256; 
+	VAR 
+		terminate: BOOLEAN; 
+		lastSelectionHead: ARRAY HSize OF CHAR; 
+
+		PROCEDURE ^  & Init; 
+		PROCEDURE ^ SelectionIsNew(): BOOLEAN; 
+		PROCEDURE ^ SaveSelection; 
+	BEGIN{ACTIVE} 
+	END Grabber; 
+VAR 
+	sendBuffer, recBuffer, utf8Buffer: Buffer; 
+	slen, rlen, ulen: LONGINT; 
+	received: BOOLEAN; 
+	grabber: Grabber; 
+	myProperty: X11.Atom; 
+	xdisp: X11.DisplayPtr; 
+	primary: X11.Window; 
+	secondary: X11.Window; 
+
+	PROCEDURE ^ A2ToUnix; 
+	PROCEDURE ^ UnixToA2; 
+	PROCEDURE ^ ScanHexDigits(CONST buf: ARRAY OF CHAR; VAR pos: LONGINT): LONGINT; 
+	PROCEDURE ^ Utf8ToUnicode(CONST buf: ARRAY OF CHAR; VAR pos: LONGINT): LONGINT; 
+	PROCEDURE ^ ClearSelection; 
+	PROCEDURE ^ ClipboardChanged(sender, data: ANY); 
+	PROCEDURE ^ PutToClipboard(text: Texts.Text); 
+	PROCEDURE ^ SendSelection(VAR event: X11Api.XSelectionRequestEvent); 
+	PROCEDURE ^ GetFromClipboard(text: Texts.Text); 
+	PROCEDURE ^ GetX11Selection; 
+	PROCEDURE ^ ReceiveSelection(VAR event: X11Api.XSelectionEvent); 
+	PROCEDURE ^ GetXDisplay; 
+	PROCEDURE ^ Cleanup; 
+	PROCEDURE ^ Install*; 
+BEGIN
+END Clipboard.

Linux64G/bin/Clock.SymUu

@@ -0,0 +1,11 @@
+MODULE Clock;
+	IMPORT Unix;
+VAR 
+	tz*: LONGINT; 
+	starttime*, startdate*: LONGINT; 
+
+	PROCEDURE ^ Get*(VAR time, date: LONGINT); 
+	PROCEDURE ^ Set*(time, date: LONGINT); 
+	PROCEDURE ^ Init; 
+BEGIN
+END Clock.

Linux64G/bin/Codecs.SymUu

@@ -0,0 +1,214 @@
+MODULE Codecs;
+	IMPORT Streams, Commands, Files, SoundDevices, Raster, Modules, Strings, Configuration, Unzip, Texts, Archives;
+CONST 
+	ResFailed* =  -1; 
+	ResOk* = 0; 
+	ResSeekInexact* = 1; 
+	ImgFmtBW* = 0; 
+	ImgFmtGrey* = 1; 
+	ImgFmtRGB* = 2; 
+	ImgFmtRGBA* = 3; 
+	STError* =  -1; 
+	STUnknown* = 0; 
+	STAudio* = 1; 
+	STVideo* = 2; 
+	STImage* = 3; 
+	SeekByte* = 0; 
+	SeekSample* = 1; 
+	SeekKeySample* = 2; 
+	SeekFrame* = 3; 
+	SeekKeyFrame* = 4; 
+	Unspecified* = 0; 
+	DoNotDispose* = 1; 
+	RestoreToBackground* = 2; 
+	RestoreToPrevious* = 3; 
+	WaitForUserInput* = 0; 
+TYPE 
+	AVStreamInfo* = RECORD 
+		streamType*: LONGINT; 
+		seekability*: SET; 
+		contentType*: ARRAY 16 OF CHAR; 
+		length*: LONGINT; 
+		frames*: LONGINT; 
+		rate*: LONGINT; 
+	END; 
+
+	FileInputStream* = OBJECT (Streams.Reader)
+	VAR 
+		r: Files.Rider; 
+		f*: Files.File; 
+		streamInfo*: AVStreamInfo; 
+
+		PROCEDURE ^ Receive(VAR buf: ARRAY OF CHAR; ofs, size, min: LONGINT; VAR len, res: LONGINT); 
+		PROCEDURE ^  & InitFileReader*(f: Files.File; pos: LONGINT); 
+		PROCEDURE ^ CanSetPos*(): BOOLEAN; 
+		PROCEDURE ^ SetPos*(pos: LONGINT); 
+	END FileInputStream; 
+
+	AVDemultiplexer* = OBJECT 
+
+		PROCEDURE ^ Open*(in: Streams.Reader; VAR res: LONGINT); 
+		PROCEDURE ^ GetNumberOfStreams*(): LONGINT; 
+		PROCEDURE ^ GetStreamType*(streamNr: LONGINT): LONGINT; 
+		PROCEDURE ^ GetStreamInfo*(streamNr: LONGINT): AVStreamInfo; 
+		PROCEDURE ^ GetStream*(streamNr: LONGINT): DemuxStream; 
+		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); 
+	END AVDemultiplexer; 
+
+	DemuxStream* = OBJECT (Streams.Reader)
+	VAR 
+		demultiplexer*: AVDemultiplexer; 
+		streamNr*: LONGINT; 
+		streamInfo*: AVStreamInfo; 
+
+		PROCEDURE ^  & Open*(demultiplexer: AVDemultiplexer; streamNr: LONGINT); 
+		PROCEDURE ^ Receive(VAR buf: ARRAY OF CHAR; ofs, size, min: LONGINT; VAR len, res: LONGINT); 
+		PROCEDURE ^ SetPos*(pos: LONGINT); 
+		PROCEDURE ^ SetPosX*(seekType: LONGINT; pos: LONGINT; VAR itemSize: LONGINT; VAR res: LONGINT); 
+	END DemuxStream; 
+
+	AudioDecoder* = OBJECT 
+
+		PROCEDURE ^ Open*(in: Streams.Reader; VAR res: LONGINT); 
+		PROCEDURE ^ HasMoreData*(): BOOLEAN; 
+		PROCEDURE ^ GetAudioInfo*(VAR nofChannels, samplesPerSecond, bitsPerSample: LONGINT); 
+		PROCEDURE ^ SetAudioInfo*(nofChannels, samplesPerSecond, bitsPerSample: LONGINT); 
+		PROCEDURE ^ CanSeek*(): BOOLEAN; 
+		PROCEDURE ^ GetCurrentSample*(): LONGINT; 
+		PROCEDURE ^ GetTotalSamples*(): LONGINT; 
+		PROCEDURE ^ GetCurrentTime*(): LONGINT; 
+		PROCEDURE ^ SetStreamLength*(length: LONGINT); 
+		PROCEDURE ^ SeekSample*(sample: LONGINT; goKeySample: BOOLEAN; VAR res: LONGINT); 
+		PROCEDURE ^ SeekMillisecond*(millisecond: LONGINT; goKeySample: BOOLEAN; VAR res: LONGINT); 
+		PROCEDURE ^ Next*; 
+		PROCEDURE ^ FillBuffer*(buffer: SoundDevices.Buffer); 
+	END AudioDecoder; 
+
+	AudioEncoder* = OBJECT 
+
+		PROCEDURE ^ Open*(out: Streams.Writer; sRate, sRes, nofCh: LONGINT; VAR res: LONGINT); 
+		PROCEDURE ^ Write*(buffer: SoundDevices.Buffer; VAR res: LONGINT); 
+		PROCEDURE ^ Close*(VAR res: LONGINT); 
+	END AudioEncoder; 
+
+	VideoDecoder* = OBJECT 
+
+		PROCEDURE ^ Open*(in: Streams.Reader; VAR res: LONGINT); 
+		PROCEDURE ^ HasMoreData*(): BOOLEAN; 
+		PROCEDURE ^ GetVideoInfo*(VAR width, height, millisecondsPerFrame: LONGINT); 
+		PROCEDURE ^ CanSeek*(): BOOLEAN; 
+		PROCEDURE ^ GetCurrentFrame*(): LONGINT; 
+		PROCEDURE ^ GetCurrentTime*(): LONGINT; 
+		PROCEDURE ^ SeekFrame*(frame: LONGINT; goKeyFrame: BOOLEAN; VAR res: LONGINT); 
+		PROCEDURE ^ SeekMillisecond*(millisecond: LONGINT; goKeyFrame: BOOLEAN; VAR res: LONGINT); 
+		PROCEDURE ^ Next*; 
+		PROCEDURE ^ Render*(img: Raster.Image); 
+	END VideoDecoder; 
+
+	ImageDecoder* = OBJECT 
+
+		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 ImageDecoder; 
+
+	ImageEncoder* = OBJECT 
+
+		PROCEDURE ^ Open*(out: Streams.Writer); 
+		PROCEDURE ^ SetQuality*(quality: LONGINT); 
+		PROCEDURE ^ WriteImage*(img: Raster.Image; VAR res: LONGINT); 
+	END ImageEncoder; 
+
+	TextDecoder* = OBJECT 
+
+		PROCEDURE ^ Open*(in: Streams.Reader; VAR res: LONGINT); 
+		PROCEDURE ^ GetText*(): Texts.Text; 
+	END TextDecoder; 
+
+	TextEncoder* = OBJECT 
+
+		PROCEDURE ^ Open*(out: Streams.Writer); 
+		PROCEDURE ^ WriteText*(text: Texts.Text; VAR res: LONGINT); 
+	END TextEncoder; 
+
+	CryptoDecoder* = OBJECT 
+
+		PROCEDURE ^ Open*(in: Streams.Reader; VAR res: LONGINT); 
+		PROCEDURE ^ GetReader*(): Streams.Reader; 
+	END CryptoDecoder; 
+
+	CryptoEncoder* = OBJECT 
+
+		PROCEDURE ^ Open*(out: Streams.Writer); 
+		PROCEDURE ^ GetWriter*(): Streams.Writer; 
+	END CryptoEncoder; 
+
+	ImageDescriptor* = OBJECT 
+	VAR 
+		left*, top*, width*, height*: LONGINT; 
+		image*: Raster.Image; 
+		delayTime*: LONGINT; 
+		disposeMode*: LONGINT; 
+		flags*: SET; 
+		previous*, next*: ImageDescriptor; 
+
+		PROCEDURE ^  & Init*; 
+	END ImageDescriptor; 
+
+	ImageSequence* = RECORD 
+		width*, height*: LONGINT; 
+		bgColor*: LONGINT; 
+		images*: ImageDescriptor; 
+	END; 
+
+	AnimationDecoder* = OBJECT 
+
+		PROCEDURE ^ Open*(in: Streams.Reader; VAR res: LONGINT); 
+		PROCEDURE ^ GetImageSequence*(VAR sequence: ImageSequence; VAR res: LONGINT); 
+	END AnimationDecoder; 
+
+	DemuxFactory = PROCEDURE ():AVDemultiplexer; 
+
+	AudioDecoderFactory = PROCEDURE ():AudioDecoder; 
+
+	AudioEncoderFactory = PROCEDURE ():AudioEncoder; 
+
+	VideoDecoderFactory = PROCEDURE ():VideoDecoder; 
+
+	ImageDecoderFactory = PROCEDURE ():ImageDecoder; 
+
+	ImageEncoderFactory = PROCEDURE ():ImageEncoder; 
+
+	TextDecoderFactory = PROCEDURE ():TextDecoder; 
+
+	TextEncoderFactory = PROCEDURE ():TextEncoder; 
+
+	CryptoDecoderFactory = PROCEDURE ():CryptoDecoder; 
+
+	CryptoEncoderFactory = PROCEDURE ():CryptoEncoder; 
+
+	AnimationDecoderFactory = PROCEDURE ():AnimationDecoder; 
+
+	PROCEDURE ^ GetDemuxFactoryName(CONST name: ARRAY OF CHAR; VAR module, procedure: Modules.Name; VAR res: LONGINT); 
+	PROCEDURE ^ GetDecoderFactoryName(CONST type, name: ARRAY OF CHAR; VAR module, procedure: Modules.Name; VAR res: LONGINT); 
+	PROCEDURE ^ GetEncoderFactoryName(CONST type, name: ARRAY OF CHAR; VAR module, procedure: Modules.Name; VAR res: LONGINT); 
+	PROCEDURE ^ GetDemultiplexer*(CONST name: ARRAY OF CHAR): AVDemultiplexer; 
+	PROCEDURE ^ GetImageDecoder*(CONST name: ARRAY OF CHAR): ImageDecoder; 
+	PROCEDURE ^ GetImageEncoder*(CONST name: ARRAY OF CHAR): ImageEncoder; 
+	PROCEDURE ^ GetVideoDecoder*(CONST name: ARRAY OF CHAR): VideoDecoder; 
+	PROCEDURE ^ GetAudioDecoder*(CONST name: ARRAY OF CHAR): AudioDecoder; 
+	PROCEDURE ^ GetAudioEncoder*(CONST name: ARRAY OF CHAR): AudioEncoder; 
+	PROCEDURE ^ GetTextDecoder*(CONST name: ARRAY OF CHAR): TextDecoder; 
+	PROCEDURE ^ GetTextEncoder*(CONST name: ARRAY OF CHAR): TextEncoder; 
+	PROCEDURE ^ GetCryptoDecoder*(CONST name: ARRAY OF CHAR): CryptoDecoder; 
+	PROCEDURE ^ GetCryptoEncoder*(CONST name: ARRAY OF CHAR): CryptoEncoder; 
+	PROCEDURE ^ GetAnimationDecoder*(CONST name: ARRAY OF CHAR): AnimationDecoder; 
+	PROCEDURE ^ SplitName*(CONST name: ARRAY OF CHAR; VAR protocol, filename: ARRAY OF CHAR); 
+	PROCEDURE ^ JoinName*(CONST protocol, filename: ARRAY OF CHAR; VAR name: ARRAY OF CHAR); 
+	PROCEDURE ^ OpenInputStream*(CONST name: ARRAY OF CHAR): Streams.Reader; 
+	PROCEDURE ^ OpenOutputStream*(CONST name: ARRAY OF CHAR): Streams.Writer; 
+BEGIN
+END Codecs.

Linux64G/bin/ColorModels.SymUu

@@ -0,0 +1,10 @@
+MODULE ColorModels;
+
+	PROCEDURE ^ RGBToHSV*(r, g, b: LONGINT; VAR h, s, v: REAL); 
+	PROCEDURE ^ HSVToRGB*(h, s, v: REAL; VAR rl, gl, bl: LONGINT); 
+	PROCEDURE ^ RGBToCMY*(r, g, b: REAL; VAR c, m, y: REAL); 
+	PROCEDURE ^ CMYToRGB*(c, m, y: REAL; VAR r, g, b: LONGINT); 
+	PROCEDURE ^ RGBToCMYK*(rl, gl, bl: LONGINT; VAR c, m, y, k: REAL); 
+	PROCEDURE ^ CMYKToRGB*(c, m, y, k: REAL; VAR r, g, b: REAL); 
+BEGIN
+END ColorModels.

Linux64G/bin/Commands.SymUu

@@ -0,0 +1,77 @@
+MODULE Commands;
+	IMPORT Objects, Modules, Streams, KernelLog, Trace, Machine;
+CONST 
+	Wait* = 0; 
+	InheritContext* = 1; 
+	Silent* = 2; 
+	Ok* = 0; 
+	CommandNotFound* = 3901; 
+	CommandError* = 3902; 
+	CommandParseError* = 3903; 
+	CommandTrapped* = 3904; 
+	Delimiter* = \"."\; 
+	Started = 0; 
+	Loaded = 1; 
+	Finished = 2; 
+TYPE 
+	Context* = OBJECT 
+	VAR 
+		in-, arg-: Streams.Reader; 
+		out-, error-: Streams.Writer; 
+		caller-: OBJECT; 
+		result*: LONGINT; 
+
+		PROCEDURE ^  & Init*(in, arg: Streams.Reader; out, error: Streams.Writer; caller: OBJECT); 
+	END Context; 
+
+	ReaderMonitor* = OBJECT (Streams.Reader)
+	VAR 
+		in: Streams.Reader; 
+		tracer: Streams.Writer; 
+		pos0: LONGINT; 
+		tracedPos: LONGINT; 
+
+		PROCEDURE ^  & Init(in: Streams.Reader; tracer: Streams.Writer); 
+		PROCEDURE ^ Receiver(VAR buf: ARRAY OF CHAR; ofs, size, min: LONGINT; VAR len, res: LONGINT); 
+		PROCEDURE ^ CanSetPos*(): BOOLEAN; 
+		PROCEDURE ^ SetPos*(pos: LONGINT); 
+		PROCEDURE ^ Pos*(): LONGINT; 
+	END ReaderMonitor; 
+
+	CommandProc = PROCEDURE ; 
+
+	CommandContextProc = PROCEDURE (context: Context); 
+
+	Runner = OBJECT {EXCLUSIVE} 
+	VAR 
+		moduleName, commandName: Modules.Name; 
+		context: Context; 
+		tracer: Streams.Writer; 
+		r: ReaderMonitor; 
+		proc: CommandProc; 
+		commandProc: CommandContextProc; 
+		msg: ARRAY 128 OF CHAR; 
+		res: LONGINT; 
+		module: Modules.Module; 
+		state: LONGINT; 
+		exception: BOOLEAN; 
+
+		PROCEDURE ^  & Init*(CONST moduleName, commandName: Modules.Name; context: Context); 
+		PROCEDURE ^ Join(this: LONGINT; VAR res: LONGINT; VAR msg: ARRAY OF CHAR); 
+	BEGIN{ACTIVE, SAFE} 
+	END Runner; 
+VAR 
+	emptyString: ARRAY 1 OF CHAR; 
+	silentWriter: Streams.Writer; 
+	trace: BOOLEAN; 
+	defaultContext: Context; 
+
+	PROCEDURE ^ GetEmptyReader(): Streams.Reader; 
+	PROCEDURE ^ SendNothing(CONST buf: ARRAY OF CHAR; ofs, len: LONGINT; propagate: BOOLEAN; VAR res: LONGINT); 
+	PROCEDURE ^ Split*(CONST cmdstr: ARRAY OF CHAR; VAR moduleName, procedureName: Modules.Name; VAR res: LONGINT; VAR msg: ARRAY OF CHAR); 
+	PROCEDURE ^ GetContext*(): Context; 
+	PROCEDURE ^ Activate*(CONST cmd: ARRAY OF CHAR; context: Context; flags: SET; VAR res: LONGINT; VAR msg: ARRAY OF CHAR); 
+	PROCEDURE ^ Call*(cmds: ARRAY OF CHAR; flags: SET; VAR res: LONGINT; VAR msg: ARRAY OF CHAR); 
+	PROCEDURE ^ Init; 
+BEGIN
+END Commands.

Linux64G/bin/Compiler.SymUu

@@ -0,0 +1,51 @@
+MODULE Compiler;
+	IMPORT Basic := FoxBasic, Scanner := FoxScanner, Parser := FoxParser, SemanticChecker := FoxSemanticChecker, SyntaxTree := FoxSyntaxTree, Formats := FoxFormats, Streams, Commands, Diagnostics, Options, Kernel, Printout := FoxPrintout, Backend := FoxBackend, Strings, Global := FoxGlobal, Frontend := FoxFrontend, Files, Machine;
+CONST 
+	Print* = 0; 
+	Silent* = 1; 
+	Check* = 2; 
+	TraceError* = 3; 
+	Info* = 4; 
+	FindPC* = 5; 
+	Warnings* = 7; 
+	ForceModuleBodies* = 8; 
+	UseDarwinCCalls* = 9; 
+	SingleModule* = 10; 
+	Oberon07* = 11; 
+	ChangeCase* = 12; 
+	Cooperative* = 13; 
+	CellsAreObjects* = 14; 
+	UseLineNumbers* = 15; 
+	DefaultBackend = \"AMD"\; 
+	DefaultFrontend = \"Oberon"\; 
+TYPE 
+	SectionName = ARRAY 256 OF CHAR; 
+
+	CompilerOptions* = RECORD 
+		flags*: SET; 
+		frontend*: Frontend.Frontend; 
+		backend*: Backend.Backend; 
+		symbolFile*: Formats.SymbolFileFormat; 
+		objectFile*: Formats.ObjectFileFormat; 
+		findPC*: SectionName; 
+		documentation*: Backend.Backend; 
+		srcPath, destPath: Files.FileName; 
+		replacements: SemanticChecker.Replacement; 
+	END; 
+VAR 
+	platforms: Options.Defaults; 
+	defaultPlatform: ARRAY 32 OF CHAR; 
+
+	PROCEDURE ^ ParseReplacements(CONST filename: ARRAY OF CHAR; VAR replacement: SemanticChecker.Replacement; diagnostics: Diagnostics.Diagnostics): BOOLEAN; 
+	PROCEDURE ^ Modules*(CONST source: ARRAY OF CHAR; reader: Streams.Reader; position: LONGINT; diagnostics: Diagnostics.Diagnostics; log: Streams.Writer; CONST options: CompilerOptions; VAR importCache: SyntaxTree.ModuleScope): BOOLEAN; 
+	PROCEDURE ^ GetOptions*(input: Streams.Reader; error: Streams.Writer; diagnostics: Diagnostics.Diagnostics; VAR compilerOptions: CompilerOptions): BOOLEAN; 
+	PROCEDURE ^ Compile*(context: Commands.Context); 
+	PROCEDURE ^ CompileReader*(context: Commands.Context; reader: Streams.Reader); 
+	PROCEDURE ^ DoAddPlatform(CONST name: ARRAY OF CHAR; CONST defaults: ARRAY OF CHAR); 
+	PROCEDURE ^ ShowDefaults*(context: Commands.Context); 
+	PROCEDURE ^ AddPlatform*(context: Commands.Context); 
+	PROCEDURE ^ SetDefaultPlatform*(context: Commands.Context); 
+	PROCEDURE ^ GetDefaultPlatform(VAR name: ARRAY OF CHAR): BOOLEAN; 
+	PROCEDURE ^ SetupDefaults; 
+BEGIN
+END Compiler.

Linux64G/bin/CompilerInterface.SymUu

@@ -0,0 +1,37 @@
+MODULE CompilerInterface;
+	IMPORT KernelLog, Streams, Commands, Strings, Texts, Diagnostics;
+CONST 
+	ModuleName = \"CompilerInterface"\; 
+TYPE 
+	Name* = ARRAY 16 OF CHAR; 
+
+	Description* = ARRAY 128 OF CHAR; 
+
+	FileExtension* = ARRAY 16 OF CHAR; 
+
+	CompileTextProc* = PROCEDURE {DELEGATE}(t: Texts.Text; CONST source: ARRAY OF CHAR; pos: LONGINT; CONST pc, opt: ARRAY OF CHAR; log: Streams.Writer; diagnostics: Diagnostics.Diagnostics; VAR error: BOOLEAN); 
+
+	Compiler* = OBJECT 
+	VAR 
+		name-: Name; 
+		description-: Description; 
+		fileExtension-: FileExtension; 
+		compileText: CompileTextProc; 
+		next: Compiler; 
+
+		PROCEDURE ^ CompileText*(t: Texts.Text; CONST source: ARRAY OF CHAR; pos: LONGINT; CONST pc, opt: ARRAY OF CHAR; log: Streams.Writer; diagnostics: Diagnostics.Diagnostics; VAR error: BOOLEAN); 
+		PROCEDURE ^ Show(out: Streams.Writer); 
+		PROCEDURE ^  & Init*(CONST name: Name; CONST description: Description; CONST fileExtension: FileExtension; compileText: CompileTextProc); 
+	END Compiler; 
+VAR 
+	compilers: Compiler; 
+
+	PROCEDURE ^ FindCompilerByName(CONST name: ARRAY OF CHAR): Compiler; 
+	PROCEDURE ^ GetCompiler*(fileExtension: FileExtension): Compiler; 
+	PROCEDURE ^ GetCompilerByName*(CONST name: ARRAY OF CHAR): Compiler; 
+	PROCEDURE ^ GetCompilerByFilename*(filename: ARRAY OF CHAR): Compiler; 
+	PROCEDURE ^ Show*(context: Commands.Context); 
+	PROCEDURE ^ Register*(CONST name: Name; CONST description: Description; fileExtension: FileExtension; compileText: CompileTextProc); 
+	PROCEDURE ^ Unregister*(CONST name: Name); 
+BEGIN
+END CompilerInterface.

Linux64G/bin/ComplexNumbers.SymUu

@@ -0,0 +1,25 @@
+MODULE ComplexNumbers;
+	IMPORT Math, MathL;
+
+	OPERATOR ^ "+"-(CONST left, right: COMPLEX): COMPLEX; 
+	OPERATOR ^ "+"-(CONST left, right: LONGCOMPLEX): LONGCOMPLEX; 
+	OPERATOR ^ "-"-(CONST left, right: COMPLEX): COMPLEX; 
+	OPERATOR ^ "-"-(CONST left, right: LONGCOMPLEX): LONGCOMPLEX; 
+	OPERATOR ^ "*"-(CONST left, right: COMPLEX): COMPLEX; 
+	OPERATOR ^ "*"-(CONST left, right: LONGCOMPLEX): LONGCOMPLEX; 
+	OPERATOR ^ "/"-(CONST left, right: COMPLEX): COMPLEX; 
+	OPERATOR ^ "/"-(CONST left, right: LONGCOMPLEX): LONGCOMPLEX; 
+	OPERATOR ^ "ABS"-(CONST arg: COMPLEX): REAL; 
+	OPERATOR ^ "ABS"-(CONST arg: LONGCOMPLEX): LONGREAL; 
+	OPERATOR ^ "~"-(CONST left: COMPLEX): COMPLEX; 
+	OPERATOR ^ "~"-(CONST left: LONGCOMPLEX): LONGCOMPLEX; 
+	OPERATOR ^ "<="-(CONST x, y: COMPLEX): BOOLEAN; 
+	OPERATOR ^ ">="-(CONST x, y: COMPLEX): BOOLEAN; 
+	OPERATOR ^ "<"-(CONST x, y: COMPLEX): BOOLEAN; 
+	OPERATOR ^ ">"-(CONST x, y: COMPLEX): BOOLEAN; 
+	OPERATOR ^ "<="-(CONST x, y: LONGCOMPLEX): BOOLEAN; 
+	OPERATOR ^ ">="-(CONST x, y: LONGCOMPLEX): BOOLEAN; 
+	OPERATOR ^ "<"-(CONST x, y: LONGCOMPLEX): BOOLEAN; 
+	OPERATOR ^ ">"-(CONST x, y: LONGCOMPLEX): BOOLEAN; 
+BEGIN
+END ComplexNumbers.

Linux64G/bin/ComponentInfo.SymUu

@@ -0,0 +1,23 @@
+MODULE ComponentInfo;
+	IMPORT Streams, Commands, Strings, KernelLog, XML, XMLObjects, WMWindowManager, WMProperties, WMEvents, WMComponents;
+CONST 
+	MaxNofWindows = 100; 
+TYPE 
+	Windows = ARRAY MaxNofWindows OF WMWindowManager.Window; 
+
+	Statistics = OBJECT 
+	VAR 
+		nofComponents, nofVisualComponents, nofOtherElements, nofEventSources, nofEventListeners: LONGINT; 
+		nofBooleanProperties, nofInt32Properties, nofColorProperties, nofRectangleProperties, nofStringProperties, nofOtherProperties: LONGINT; 
+
+		PROCEDURE ^  & Reset; 
+		PROCEDURE ^ Add(stats: Statistics); 
+		PROCEDURE ^ Show(out: Streams.Writer); 
+	END Statistics; 
+
+	PROCEDURE ^ DumpComponent*(obj: ANY; out: Streams.Writer); 
+	PROCEDURE ^ GatherStatistics*(component: XML.Element; stats: Statistics); 
+	PROCEDURE ^ ShowStatistics*(context: Commands.Context); 
+	PROCEDURE ^ ShowPrototypes*(context: Commands.Context); 
+BEGIN
+END ComponentInfo.

Linux64G/bin/ComponentViewer.SymUu

@@ -0,0 +1,40 @@
+MODULE ComponentViewer;
+	IMPORT Modules, Commands, Options, XML, Repositories, WMMessages, WMWindowManager, WMComponents, WMRestorable, Streams, D := Debugging, Files, WMRectangles, WMGraphicsSmooth;
+CONST 
+	DefaultWidth = 320; 
+	DefaultHeight = 240; 
+	InvalidPosition* = MIN(LONGINT); 
+	FlagMoveable* = 20; 
+	FlagSmoothGraphics* = 21; 
+TYPE 
+	KillerMsg = OBJECT 
+	END KillerMsg; 
+
+	Window* = OBJECT {EXCLUSIVE} (WMComponents.FormWindow)
+	VAR 
+		dragging: BOOLEAN; 
+		lastX, lastY: LONGINT; 
+
+		PROCEDURE ^ RestoreWindow*(c: WMRestorable.Context); 
+		PROCEDURE ^  & InitWindow(width, height: LONGINT; alpha: BOOLEAN); 
+		PROCEDURE ^ Close*; 
+		PROCEDURE ^ Handle*(VAR m: WMMessages.Message); 
+		PROCEDURE ^ PointerDown*(x, y: LONGINT; keys: SET); 
+		PROCEDURE ^ PointerMove*(x, y: LONGINT; keys: SET); 
+		PROCEDURE ^ PointerUp*(x, y: LONGINT; keys: SET); 
+	END Window; 
+VAR 
+	nofWindows: LONGINT; 
+
+	PROCEDURE ^ DoShow*(vc: WMComponents.VisualComponent; VAR window: Window; x, y, width, height: LONGINT; client, alpha, fullscreen: BOOLEAN; flags: SET); 
+	PROCEDURE ^ DoLoad*(CONST filename: ARRAY OF CHAR; error: Streams.Writer): WMComponents.VisualComponent; 
+	PROCEDURE ^ DoOpen*(CONST filename: ARRAY OF CHAR; error: Streams.Writer; x, y, width, height: LONGINT; client, alpha, fullscreen: BOOLEAN; flags: SET): WMComponents.VisualComponent; 
+	PROCEDURE ^ SetProperties(c: WMComponents.Component; CONST attr: ARRAY OF CHAR); 
+	PROCEDURE ^ Open*(context: Commands.Context); 
+	PROCEDURE ^ Store*(context: Commands.Context); 
+	PROCEDURE ^ Restore*(context: WMRestorable.Context); 
+	PROCEDURE ^ IncCount; 
+	PROCEDURE ^ DecCount; 
+	PROCEDURE ^ Cleanup; 
+BEGIN
+END ComponentViewer.

Linux64G/bin/Configuration.SymUu

@@ -0,0 +1,36 @@
+MODULE Configuration;
+	IMPORT KernelLog, Strings, Files, XMLObjects, XML, XMLScanner, XMLParser;
+CONST 
+	Ok* = 0; 
+	ElementNotFound* = 10001; 
+	AttributeNotFound* = 10002; 
+	WrongType* = 10003; 
+	Error* = 10004; 
+	SaveConfigFile = \"Save.Configuration.XML"\; 
+	MyConfigFile = \"MyConfiguration.XML"\; 
+	ConfigFile = \"Configuration.XML"\; 
+	Section = \"Section"\; 
+	Setting = \"Setting"\; 
+	NameAttr = \"name"\; 
+	ValueAttr = \"value"\; 
+VAR 
+	config*: XML.Document; 
+	error: BOOLEAN; 
+
+	PROCEDURE ^ GetNamedElement*(parent: XML.Element; CONST type, name: ARRAY OF CHAR): XML.Element; 
+	PROCEDURE ^ GetSection*(CONST key: ARRAY OF CHAR): XML.Element; 
+	PROCEDURE ^ GetSetting*(CONST key: ARRAY OF CHAR): XML.Element; 
+	PROCEDURE ^ GetElementX(CONST type, key: ARRAY OF CHAR): XML.Element; 
+	PROCEDURE ^ Get*(CONST key: ARRAY OF CHAR; VAR val: ARRAY OF CHAR; VAR res: LONGINT); 
+	PROCEDURE ^ GetBoolean*(CONST key: ARRAY OF CHAR; VAR value: BOOLEAN; VAR res: LONGINT); 
+	PROCEDURE ^ GetColor*(CONST key: ARRAY OF CHAR; VAR value: LONGINT; VAR res: LONGINT); 
+	PROCEDURE ^ GetInteger*(CONST key: ARRAY OF CHAR; VAR value: LONGINT; VAR res: LONGINT); 
+	PROCEDURE ^ Put*(CONST key, val: ARRAY OF CHAR; VAR res: LONGINT); 
+	PROCEDURE ^ PutBoolean*(CONST key: ARRAY OF CHAR; value: BOOLEAN; VAR res: LONGINT); 
+	PROCEDURE ^ PutColor*(CONST key: ARRAY OF CHAR; value: LONGINT; VAR res: LONGINT); 
+	PROCEDURE ^ PutInteger*(CONST key: ARRAY OF CHAR; value: LONGINT; VAR res: LONGINT); 
+	PROCEDURE ^ WriteConfig; 
+	PROCEDURE ^ TrapHandler(pos, line, row: LONGINT; CONST msg: ARRAY OF CHAR); 
+	PROCEDURE ^ Init*; 
+BEGIN
+END Configuration.