LTCD_060719.ISO
This commit is contained in:
Terry A. Davis authored and minexew committed
commit
f86e69648b
156 files changed
+49537
No files matched your search
@@ -0,0 +1,8 @@
|
||||
extern U8i SysEcho(U8i val);
|
||||
SysEcho(0); //0=echo OFF 1=echo ON
|
||||
#include "/LT/OSMain/ADAMK.HPZ"
|
||||
#include "/LT/OSMain/ADAMK2.HPZ"
|
||||
#include "/LT/OSMain/ADAMK3.HPZ"
|
||||
#include "/LT/COMPILE/CMP.HPZ"
|
||||
Cd("/LT/ADAM");;
|
||||
#include "ADAM2"
|
||||
+2336
File diff suppressed because it is too large.
Load diff
Binary file not shown.
@@ -0,0 +1,290 @@
|
||||
extern SysAccntStruct sys_accounts;
|
||||
public extern TssStruct *adam_tss;
|
||||
public extern U4 num_spawned_users;
|
||||
extern TssCmdStruct sys_macro_queue;
|
||||
extern TssStruct *macro_util_tss;
|
||||
public extern U1 *grfont;
|
||||
extern U4 *vga_image;
|
||||
|
||||
extern U4 FDC_retries;
|
||||
extern U4 FDC_DRIVE_HEADS;
|
||||
extern U4 FDC_DISK_CYLINDERS;
|
||||
extern U4 FDC_DISK_SECTORS;
|
||||
extern U4 FDC_MAX_SECTOR;
|
||||
extern U4 FDC_DMA_BUF;
|
||||
extern LTCacheBlk *LTDCBase;
|
||||
extern LTCacheBlk *LTDCNext_lru,*LTDCLast_lru;
|
||||
extern LTCacheBlk **LTDCHashTable;
|
||||
public extern void LTDCInitCache(U8 size_in_U1s);
|
||||
|
||||
extern U8 sys_timer,jiffies;
|
||||
extern U8 rnd_SEED;
|
||||
extern I1 sys_temp_filename[80];
|
||||
extern U8 disk_status_display,compiled_lines;
|
||||
public extern Ltf *sys_clipboard_ltf;
|
||||
public extern I8 num_blkdevs;
|
||||
extern I1 *sys_startup_account;
|
||||
extern I1 *wordstat_mask;
|
||||
extern BoolU4 ip_inhibit_win_operations;
|
||||
public extern I1 *sys_compile_time;
|
||||
|
||||
public extern void PortNop();
|
||||
public extern void BusyWait(U8 uS); //Loosely timed
|
||||
|
||||
//49,710Hz since boot (LTDATE_FREQ)
|
||||
public extern LTDate BootTime();
|
||||
//18.33333*65536Hz (SYS_TIMER_FREQ)
|
||||
public extern U8 ReadSysTimer();
|
||||
|
||||
|
||||
extern void KbdCmdSend(U8 port, U1 val);
|
||||
extern I8 KbdCmdRead();
|
||||
extern void KbdCmdFlush();
|
||||
extern void KbdMouseCmdAck(U1 val);
|
||||
|
||||
public extern U8 RandU2();
|
||||
public extern U8 RandU4();
|
||||
public extern U8 DivU8(U8 n1,U8 n2);
|
||||
public extern I8 DivI8(I8 n1,I8 n2);
|
||||
public extern U8 ModU8(U8 n1,U8 n2);
|
||||
public extern I8 ModI8(I8 n1,I8 n2);
|
||||
public extern I8 AtoI(I1 *st,I8 radix=10,I1 **end_ptr=NULL);
|
||||
public extern void Sleep(U8 mS);
|
||||
public extern void Sound(U8 freq);
|
||||
public extern void Beep(U8 freq=500,BoolU4 busy=FALSE);
|
||||
public extern U8 GetS(I1 *buf,U8 size);
|
||||
public extern BoolU4 YorN();
|
||||
public extern void D(U1 *buf,U8 cnt=0x80,BoolU4 show_offset=TRUE);
|
||||
public extern void Dm(U1 *buf,U8 cnt=0x80);
|
||||
|
||||
public extern I8 ToUpper(I8 ch);
|
||||
public extern BoolU4 AssignBit(U1 *field,U8 bit,BoolU4 val);
|
||||
public extern BoolU4 Externs2Imports(BoolU4 val);
|
||||
public extern BoolU4 KeepPrivate(BoolU4 val);
|
||||
public extern BoolU4 PTrace(BoolU4 val);
|
||||
public extern BoolU4 OTrace(BoolU4 val);
|
||||
public extern BoolU4 NoRegVar(BoolU4 val);
|
||||
public extern BoolU4 CTrace(BoolU4 val);
|
||||
public extern BoolU4 LTrace(BoolU4 val);
|
||||
public extern BoolU4 Echo(BoolU4 val);
|
||||
public extern BoolU4 Silent(BoolU4 val);
|
||||
public extern BoolU4 Preempt(BoolU4 val);
|
||||
public extern BoolU4 SysDbg(BoolU4 val);
|
||||
public extern BoolU4 IsSysDbg();
|
||||
public extern BoolU4 Raw(BoolU4 val);
|
||||
public extern BoolU4 IsRaw();
|
||||
public extern U1 *Caller();
|
||||
public extern U1 *CallerCaller();
|
||||
public extern void DbgStr(I1 *st,U8 mS=100);
|
||||
public extern void DbgNum(U8 num,U8 mS=100);
|
||||
public extern void DbgF(double d,U8 mS=100);
|
||||
public extern void DbgAdd(U4 *add,U8 mS=100);
|
||||
public extern void DbgD(U4 *add,U8 cnt=0x80,U8 mS=100);
|
||||
public extern void DbgDm(U4 *add,U8 cnt=0x80,U8 mS=100);
|
||||
extern void ThrowDivide(U1 *eip);
|
||||
extern void ThrowFloating(U1 *eip);
|
||||
|
||||
public extern SysHashEntry *FindLocalHash(I1 *st,U8 mask);
|
||||
public extern void GrClear(GrBitMap *base=NULL);
|
||||
public extern GrBitMap *GrBitMapNew(U8 type,U8 width,U8 height);
|
||||
public extern void CursorHome();
|
||||
public extern void CursorOn();
|
||||
public extern void CursorOff();
|
||||
public extern void ClearWindowText();
|
||||
public extern void InitCrt();
|
||||
public extern void PutChar(I1 ch);
|
||||
public extern void PutS(I1 *st);
|
||||
public extern U1 *AMAlloc(U8 size);
|
||||
public extern void AFree(U1 *add);
|
||||
public extern U1 *AMAllocIdentical(U1 *src);
|
||||
public extern U1 *MAllocIdentical(U1 *src,TssStruct *tss=NULL);
|
||||
public extern I1 *ANewString(I1 *buf);
|
||||
public extern I1 *NewString(I1 *buf,TssStruct *tss=NULL);
|
||||
public extern U1 *AMAllocZ(U8 size);
|
||||
public extern U1 *MAllocZ(U8 size,TssStruct *tss=NULL);
|
||||
public extern void DelLinkedList(U4 *list);
|
||||
public extern void Exit();
|
||||
public extern void Kill(TssStruct *tss);
|
||||
|
||||
//Exceptions are thrown through the following funcation call.
|
||||
//by convention, the first parameter should be a type code.
|
||||
public extern U8 ExceptDepth(TssStruct *tss=NULL);
|
||||
public extern void throw(...);
|
||||
//The following are used internally and should not be called directly
|
||||
extern void SysTry(U1 *start_label,U1 *skip_label,U8 my_ebp,U8 my_esp);
|
||||
extern void SysCatch();
|
||||
|
||||
public extern void ArcCompressBuf(ArcCs *c);
|
||||
public extern void ArcFinishCompression(ArcCs *c);
|
||||
public extern void ArcExpandBuf(ArcCs *c);
|
||||
public extern ArcCs *NewArcCs(BoolU4 expand,BoolU4 text_only);
|
||||
public extern void DelArcCs(ArcCs *c);
|
||||
public extern ArcCompressStruct *
|
||||
CompressBuf(U1 *src,U8 size,U8 flags=0);
|
||||
public extern U1 *ExpandBuf(ArcCompressStruct *r);
|
||||
|
||||
|
||||
public extern SysHashEntry *LoadStr(I1 *name, I1 *st);
|
||||
public extern SysHashEntry *LoadList(I1 *name, I1 *st);
|
||||
public extern I1 *SysText(I1 *name);
|
||||
public extern I1 *SysTextSub(U8 sub,I1 *name);
|
||||
public extern I8 SysTextSubCount(I1 *name);
|
||||
public extern void Beeps(U8 j,BoolU4 busy);
|
||||
public extern void UnrecoverableSysError(U8 j);
|
||||
public extern void PutSysText(I1 *name);
|
||||
public extern SysHashEntry *FindPSect(U1 *add,I8 *offset);
|
||||
|
||||
public extern I1 *PointAtListEntry(I8 entry_number, I1 *lst);
|
||||
public extern I8 MatchListEntry(I1 *src, I1 *lst,I8 flags=0,I8 *ambiguity_overkill_ptr=NULL);
|
||||
public extern I8 MatchSysTextEntry(I1 *src, I1 *lst_name,I8 flags=0,I8 *ambiguity_overkill_ptr=NULL);
|
||||
public extern I8 Occurrences(I1 *src, I1 ch);
|
||||
public extern I8 SpacesToTabs(I1 *dst,I1 *src);
|
||||
public extern I1 *TabsToSpaces(I1 *src);
|
||||
public extern I1 *StringUtil(I1 *u, I8 mask);
|
||||
public extern I1 *MStringUtil(I1 *u,U8 flags);
|
||||
public extern I1 *RemoveFirstSeg(I1 *src, I1 *marker, I1 *dst);
|
||||
public extern I1 *RemoveLastSeg(I1 *src, I1 *marker, I1 *dst);
|
||||
public extern BoolU4 WildCardMatch(I1 *wild_st,I1 *src_st);
|
||||
public extern BoolU4 WildFileNameList(I1 *wild_st,I1 *src_st);
|
||||
public extern I1 *Add2String(I1 *base,I1 *addition); //frees base parameter
|
||||
public extern I1 *SearchString(I1 *src,I1 *pattern,U8 flags=0);
|
||||
|
||||
public extern I1 *SPrintFJoin(I1 *dst,I1 *fmt,I8i argc,I8i *argv);
|
||||
public extern void GetFJoin(I1 *src,I1 *fmt,I8i argc,I8i *argv);
|
||||
public extern void SPrintF(I1 *dst,I1 *fmt,...);
|
||||
public extern void PrintF(I1 *fmt,...);
|
||||
public extern I1 *MSPrintF(I1 *fmt,...);
|
||||
public extern void Adam(I1 *fmt,...);
|
||||
public extern void AdamLog(I1 *fmt,...);
|
||||
public extern void AdamErr(I1 *fmt,...);
|
||||
public extern U8 System(I1 *fmt,...);
|
||||
public extern U8 ServantUser(I1 *fmt,...);
|
||||
public extern void XTalk(TssStruct *tss,I1 *fmt,...);
|
||||
public extern void XTalkString(TssStruct *tss,I1 *fmt,...);
|
||||
public extern void Auto(I1 *fmt,...);
|
||||
public extern void AutoString(I1 *fmt,...);
|
||||
public extern void AutoFile(I1 *filename);
|
||||
public extern void GetF(I1 *src,I1 *fmt,...);
|
||||
|
||||
public extern void QSort(void *base,U8 num, U8 width, U1 *compare);
|
||||
|
||||
public extern I4 YearStartDate(I4 year);
|
||||
public extern LTDate ToLTDate(LTDateStruct *d);
|
||||
public extern void ToLTDateStruct(LTDateStruct *d,LTDate ltdt);
|
||||
public extern I4 FirstDayOfMonth(I4 i);
|
||||
public extern I4 LastDayOfMonth(I4 i);
|
||||
public extern I4 FirstDayOfYear(I4 i);
|
||||
public extern I4 LastDayOfYear(I4 i);
|
||||
public extern U1 DayOfWeek(I4 i);
|
||||
public extern void GetCurTimeLTDateStruct(LTDateStruct *r);
|
||||
public extern LTDate GetCurTimeLTDate();
|
||||
public extern void LTDateToISO(ISODate *dst,LTDate ltdate);
|
||||
|
||||
public extern LTBlkDev *local_blkdevs,*boot_blkdev;
|
||||
public extern LTPartition *local_partitions,*default_partition;
|
||||
public extern I1 default_drive;
|
||||
public extern LTPartition *drive_to_partition[32];
|
||||
extern void LockPartition(LTPartition *p);
|
||||
extern BoolU4 UnlockPartition(LTPartition *p,BoolU4 reset=FALSE);
|
||||
public extern void InvalidateDiskCache(LTPartition *p,BoolU4 unlock);
|
||||
public extern void ChangeDisk(I1 drive_letter=0);
|
||||
public extern void PartitionRep();
|
||||
extern void AddBlkDev(LTBlkDev *bd);
|
||||
public extern BoolU4 RBlks(LTPartition *p,U1 *buf, U8 blk, U8 cnt,BoolU4 unlock);
|
||||
public extern BoolU4 WBlks(LTPartition *p,U1 *buf, U8 blk, U8 cnt,BoolU4 unlock);
|
||||
public extern void WZeroBlks(LTPartition *p,U8 blk,U8 cnt,BoolU4 unlock);
|
||||
public extern LTFile *FOpen(I1 *filename,I1 *flags,U8 cnt=0);
|
||||
public extern U8 FSize(LTFile *f);
|
||||
public extern void FSync(LTFile *f);
|
||||
public extern void FClose(LTFile *f);
|
||||
public extern BoolU4 FRBlks(LTFile *f,U1 *buf,U8 blk=LTFB_NEXT_BLK,U8 cnt=1);
|
||||
public extern BoolU4 FWBlks(LTFile *f,U1 *buf,U8 blk=LTFB_NEXT_BLK,U8 cnt=1);
|
||||
public extern void ReadCDImage(I1 drive,I1 *out_name,U8 cnt);
|
||||
public extern void WriteCDImage(I1 drive,I1 *in_name);
|
||||
public extern U8 NextClusterNum(LTPartition *p,U8 c,U8 cnt,BoolU4 unlock);
|
||||
public extern U8 ClusterBlk(LTPartition *p,U8 c);
|
||||
public extern U8 RClusters(LTPartition *p,U1 *buf,U8 c,U8 cnt,BoolU4 unlock,BoolU4 update_display=FALSE);
|
||||
public extern U8 WClusters(LTPartition *p,U1 *buf,U8 c,U8 cnt,BoolU4 unlock,BoolU4 update_display=FALSE);
|
||||
public extern void CleanMAPBuf(LTPartition *p);
|
||||
public extern U8 AllocClusters(LTPartition *p,U8 c,U8 cnt,BoolU4 contiguous,BoolU4 unlock);
|
||||
public extern BoolU4 NewLTDirEntry(LTPartition *p,I1 *cur_dir,LTDirEntry *tempm,BoolU4 free_old_chain=TRUE);
|
||||
|
||||
public extern void DelLTDirEntry(LTDirEntry *tempm);
|
||||
public extern void DelLTDirList(LTDirEntry *tempm);
|
||||
extern LTDirEntry *SysFindFiles(I1 *wild,U8 *fuf_flags=NULL);
|
||||
public extern LTDirEntry *FindFiles(I1 *wild,U8 *fuf_flags=NULL);
|
||||
extern U8 NameToDirCluster(LTPartition *p,I1 *name,BoolU4 unlock);
|
||||
extern U8 NameToParentDirCluster(LTPartition *p,I1 *name,BoolU4 unlock);
|
||||
|
||||
public extern void PutFileLink(I1 *name,I8 line=0,BoolU4 plain_text=FALSE);
|
||||
public extern void PutDirLink(I1 *name);
|
||||
|
||||
public extern void CheckLTPartition(LTPartition *p);
|
||||
public extern void CheckLTBlkDev(LTBlkDev *bdev);
|
||||
public extern I1 PartitionToDrive(LTPartition *p=NULL);
|
||||
public extern LTPartition *DriveToPartition(I1 drive=0);
|
||||
public extern LTBlkDev *DriveToBlkDev(I1 drive=0);
|
||||
public extern BoolU4 DriveIsWritable(I1 drive=0);
|
||||
|
||||
public extern I1 *CurDir();
|
||||
public extern I1 *AbsoluteDirName(I1 *name);
|
||||
public extern I1 *AbsoluteFileName(I1 *name);
|
||||
public extern BoolU4 CheckFileName(I1 *name);
|
||||
public extern I1 *ChangeExtension(I1 *name,I1 *extension);
|
||||
public extern I1 *DefaultExtension(I1 *name,I1 *extension);
|
||||
public extern U8 FileAttr(I1 *name,U8 old_attr=0);
|
||||
public extern void GetFFlags(FlagsStruct *f,I1 *systext_list,I1 *st);
|
||||
public extern I1 *SPrintFFlags(I1 *dst,I1 *systext_list,U8 flags0,U8 flags1=0);
|
||||
public extern void MapDrive(I1 ch,LTPartition *p);
|
||||
public extern BoolU4 Drive(I1 drive_letter);
|
||||
public extern BoolU4 Cd(I1 *name,BoolU4 make_dirs=FALSE);
|
||||
public extern void DelLTFileAccess(LTFileAccess *fa);
|
||||
public extern LTFileAccess *NewLTFileAccess(I1 *mask,BoolU4 make_mask=FALSE,BoolU4 make_dirs=FALSE);
|
||||
public extern void Dir(I1 *wild=NULL,BoolU4 full=FALSE);
|
||||
public extern void Del(I1 *wild,BoolU4 print_msg=TRUE);
|
||||
public extern U1 *ReadFile(I1 *filename,U8 *size=NULL,U8 *attr=NULL,BoolU4 raw=FALSE);
|
||||
public extern I1 *ReadTextFile(I1 *filename,U8 *attr=NULL);
|
||||
public extern BoolU4 FindFile(I1 *filename,LTDirEntry *de=NULL,
|
||||
BoolU4 dir_only=FALSE,BoolU4 file_only=FALSE,BoolU4 scan_parents=FALSE);
|
||||
public extern U8 WriteFile(I1 *filename,U1 *fbuf,
|
||||
U8 size,LTDate LTdatetime=0,U8 attr=0,BoolU4 raw=FALSE);
|
||||
public extern void WriteTextFile(I1 *filename,I1 *st,U8 attr=0);
|
||||
public extern void AddDrives(BoolU4 show_rep=TRUE);
|
||||
public extern void SelectDefaultDrive();
|
||||
extern BoolU4 CopySingle(I1 *f1,I1 *f2); //LTust one file
|
||||
public extern BoolU4 MkDir(I1 *filename);
|
||||
public extern BoolU4 IsDir(I1 *dir_name);
|
||||
extern void SysDel(I1 *wild,BoolU4 make_mask); //this is dangerous
|
||||
public extern void Format(I1 drive_letter,BoolU4 quick=TRUE,BoolU4 confirm=TRUE,U8 type=PT_LT);
|
||||
|
||||
|
||||
public extern TssStruct *Spawn(U1 *start_add,
|
||||
I1 *desc=NULL,
|
||||
TssStruct *parent=NULL, //NULL means adam
|
||||
I1 *account=NULL, //Null means use parent's
|
||||
U8 stk=DEFAULT_STACK);
|
||||
public extern SysHashTable *NewHashTable(U8 size,TssStruct *mem_tss=NULL);
|
||||
public extern void AddTaskToQueue(TssStruct *tss,TssStruct *pred=NULL);
|
||||
public extern TssCmdStruct *
|
||||
QueueTaskRequest(TssStruct *servant,TssStruct *master,
|
||||
I1 *data,U8 flags);
|
||||
public extern TssCmdStruct *
|
||||
QueueTextInput(TssStruct *servant,TssStruct *master,
|
||||
I1 *data,U8 flags);
|
||||
public extern TssCmdStruct *QueueMsg(TssStruct *servant,TssStruct *master,
|
||||
U8 code,U8 p1,U8 p2,U8 flags);
|
||||
public extern void Msg(U8 code,U8 p1,U8 p2,U8 flags=0);
|
||||
public extern BoolU4 GetRequestResult(TssCmdStruct *rqst=NULL,U8 *result=NULL);
|
||||
|
||||
public extern void HandleServantCmds();
|
||||
public extern void InitUserTask();
|
||||
public extern void InitLocalTask();
|
||||
public extern void InitSysTask();
|
||||
public extern I1 *HomeDirString();
|
||||
public extern void ContinueServantTask();
|
||||
public extern void UserCmdLine();
|
||||
extern void SysCmdLine();
|
||||
extern void ServantUserCmdLine();
|
||||
extern void FaultCmdLine();
|
||||
public extern U1 *Load(I1 *filename,BoolU4 no_abs=FALSE);
|
||||
|
||||
Binary file not shown.
@@ -0,0 +1,547 @@
|
||||
I8 my_ExecuteFile(I1 *name)
|
||||
{
|
||||
I8 my_my_ExecuteFile(I1 *name);
|
||||
if (my_my_ExecuteFile=ext[EXT_EXECUTE_FILE])
|
||||
return my_my_ExecuteFile(name);
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
I8 my_ExecuteString(I1 *st,I1 *filename=NULL)
|
||||
{
|
||||
I8 my_my_ExecuteString(I1 *st,I1 *filename);
|
||||
if (my_my_ExecuteString=ext[EXT_EXECUTE_STRING])
|
||||
return my_my_ExecuteString(st,filename);
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
BoolU4 my_WindowToTop(TssStruct *tss)
|
||||
{
|
||||
BoolU4 my_my_WindowToTop(TssStruct *tss);
|
||||
if (my_my_WindowToTop=ext[EXT_WINDOW_TO_TOP])
|
||||
return my_my_WindowToTop(tss);
|
||||
else
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
|
||||
SysHashTable *NewHashTable(U8 size,TssStruct *mem_tss=NULL)
|
||||
{
|
||||
SysHashTable *tempht;
|
||||
tempht=MAllocZ(offset(SysHashTable.body)+size<<2,mem_tss);
|
||||
tempht->mask=size-1;
|
||||
return tempht;
|
||||
}
|
||||
|
||||
/*
|
||||
U8 CreateCodeSelector(U8 phy_add)
|
||||
{
|
||||
U8 result,*d,*d1,old_flags=GetFlags;
|
||||
Cli;
|
||||
result=*FREE_GDT_LIST;
|
||||
d=GDTTAB+result;
|
||||
*FREE_GDT_LIST=*d;
|
||||
d=result+GDTTAB;
|
||||
d1=d+4;
|
||||
*d =0x0000FFFF;
|
||||
*d1=0x00CF9A00;
|
||||
d=d+2;
|
||||
*d+=(phy_add & 0x00FFFFFF);
|
||||
*d1+=(phy_add & 0xFF000000);
|
||||
SetFlags(old_flags);
|
||||
return result;
|
||||
}
|
||||
U8 CreateTssSelector(U8 phy_add)
|
||||
{
|
||||
U8 result,*d,*d1,old_flags=GetFlags;
|
||||
Cli;
|
||||
result=*FREE_GDT_LIST;
|
||||
d=GDTTAB+result;
|
||||
*FREE_GDT_LIST=*d;
|
||||
d=result+GDTTAB;
|
||||
d1=d+4;
|
||||
*d =sizeof(TssStruct)-1;
|
||||
*d1=0x00008900;
|
||||
d=d+2;
|
||||
*d+=(phy_add & 0x00FFFFFF);
|
||||
*d1+=(phy_add & 0xFF000000);
|
||||
SetFlags(old_flags);
|
||||
return result;
|
||||
}
|
||||
*/
|
||||
|
||||
U8 CreateMemSelector(U8 phy_add)
|
||||
{
|
||||
U8 result,old_flags=GetFlags;
|
||||
U4 *d,*d1;
|
||||
Cli;
|
||||
result=free_gdt_list;
|
||||
d=&gdttab+result;
|
||||
free_gdt_list=*d;
|
||||
d1=d+4;
|
||||
*d =0x0000FFFF;
|
||||
*d1=0x00CF9200;
|
||||
d=d+2;
|
||||
*d +=(phy_add & 0x00FFFFFF);
|
||||
*d1+=(phy_add & 0xFF000000);
|
||||
SetFlags(old_flags);
|
||||
return result;
|
||||
}
|
||||
|
||||
void AddTaskToQueue(TssStruct *tss,TssStruct *pred=NULL)
|
||||
{
|
||||
TssStruct *last;
|
||||
U8 old_flags=GetFlags;
|
||||
if (!pred) pred=Fs;
|
||||
Cli;
|
||||
last=pred->last_tss;
|
||||
last->next_tss=tss;
|
||||
pred->last_tss=tss;
|
||||
tss ->last_tss=last;
|
||||
tss ->next_tss=pred;
|
||||
SetFlags(old_flags);
|
||||
}
|
||||
|
||||
void AddTaskToChildQueue(TssStruct *tss)
|
||||
{
|
||||
TssStruct *last,*pred;
|
||||
U8 old_flags=GetFlags;
|
||||
Cli;
|
||||
pred=tss->parent_tss->last_child_tss;
|
||||
last=pred->last_sibling_tss;
|
||||
last->next_sibling_tss=tss;
|
||||
pred->last_sibling_tss=tss;
|
||||
tss ->last_sibling_tss=last;
|
||||
tss ->next_sibling_tss=pred;
|
||||
SetFlags(old_flags);
|
||||
}
|
||||
|
||||
asm {CP_INIT_TSS::}
|
||||
U1 *InitTss(TssStruct *tss,U8 stk)
|
||||
{ //Returns Fs of task
|
||||
U1 *b;
|
||||
U1 *result;
|
||||
MemSet(tss,0,sizeof(TssStruct));
|
||||
tss->cs=SYS_CS_SEL;
|
||||
tss->ds=ZERO_DS_SEL;
|
||||
tss->es=ZERO_DS_SEL;
|
||||
tss->gs=ZERO_DS_SEL;
|
||||
tss->absolute_address=tss;
|
||||
tss->io_bitmap_ptr=TSS_IO_BITMAP;
|
||||
tss->next_tss=tss;
|
||||
tss->last_tss=tss;
|
||||
tss->eflags=SYS_DEFAULT_FLAGS;
|
||||
tss->cr3=SYS_DEFAULT_CR3;
|
||||
tss->optimization=0x7F;
|
||||
b=&tss->next_child_tss-offset(TssStruct.next_sibling_tss);
|
||||
tss->next_child_tss=b;
|
||||
tss->last_child_tss=b;
|
||||
b=&tss->next_servant_cmd;
|
||||
tss->next_servant_cmd=b;
|
||||
tss->last_servant_cmd=b;
|
||||
b=&tss->next_master_cmd;
|
||||
tss->next_master_cmd=b;
|
||||
tss->last_master_cmd=b;
|
||||
b=&tss->next_mem_blk;
|
||||
tss->next_mem_blk=b;
|
||||
tss->last_mem_blk=b;
|
||||
b=&tss->next_lex;
|
||||
tss->next_lex=b;
|
||||
tss->last_lex=b;
|
||||
b=&tss->next_except;
|
||||
tss->next_except=b;
|
||||
tss->last_except=b;
|
||||
b=&tss->next_ode;
|
||||
tss->next_ode=b;
|
||||
tss->last_ode=b;
|
||||
|
||||
result=CreateMemSelector(tss);
|
||||
tss->fs=result;
|
||||
tss->hash_table=NewHashTable(0x1000,tss);
|
||||
b=MAlloc(stk,tss);
|
||||
tss->stack_base=b;
|
||||
b=b+stk;
|
||||
tss->esp0=b;
|
||||
tss->esp1=b;
|
||||
tss->esp2=b;
|
||||
tss->esp=b;
|
||||
tss->ss0=ZERO_DS_SEL;
|
||||
tss->ss1=ZERO_DS_SEL;
|
||||
tss->ss2=ZERO_DS_SEL;
|
||||
tss->ss=ZERO_DS_SEL;
|
||||
MemSet(tss->io_bitmap,0xFF,MAXIO>>3);
|
||||
Bts(&tss->task_flags,TSSf_PREEMPT);
|
||||
return result;
|
||||
}
|
||||
|
||||
asm {CP_SPAWN_TASK::}
|
||||
TssStruct *Spawn(U1 *start_add,I1 *desc=NULL,
|
||||
TssStruct *parent=NULL, //NULL means adam
|
||||
I1 *account=NULL,
|
||||
U8 stk=DEFAULT_STACK)
|
||||
{
|
||||
U8 d,old_flags=GetFlags;
|
||||
TssStruct *tss=AMAlloc(sizeof(TssStruct));
|
||||
SysAccntStruct *my_FindSysAccnt(I1 *name);
|
||||
SysAccntStruct *tempa;
|
||||
if (!parent) parent=adam_tss;
|
||||
InitTss(tss,stk);
|
||||
tss->eip=start_add;
|
||||
tss->esp-=4;
|
||||
*tss->esp=&Exit;
|
||||
tss->parent_tss=parent;
|
||||
tss->hash_table->next=parent->hash_table;
|
||||
if (!desc) desc="USER CMD";
|
||||
MemCpy(tss->task_descriptor,desc,TSS_DESC_LENGTH);
|
||||
tss->account=tss->parent_tss->account;
|
||||
if (account) {
|
||||
if (d=FindExtern("FindSysAccnt")) {
|
||||
my_FindSysAccnt=d;
|
||||
if (tempa=my_FindSysAccnt(account))
|
||||
tss->account=tempa;
|
||||
}
|
||||
}
|
||||
Cli;
|
||||
//The following is a convenient way to
|
||||
//initialize the FPU, but not very professional.
|
||||
//I'll fix it when I have time.
|
||||
MemCpy(&tss->fpu,&parent->fpu,108);
|
||||
|
||||
AddTaskToQueue(tss);
|
||||
AddTaskToChildQueue(tss);
|
||||
Bts(&sys_flags,SYSf_TASK_LINKS_ALTERED);
|
||||
SetFlags(old_flags);
|
||||
return tss;
|
||||
}
|
||||
|
||||
|
||||
TssCmdStruct *QueueTaskRequest(TssStruct *servant,TssStruct *master,
|
||||
I1 *data,U8 flags)
|
||||
{
|
||||
U8 old_flags=GetFlags;
|
||||
TssCmdStruct *result;
|
||||
if (!data) return;
|
||||
result=AMAlloc(sizeof(TssCmdStruct));
|
||||
result->master_tss=master;
|
||||
Bts(&flags,TSSCf_TEXT);
|
||||
Bts(&flags,TSSCf_NOT_INPUT);
|
||||
result->flags=flags;
|
||||
result->data=ANewString(data);
|
||||
Cli;
|
||||
InsQue(result,servant->last_servant_cmd);
|
||||
if (Bt(&flags,TSSCf_WAKE_MASTER)) {
|
||||
Bts(&master->task_flags,TSSf_SUSPENDED);
|
||||
SwapInNext;
|
||||
}
|
||||
SetFlags(old_flags);
|
||||
return result;
|
||||
}
|
||||
|
||||
TssCmdStruct *QueueTextInput(TssStruct *servant,TssStruct *master,
|
||||
I1 *data,U8 flags)
|
||||
{
|
||||
U8 old_flags=GetFlags;
|
||||
BoolU4 old_preempt=Preempt(OFF);
|
||||
U1 *input_filter_start_add;
|
||||
TssCmdStruct *result;
|
||||
TssStruct *tss;
|
||||
if (!data) return;
|
||||
result=AMAlloc(sizeof(TssCmdStruct));
|
||||
result->master_tss=master;
|
||||
Bts(&flags,TSSCf_TEXT);
|
||||
result->flags=flags;
|
||||
result->data=ANewString(data);
|
||||
|
||||
if (input_filter_start_add=FindExtern("InputFilterTask")) {
|
||||
if (Bt(&servant->task_flags,TSSf_INPUT_FILTER_TASK))
|
||||
servant=servant->parent_tss;
|
||||
tss=Spawn(input_filter_start_add,
|
||||
"Input Filter",servant);
|
||||
tss->input_filter_tss=servant->input_filter_tss;
|
||||
servant->input_filter_tss=tss;
|
||||
Cli;
|
||||
InsQue(result,tss->last_servant_cmd);
|
||||
if (Bt(&flags,TSSCf_WAKE_MASTER)) {
|
||||
Bts(&master->task_flags,TSSf_SUSPENDED);
|
||||
SwapInNext;
|
||||
}
|
||||
SetFlags(old_flags);
|
||||
} else {
|
||||
AFree(result);
|
||||
result=NULL;
|
||||
}
|
||||
Preempt(old_preempt);
|
||||
return result;
|
||||
}
|
||||
|
||||
TssCmdStruct *QueueMsg(TssStruct *servant,TssStruct *master,
|
||||
U8 code,U8 p1,U8 p2,U8 flags)
|
||||
{
|
||||
TssCmdStruct *tempc1,*tempc=AMAlloc(sizeof(TssCmdStruct));
|
||||
U8 old_flags=GetFlags;
|
||||
tempc->master_tss=master;
|
||||
tempc->code=code;
|
||||
tempc->p1=p1;
|
||||
tempc->p2=p2;
|
||||
tempc->flags=flags;
|
||||
tempc->data=NULL;
|
||||
if (Bt(&sys_flags,SYSf_RECORD_MACRO) &&
|
||||
servant!=macro_util_tss &&
|
||||
code==MSG_KEY_DOWN) {
|
||||
tempc1=AMAllocIdentical(tempc);
|
||||
InsQue(tempc1,sys_macro_queue.last);
|
||||
}
|
||||
Cli;
|
||||
if (Bt(&servant->task_flags,TSSf_FILTER_INPUT) &&
|
||||
!Bt(&flags,TSSCf_DONT_FILTER))
|
||||
servant=servant->input_filter_tss;
|
||||
InsQue(tempc,servant->last_servant_cmd);
|
||||
if (Bt(&flags,TSSCf_WAKE_MASTER)) {
|
||||
Bts(&master->task_flags,TSSf_SUSPENDED);
|
||||
SwapInNext;
|
||||
}
|
||||
SetFlags(old_flags);
|
||||
return tempc;
|
||||
}
|
||||
|
||||
BoolU4 GetRequestResult(TssCmdStruct *rqst=NULL,U8 *result=NULL)
|
||||
{
|
||||
U8 old_flags=GetFlags;
|
||||
TssCmdStruct *tempc,*tempc1;
|
||||
Cli;
|
||||
tempc1=&Fs->next_master_cmd;
|
||||
tempc=tempc1->next;
|
||||
while (tempc!=tempc1) {
|
||||
if (!rqst || rqst==tempc) {
|
||||
RemQue(tempc);
|
||||
if (result)
|
||||
*result=tempc->result;
|
||||
AFree(tempc->data);
|
||||
AFree(tempc);
|
||||
SetFlags(old_flags);
|
||||
return TRUE;
|
||||
}
|
||||
tempc=tempc->next;
|
||||
}
|
||||
SetFlags(old_flags);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
void Msg(U8 code,U8 p1,U8 p2,U8 flags=0)
|
||||
{
|
||||
if (Bt(&Fs->task_flags,TSSf_INPUT_FILTER_TASK)) {
|
||||
QueueMsg(Fs->parent_tss,0,code,p1,p2,
|
||||
flags| 1<<TSSCf_DONT_FILTER);
|
||||
} else
|
||||
QueueMsg(Fs,0,code,p1,p2,flags);
|
||||
}
|
||||
|
||||
|
||||
void HandleServantCmds()
|
||||
{
|
||||
U8 old_flags=GetFlags;
|
||||
TssCmdStruct *tempc,*tempc1,*tempc2;
|
||||
TssStruct *master;
|
||||
start_over:
|
||||
Cli;
|
||||
tempc1=&Fs->next_servant_cmd;
|
||||
tempc=tempc1->next;
|
||||
while (tempc!=tempc1) {
|
||||
tempc2=tempc->next;
|
||||
if (Bt(&tempc->flags,TSSCf_NOT_INPUT)) {
|
||||
RemQue(tempc);
|
||||
SetFlags(old_flags);
|
||||
tempc->result=my_ExecuteString(tempc->data,sys_temp_filename);
|
||||
if (master=tempc->master_tss) {
|
||||
if (!Bt(&tempc->flags,TSSCf_EXIT_ON_COMPLETE)) {
|
||||
Cli;
|
||||
InsQue(tempc,master->last_master_cmd);
|
||||
SetFlags(old_flags);
|
||||
}
|
||||
if (Bt(&tempc->flags,TSSCf_FOCUS_MASTER) &&
|
||||
Bt(&master->task_flags,TSSf_LOCAL_USER))
|
||||
sys_cur_focus_task=master;
|
||||
if (Bt(&tempc->flags,TSSCf_WAKE_MASTER))
|
||||
Btr(&master->task_flags,TSSf_SUSPENDED);
|
||||
if (!Bt(&tempc->flags,TSSCf_EXIT_ON_COMPLETE))
|
||||
goto start_over;
|
||||
else {
|
||||
AFree(tempc->data);
|
||||
AFree(tempc);
|
||||
Exit;
|
||||
}
|
||||
} else {
|
||||
if (!Bt(&tempc->flags,TSSCf_EXIT_ON_COMPLETE)) {
|
||||
AFree(tempc->data);
|
||||
AFree(tempc);
|
||||
goto start_over;
|
||||
} else {
|
||||
AFree(tempc->data);
|
||||
AFree(tempc);
|
||||
Exit;
|
||||
}
|
||||
}
|
||||
} //TODO: figure-out how to handle build-up of input
|
||||
tempc=tempc2;
|
||||
}
|
||||
SetFlags(old_flags);
|
||||
}
|
||||
|
||||
void ContinueServantTask()
|
||||
{
|
||||
while (TRUE) {
|
||||
Btr(&Fs->task_flags,TSSf_IDLE);
|
||||
HandleServantCmds;
|
||||
Bts(&Fs->task_flags,TSSf_IDLE);
|
||||
SwapInNext;
|
||||
}
|
||||
}
|
||||
|
||||
I1 *HomeDirString()
|
||||
{
|
||||
I1 *result=MAlloc(128);
|
||||
SysAccntStruct *sa=Fs->account;
|
||||
StrCpy(result,"::/LT/ACCOUNTS/");
|
||||
if (sa)
|
||||
StrCat(result,sa->name);
|
||||
else
|
||||
StrCat(result,"USER");
|
||||
*result=PartitionToDrive(default_partition);
|
||||
return result;
|
||||
}
|
||||
|
||||
void InitSysTask()
|
||||
{
|
||||
InitCrt;
|
||||
CursorOff;
|
||||
Fs->text_attribute=(WHITE<<4)+PURPLE;
|
||||
Fs->border_attribute=(WHITE<<4)+LTPURPLE;
|
||||
Fs->window_top++;
|
||||
CursorHome;
|
||||
}
|
||||
|
||||
void InitLocalTask()
|
||||
{
|
||||
InitCrt;
|
||||
Bts(&Fs->crt_flags,CRTf_HAS_CLOSE_WINDOW);
|
||||
CursorOff;
|
||||
Fs->text_attribute=(WHITE<<4)+BLUE;
|
||||
Fs->border_attribute=(WHITE<<4)+LTBLUE;
|
||||
Fs->window_top=13;
|
||||
CursorHome;
|
||||
Cd("HOME");
|
||||
my_WindowToTop(Fs);
|
||||
}
|
||||
|
||||
void InitUserTask()
|
||||
{
|
||||
Bts(&Fs->task_flags,TSSf_LOCAL_USER);
|
||||
InitLocalTask;
|
||||
}
|
||||
|
||||
|
||||
asm {CP_USER_CMD_LINE::}
|
||||
void UserCmdLine()
|
||||
{
|
||||
void my_ContinueUserTask();
|
||||
InitUserTask;
|
||||
Fs->user_num=++num_spawned_users;
|
||||
my_ExecuteFile("USER.CPZ");
|
||||
my_ContinueUserTask=FindExtern("ContinueUserTask");
|
||||
my_ContinueUserTask();
|
||||
}
|
||||
|
||||
void SysCmdLine()
|
||||
{
|
||||
InitSysTask;
|
||||
Cd("HOME");
|
||||
my_ExecuteFile("SYSTEM.CPZ");
|
||||
ContinueServantTask;
|
||||
}
|
||||
|
||||
void ServantUserCmdLine()
|
||||
{
|
||||
InitUserTask;
|
||||
my_ExecuteFile("SERVANT.CPZ");
|
||||
ContinueServantTask;
|
||||
}
|
||||
|
||||
asm {CP_FAULT_CMD_LINE::}
|
||||
void FaultCmdLine()
|
||||
{
|
||||
void my_ContinueUserTask();
|
||||
InitUserTask;
|
||||
my_ExecuteFile("FAULT.CPZ");
|
||||
my_ContinueUserTask=FindExtern("ContinueUserTask");
|
||||
my_ContinueUserTask();
|
||||
}
|
||||
|
||||
asm {END_TASK::}
|
||||
U8 EndTask()
|
||||
{
|
||||
TssStruct *tempt,*tempt1;
|
||||
TssCmdStruct *tempc,*tempc1,*tempc2;
|
||||
U8 my_fs;
|
||||
U4 *d;
|
||||
if (Fs->end_task_cb) {
|
||||
Btr(&Fs->task_flags,TSSf_KILL_TASK);
|
||||
Fs->eip=Fs->end_task_cb;
|
||||
Fs->end_task_cb=NULL;
|
||||
return Fs->fs;
|
||||
}
|
||||
Cli;
|
||||
if (sys_cur_focus_task==Fs) {
|
||||
sys_cur_focus_task=0;
|
||||
ip_inhibit_win_operations=FALSE;
|
||||
}
|
||||
ReleaseTaskPartitions;
|
||||
tempt1=&Fs->next_child_tss-offset(TssStruct.next_sibling_tss);
|
||||
tempt=tempt1->next_sibling_tss;
|
||||
if (tempt!=tempt1) {
|
||||
do {
|
||||
Bts(&tempt->task_flags,TSSf_KILL_TASK);
|
||||
tempt=tempt->next_sibling_tss;
|
||||
} while (tempt!=tempt1);
|
||||
return Fs->next_tss->fs;
|
||||
}
|
||||
Btr(&sys_flags,SYSf_PREEMPTIVE);
|
||||
Bts(&sys_flags,SYSf_CLEAR_SCREEN_TEXT);
|
||||
|
||||
tempc1=&Fs->next_servant_cmd;
|
||||
tempc=tempc1->next;
|
||||
while (tempc!=tempc1) {
|
||||
tempc2=tempc->next;
|
||||
AFree(tempc->data);
|
||||
AFree(tempc);
|
||||
tempc=tempc2;
|
||||
}
|
||||
|
||||
tempc1=&Fs->next_master_cmd;
|
||||
tempc=tempc1->next;
|
||||
while (tempc!=tempc1) {
|
||||
tempc2=tempc->next;
|
||||
AFree(tempc->data);
|
||||
AFree(tempc);
|
||||
tempc=tempc2;
|
||||
}
|
||||
|
||||
//Remque
|
||||
tempt =Fs->next_sibling_tss;
|
||||
tempt1=Fs->last_sibling_tss;
|
||||
tempt1->next_sibling_tss=tempt;
|
||||
tempt ->last_sibling_tss=tempt1;
|
||||
tempt =Fs->next_tss;
|
||||
tempt1=Fs->last_tss;
|
||||
tempt1->next_tss=tempt;
|
||||
tempt ->last_tss=tempt1;
|
||||
Bts(&sys_flags,SYSf_TASK_LINKS_ALTERED);
|
||||
FreeMemBlkList;
|
||||
my_fs=Fs->fs;
|
||||
AFree(Fs);
|
||||
d=&gdttab+my_fs;
|
||||
*d=*free_gdt_list;
|
||||
*free_gdt_list=my_fs;
|
||||
return tempt->fs;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,209 @@
|
||||
// The following algorithm came from a magazine
|
||||
// and I implimented it when I worked for Ticketmaster.
|
||||
|
||||
void ArcCompressBuf(ArcCs *c)
|
||||
{
|
||||
ArcTableEntry *temp,*temp1;
|
||||
U8 basecode;
|
||||
U1 *src_ptr,*src_limit,ch;
|
||||
|
||||
src_ptr=c->src_buf+c->src_pos;
|
||||
src_limit=c->src_buf+c->src_size;
|
||||
|
||||
if (c->saved_basecode==0xFFFFFFFF)
|
||||
basecode=*src_ptr++;
|
||||
else
|
||||
basecode=c->saved_basecode;
|
||||
|
||||
while (src_ptr<src_limit &&
|
||||
c->dst_pos+c->cur_bits_in_use<=c->dst_size) {
|
||||
ArcGetTableEntry(c);
|
||||
|
||||
arc_start_loop1:
|
||||
if (src_ptr>=src_limit) goto arc_done_compression;
|
||||
ch=*src_ptr++;
|
||||
if (temp=c->hash[basecode])
|
||||
do {
|
||||
if (temp->ch==ch) {
|
||||
basecode=(temp-&c->compress[0])>>3;
|
||||
goto arc_start_loop1;
|
||||
}
|
||||
} while (temp=temp->next);
|
||||
|
||||
OrWordBitField(c->dst_buf,c->dst_pos,basecode);
|
||||
c->dst_pos+=c->cur_bits_in_use;
|
||||
|
||||
c->entry_used=TRUE;
|
||||
temp=c->cur_entry;
|
||||
temp->basecode=basecode;
|
||||
temp->ch=ch;
|
||||
temp1=&c->hash[basecode];
|
||||
temp->next=temp1->next;
|
||||
temp1->next=temp;
|
||||
|
||||
basecode=ch;
|
||||
}
|
||||
arc_done_compression:
|
||||
c->saved_basecode=basecode;
|
||||
c->src_pos=src_ptr-c->src_buf;
|
||||
}
|
||||
|
||||
void ArcFinishCompression(ArcCs *c)
|
||||
{
|
||||
if (c->dst_pos+c->cur_bits_in_use<=c->dst_size) {
|
||||
OrWordBitField(c->dst_buf,c->dst_pos,c->saved_basecode);
|
||||
c->dst_pos+=c->cur_bits_in_use;
|
||||
}
|
||||
}
|
||||
|
||||
void ArcExpandBuf(ArcCs *c)
|
||||
{
|
||||
U1 *dst_ptr,*dst_limit;
|
||||
U8 basecode,lastcode,code;
|
||||
ArcTableEntry *temp,*temp1;
|
||||
|
||||
dst_ptr=c->dst_buf+c->dst_pos;
|
||||
dst_limit=c->dst_buf+c->dst_size;
|
||||
|
||||
while (dst_ptr<dst_limit &&
|
||||
c->stack_ptr!=c->stack_base)
|
||||
*dst_ptr++ = * -- c->stack_ptr;
|
||||
|
||||
if (c->stack_ptr==c->stack_base && dst_ptr<dst_limit) {
|
||||
if (c->saved_basecode==0xFFFFFFFF) {
|
||||
lastcode=ExtractWordBitField(c->src_buf,c->src_pos,
|
||||
c->next_bits_in_use);
|
||||
c->src_pos=c->src_pos+c->next_bits_in_use;
|
||||
*dst_ptr++=lastcode;
|
||||
ArcGetTableEntry(c);
|
||||
c->last_ch=lastcode;
|
||||
} else
|
||||
lastcode=c->saved_basecode;
|
||||
while (dst_ptr<dst_limit &&
|
||||
c->src_pos+c->next_bits_in_use<=c->src_size) {
|
||||
basecode=ExtractWordBitField(c->src_buf,c->src_pos,
|
||||
c->next_bits_in_use);
|
||||
c->src_pos+=c->next_bits_in_use;
|
||||
if (c->cur_entry==&c->compress[basecode]) {
|
||||
*c->stack_ptr++=c->last_ch;
|
||||
code=lastcode;
|
||||
} else
|
||||
code=basecode;
|
||||
while (code>=c->min_table_entry) {
|
||||
*c->stack_ptr++=c->compress[code].ch;
|
||||
code=c->compress[code].basecode;
|
||||
}
|
||||
*c->stack_ptr++=code;
|
||||
c->last_ch=code;
|
||||
|
||||
c->entry_used=TRUE;
|
||||
temp=c->cur_entry;
|
||||
temp->basecode=lastcode;
|
||||
temp->ch=c->last_ch;
|
||||
temp1=&c->hash[lastcode];
|
||||
temp->next=temp1->next;
|
||||
temp1->next=temp;
|
||||
|
||||
ArcGetTableEntry(c);
|
||||
while (dst_ptr<dst_limit && c->stack_ptr!=c->stack_base)
|
||||
*dst_ptr++ = * -- c->stack_ptr;
|
||||
lastcode=basecode;
|
||||
}
|
||||
c->saved_basecode=lastcode;
|
||||
}
|
||||
c->dst_pos=dst_ptr-c->dst_buf;
|
||||
}
|
||||
|
||||
ArcCs *NewArcCs(BoolU4 expand,BoolU4 text_only)
|
||||
{
|
||||
ArcCs *c;
|
||||
c=MAllocZ(sizeof(ArcCs));
|
||||
if (expand) {
|
||||
c->stack_base=MAlloc(ARC_MAX_TABLE_ENTRY+1);
|
||||
c->stack_ptr=c->stack_base;
|
||||
}
|
||||
if (text_only)
|
||||
c->min_bits=7;
|
||||
else
|
||||
c->min_bits=8;
|
||||
c->min_table_entry=1<<c->min_bits;
|
||||
c->free_index=c->min_table_entry;
|
||||
c->next_bits_in_use=c->min_bits+1;
|
||||
c->free_limit=1<<c->next_bits_in_use;
|
||||
c->saved_basecode=0xFFFFFFFF;
|
||||
c->entry_used=TRUE;
|
||||
ArcGetTableEntry(c);
|
||||
c->entry_used=TRUE;
|
||||
return c;
|
||||
}
|
||||
|
||||
void DelArcCs(ArcCs *c)
|
||||
{
|
||||
Free(c->stack_base);
|
||||
Free(c);
|
||||
}
|
||||
|
||||
|
||||
ArcCompressStruct *CompressBuf(U1 *src,U8 size,
|
||||
U8 flags=0)
|
||||
{
|
||||
U8 size_out;
|
||||
ArcCompressStruct *result;
|
||||
BoolU4 text_only=(ArcDetermineCompressionType(src,size)==CT_7_BIT);
|
||||
ArcCs *c=NewArcCs(FALSE,text_only);
|
||||
c->src_size=size;
|
||||
c->src_buf=src;
|
||||
c->dst_size=(size+sizeof(ArcCompressStruct)-1)<<3;
|
||||
c->dst_buf=MAllocZ(c->dst_size>>3);
|
||||
c->dst_pos=(sizeof(ArcCompressStruct)-1)<<3;
|
||||
ArcCompressBuf(c);
|
||||
ArcFinishCompression(c);
|
||||
if (c->src_pos==c->src_size) {
|
||||
size_out=(c->dst_pos+7)>>3;
|
||||
result=MAlloc(size_out);
|
||||
MemCpy(result,c->dst_buf,size_out);
|
||||
result->compression_type=(text_only) ? CT_7_BIT:CT_8_BIT;
|
||||
result->compressed_size=size_out;
|
||||
} else {
|
||||
result=MAlloc(size+sizeof(ArcCompressStruct)-1);
|
||||
MemCpy(result->body,src,size);
|
||||
result->compression_type=CT_NONE;
|
||||
result->compressed_size=size+sizeof(ArcCompressStruct)-1;
|
||||
}
|
||||
result->expanded_size=size;
|
||||
result->flags=flags;
|
||||
Free(c->dst_buf);
|
||||
DelArcCs(c);
|
||||
return result;
|
||||
}
|
||||
|
||||
U1 *ExpandBuf(ArcCompressStruct *r)
|
||||
{
|
||||
ArcCs *c;
|
||||
ArcCompressStruct *r2=r;
|
||||
U1 *result;
|
||||
BoolU4 text_only;
|
||||
result=MAlloc(r2->expanded_size+1);
|
||||
result[r2->expanded_size]=0; //terminate
|
||||
|
||||
text_only=(r2->compression_type==CT_7_BIT);
|
||||
if (r2->compression_type==CT_NONE) {
|
||||
MemCpy(result,r2->body,r2->expanded_size);
|
||||
goto expand_end;
|
||||
}
|
||||
c=NewArcCs(TRUE,text_only);
|
||||
c->src_size=r2->compressed_size<<3;
|
||||
c->src_pos=(sizeof(ArcCompressStruct)-1)<<3;
|
||||
c->src_buf=r2;
|
||||
c->dst_size=r2->expanded_size;
|
||||
c->dst_buf=result;
|
||||
c->dst_pos=0;
|
||||
ArcExpandBuf(c);
|
||||
DelArcCs(c);
|
||||
|
||||
expand_end:
|
||||
if (r2!=r)
|
||||
Free(r2);
|
||||
return result;
|
||||
}
|
||||
|
||||
Binary file not shown.
@@ -0,0 +1,191 @@
|
||||
I4 YearStartDate(I4 year)
|
||||
{
|
||||
I4 y1=year-1;
|
||||
I4 yd4000=y1/4000,yd400=y1/400,yd100=y1/100,yd4=y1/4;
|
||||
return year*365+yd4-yd100+yd400-yd4000;
|
||||
}
|
||||
|
||||
LTDate ToLTDate(LTDateStruct *d)
|
||||
{
|
||||
LTDate ltdt;
|
||||
I4 i1,i2;
|
||||
i1=YearStartDate(d->year);
|
||||
i2=YearStartDate(d->year+1);
|
||||
if (i2-i1==365)
|
||||
i1+=month_start_days1[d->month-1];
|
||||
else
|
||||
i1+=month_start_days2[d->month-1];
|
||||
ltdt.date=i1+d->day_of_month-1;
|
||||
ltdt.time=DivU8((d->ten_thousandths+10000*(d->seconds+60*(d->minutes+60*d->hours)))<<21,(15*15*3*625));
|
||||
return ltdt;
|
||||
}
|
||||
|
||||
U1 DayOfWeek(I4 i)
|
||||
{
|
||||
return (i+LT_BASE_DAY_OF_WEEK) % 7;
|
||||
}
|
||||
|
||||
void ToLTDateStruct(LTDateStruct *d,LTDate ltdt)
|
||||
{
|
||||
I4 i,date=ltdt.date;
|
||||
U4 k;
|
||||
d->day_of_week=DayOfWeek(date);
|
||||
d->year=DivI8(MulI8(date,100000),36524225);
|
||||
i=YearStartDate(d->year);
|
||||
date-=i;
|
||||
if (YearStartDate(d->year+1)-i==365) {
|
||||
k=0;
|
||||
while (date>=month_start_days1[k+1] && k<11)
|
||||
k++;
|
||||
date-=month_start_days1[k];
|
||||
} else {
|
||||
k=0;
|
||||
while (date>=month_start_days2[k+1] && k<11)
|
||||
k++;
|
||||
date-=month_start_days2[k];
|
||||
}
|
||||
d->month=k+1;
|
||||
d->day_of_month=date+1;
|
||||
k=MulU8(625*15*15*3,ltdt.time)>>21+1;
|
||||
d->ten_thousandths=k%10000; k/=100;
|
||||
d->hundredths=k%100; k/=100;
|
||||
d->seconds=k%60;k/=60;
|
||||
d->minutes=k%60;
|
||||
d->hours =k/60;
|
||||
}
|
||||
|
||||
I4 FirstDayOfMonth(I4 i)
|
||||
{
|
||||
LTDateStruct d;
|
||||
LTDate ltdt=0;
|
||||
ltdt.date=i;
|
||||
ToLTDateStruct(&d,ltdt);
|
||||
d.day_of_month=1;
|
||||
ltdt=ToLTDate(&d);
|
||||
return ltdt.date;
|
||||
}
|
||||
|
||||
I4 LastDayOfMonth(I4 i)
|
||||
{
|
||||
LTDateStruct d;
|
||||
LTDate ltdt=0;
|
||||
ltdt.date=i;
|
||||
ToLTDateStruct(&d,ltdt);
|
||||
d.month++;
|
||||
if (d.month==13) {
|
||||
d.month=0;
|
||||
d.year++;
|
||||
}
|
||||
d.day_of_month=1;
|
||||
ltdt=ToLTDate(&d);
|
||||
return ltdt.date-1;
|
||||
}
|
||||
|
||||
I4 FirstDayOfYear(I4 i)
|
||||
{
|
||||
LTDateStruct d;
|
||||
LTDate ltdt=0;
|
||||
ltdt.date=i;
|
||||
ToLTDateStruct(&d,ltdt);
|
||||
d.day_of_month=1;
|
||||
d.month=1;
|
||||
ltdt=ToLTDate(&d);
|
||||
return ltdt.date;
|
||||
}
|
||||
|
||||
I4 LastDayOfYear(I4 i)
|
||||
{
|
||||
LTDateStruct d;
|
||||
LTDate ltdt=0;
|
||||
ltdt.date=i;
|
||||
ToLTDateStruct(&d,ltdt);
|
||||
d.day_of_month=1;
|
||||
d.month=1;
|
||||
d.year++;
|
||||
ltdt=ToLTDate(&d);
|
||||
return ltdt.date-1;
|
||||
}
|
||||
|
||||
|
||||
I8 Bcd2Bin(U8 b)
|
||||
{
|
||||
I8 i,result=0;
|
||||
for (i=0;i<16;i++) {
|
||||
result=MulU8(result,10)+DivU8(b,0x1000000000000000);
|
||||
b<<=4;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
void GetCurTimeLTDateStruct(LTDateStruct *r)
|
||||
{
|
||||
I8 i;
|
||||
U8 old_flags=GetFlags;
|
||||
U1 *p=r;
|
||||
|
||||
MemSet(r,0,sizeof(LTDateStruct));
|
||||
Cli;
|
||||
do OutP(0x70,0x0A);
|
||||
while (InP(0x71) & 0x80);
|
||||
|
||||
OutP(0x70,0);
|
||||
p[3]=InP(0x71);
|
||||
OutP(0x70,2);
|
||||
p[4]=InP(0x71);
|
||||
OutP(0x70,4);
|
||||
p[5]=InP(0x71);
|
||||
|
||||
OutP(0x70,6);
|
||||
p[6]=InP(0x71);
|
||||
OutP(0x70,7);
|
||||
p[7]=InP(0x71);
|
||||
OutP(0x70,8);
|
||||
p[8]=InP(0x71);
|
||||
OutP(0x70,9);
|
||||
p[9]=InP(0x71);
|
||||
|
||||
SetFlags(old_flags);
|
||||
|
||||
OutP(0x70,0x0B);
|
||||
if (!(InP(0x71) & 4)) {
|
||||
for (i=3;i<10;i++)
|
||||
p[i]=Bcd2Bin(p[i]);
|
||||
}
|
||||
r->year+=2000;
|
||||
}
|
||||
|
||||
LTDate GetCurTimeLTDate()
|
||||
{
|
||||
LTDateStruct r;
|
||||
GetCurTimeLTDateStruct(&r);
|
||||
return ToLTDate(&r);
|
||||
}
|
||||
|
||||
void LTDateToISO(ISODate *dst,LTDate ltdate)
|
||||
{
|
||||
LTDateStruct d;
|
||||
ToLTDateStruct(&d,ltdate);
|
||||
dst->year=d.year-ISO_BASE_YEAR;
|
||||
dst->mon=d.month;
|
||||
dst->day=d.day_of_month;
|
||||
dst->hour=d.hours;
|
||||
dst->min=d.minutes;
|
||||
dst->sec=d.seconds;
|
||||
dst->hund=d.hundredths;
|
||||
}
|
||||
|
||||
LTDate ISOToLTDate(ISODate *dt)
|
||||
{
|
||||
LTDateStruct ltdt;
|
||||
ltdt.day_of_month=dt->day;
|
||||
ltdt.month=dt->mon;
|
||||
ltdt.year=dt->year+ISO_BASE_YEAR;
|
||||
ltdt.ten_thousandths=dt->hund*100;
|
||||
ltdt.hundredths=dt->hund;
|
||||
ltdt.seconds=dt->sec;
|
||||
ltdt.minutes=dt->min;
|
||||
ltdt.hours=dt->hour;
|
||||
return ToLTDate(<dt);
|
||||
}
|
||||
|
||||
Binary file not shown.
@@ -0,0 +1,901 @@
|
||||
BoolU4 RAMRBlks(LTPartition *p,U1 *buf,U8 blk,U8 cnt)
|
||||
{
|
||||
LTBlkDev *bdev=p->bdev;
|
||||
CheckLTBlkDev(bdev);
|
||||
MemCpy(buf,bdev->RAM_disk+blk*BLK_SIZE,cnt*BLK_SIZE);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BoolU4 RAMWBlks(LTPartition *p,U1 *buf,U8 blk,U8 cnt)
|
||||
{
|
||||
LTBlkDev *bdev=p->bdev;
|
||||
CheckLTBlkDev(bdev);
|
||||
MemCpy(bdev->RAM_disk+blk*BLK_SIZE,buf,cnt*BLK_SIZE);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BoolU4 FileRBlks(LTPartition *p,U1 *buf,U8 blk,U8 cnt)
|
||||
{
|
||||
LTBlkDev *bdev=p->bdev;
|
||||
CheckLTBlkDev(bdev);
|
||||
if (!bdev->f)
|
||||
throw(EXCEPT_PARTITION,5);
|
||||
if (!FRBlks(bdev->f,buf,blk,cnt))
|
||||
throw(EXCEPT_PARTITION,6);
|
||||
FSync(bdev->f);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BoolU4 FileWBlks(LTPartition *p,U1 *buf,U8 blk,U8 cnt)
|
||||
{
|
||||
LTBlkDev *bdev=p->bdev;
|
||||
CheckLTBlkDev(bdev);
|
||||
if (!bdev->f)
|
||||
throw(EXCEPT_PARTITION,7);
|
||||
if (!FWBlks(bdev->f,buf,blk,cnt))
|
||||
throw(EXCEPT_PARTITION,8);
|
||||
FSync(bdev->f);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
#define FDC_p0 0
|
||||
#define FDC_p1 1
|
||||
#define FDC_DOR 2
|
||||
#define FDC_p3 3
|
||||
#define FDC_STATUS 4
|
||||
#define FDC_DATA 5
|
||||
#define FDC_DIR 7
|
||||
#define FDC_DCR 7
|
||||
|
||||
void Irq06Handler()
|
||||
{
|
||||
Bts(&sys_irq_flags,6);
|
||||
}
|
||||
|
||||
|
||||
void FDCFlushStatus(LTBlkDev *bdev)
|
||||
{
|
||||
U1 b;
|
||||
I8 i;
|
||||
MemSet(bdev->status,0,32);
|
||||
i=0;
|
||||
while (i<32) {
|
||||
b=InP(bdev->base0+FDC_STATUS);
|
||||
if (b & 0x80) {
|
||||
if (b & 0x40)
|
||||
bdev->status[i++]=InP(bdev->base0+FDC_DATA);
|
||||
else
|
||||
break;
|
||||
}
|
||||
SwapInNext;
|
||||
}
|
||||
if (i==32)
|
||||
throw(EXCEPT_FDC,2);
|
||||
bdev->status[0]=bdev->status[0] & 0xC8; //clear non-error bits
|
||||
bdev->last_jiffy=jiffies;
|
||||
}
|
||||
|
||||
void FDCWaitIrq(LTBlkDev *bdev)
|
||||
{
|
||||
BoolU4 old_flags=GetFlags;
|
||||
Sti;
|
||||
while (!Btr(&sys_irq_flags,bdev->irq)) {
|
||||
/*
|
||||
if (!(InP(bdev->base0+FDC_p0) & 0x80)) //Pending IRQ?
|
||||
throw(EXCEPT_FDC,1);
|
||||
*/
|
||||
SwapInNext;
|
||||
}
|
||||
SetFlags(old_flags);
|
||||
FDCFlushStatus(bdev);
|
||||
}
|
||||
|
||||
|
||||
void FDCSendCmdU1(LTBlkDev *bdev,U1 v)
|
||||
{
|
||||
FDCFlushStatus(bdev);
|
||||
OutP(bdev->base0+FDC_DATA,v);
|
||||
}
|
||||
|
||||
void FDCSeek(LTBlkDev *bdev,U1 cyl, U1 head)
|
||||
{
|
||||
FDCSendCmdU1(bdev,0x0F);
|
||||
FDCSendCmdU1(bdev,head<<2);
|
||||
FDCSendCmdU1(bdev,cyl);
|
||||
FDCWaitIrq(bdev);
|
||||
}
|
||||
|
||||
void FDCFree(LTBlkDev *bdev)
|
||||
{
|
||||
Btr(&sys_irq_busy_flags,bdev->irq);
|
||||
}
|
||||
|
||||
void MonitorFDCTsk()
|
||||
{
|
||||
LTBlkDev *bdev;
|
||||
Preempt(OFF);
|
||||
bdev=Fs->user_aux0;
|
||||
CheckLTBlkDev(bdev);
|
||||
while (TRUE) {
|
||||
if (!Bts(&sys_irq_busy_flags,bdev->irq)) {
|
||||
if (bdev->last_jiffy) {
|
||||
if (jiffies > bdev->last_jiffy+JIFFY_FREQ<<1) {
|
||||
FDCSeek(bdev,0,0);
|
||||
FDCSeek(bdev,0,1);
|
||||
OutP(bdev->base0+FDC_DOR,0x00);
|
||||
bdev->last_jiffy=0;
|
||||
}
|
||||
}
|
||||
FDCFree(bdev);
|
||||
}
|
||||
SwapInNext;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void FDCGet(LTBlkDev *bdev)
|
||||
{
|
||||
CheckLTBlkDev(bdev);
|
||||
while (Bts(&sys_irq_busy_flags,bdev->irq))
|
||||
SwapInNext;
|
||||
Btr(&sys_irq_flags,bdev->irq);
|
||||
|
||||
if (!bdev->last_jiffy) {
|
||||
bdev->last_jiffy=jiffies;
|
||||
OutP(bdev->base0+FDC_DOR,0x00);
|
||||
BusyWait(100);
|
||||
OutP(bdev->base0+FDC_DOR,0x1C); //Motor ON
|
||||
FDCWaitIrq(bdev);
|
||||
OutP(bdev->base0+FDC_DCR,0x00); //step,Load, Unload specs
|
||||
FDCSendCmdU1(bdev,0x03);
|
||||
FDCSendCmdU1(bdev,0xCF);
|
||||
FDCSendCmdU1(bdev,0x10);
|
||||
FDCWaitIrq(bdev);
|
||||
FDCSendCmdU1(bdev,0x07); //Recalibrate
|
||||
FDCSendCmdU1(bdev,0x00);
|
||||
FDCWaitIrq(bdev);
|
||||
}
|
||||
}
|
||||
|
||||
void FDCReset(LTBlkDev *bdev)
|
||||
{
|
||||
CheckLTBlkDev(bdev);
|
||||
OutP(0x0A,0x42); //Shut down old DMA
|
||||
OutP(0x09,0x02);
|
||||
bdev->last_jiffy=0;
|
||||
Btr(&sys_irq_busy_flags,bdev->irq);
|
||||
FDCGet(bdev);
|
||||
}
|
||||
|
||||
BoolU4 FDCReadTrack(LTBlkDev *bdev,U1 cyl, U1 head,U8 blk)
|
||||
{
|
||||
I8 i;
|
||||
U8 size=BLK_SIZE*FDC_DISK_SECTORS-1;
|
||||
BoolU4 old_preempt=Preempt(OFF);
|
||||
CheckLTBlkDev(bdev);
|
||||
|
||||
for (i=0;i<FDC_retries;i++) {
|
||||
FDCSeek(bdev,cyl,head);
|
||||
|
||||
OutP(0x0A,0x42); //Shut down old DMA
|
||||
OutP(0x09,0x02);
|
||||
OutP(0x08,0x00); //ctrl
|
||||
OutP(0x0B,0x56); //mode Read
|
||||
OutP(0x0C,0);
|
||||
OutP(0x04,FDC_DMA_BUF & 0xFF); //addr
|
||||
OutP(0x04,(FDC_DMA_BUF>>8) & 0xFF);
|
||||
OutP(0x81,FDC_DMA_BUF>>16); //set page
|
||||
OutP(0x0C,0);
|
||||
OutP(0x05,size.u1[0]); //cnt
|
||||
OutP(0x05,size.u1[1]);
|
||||
OutP(0x0A,0x02); //Start new DMA
|
||||
OutP(0x09,0x06);
|
||||
|
||||
FDCSendCmdU1(bdev,0x62);
|
||||
FDCSendCmdU1(bdev,head<<2);
|
||||
FDCSendCmdU1(bdev,cyl);
|
||||
FDCSendCmdU1(bdev,head);
|
||||
FDCSendCmdU1(bdev,1); //sector
|
||||
FDCSendCmdU1(bdev,BLK_SIZE>>8);
|
||||
FDCSendCmdU1(bdev,FDC_DISK_SECTORS); //last sec
|
||||
FDCSendCmdU1(bdev,0x1B); //gap
|
||||
FDCSendCmdU1(bdev,0xFF);
|
||||
FDCWaitIrq(bdev);
|
||||
if (bdev->status[0] || bdev->status[1] ||
|
||||
bdev->status[2]) {
|
||||
coutln "FDC Read Error:",bdev->status[2],bdev->status[1],bdev->status[0];
|
||||
FDCReset(bdev);
|
||||
} else {
|
||||
Preempt(old_preempt);
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
coutln "FDC Read Failed!!! Blk:",blk;
|
||||
Preempt(old_preempt);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
BoolU4 FDCRBlks(LTPartition *p,U1 *buf, U8 blk, U8 cnt)
|
||||
{
|
||||
LTCacheBlk *tempc;
|
||||
BoolU4 okay=TRUE;
|
||||
U8 l,blk2;
|
||||
U1 cyl,head,sec;
|
||||
LTBlkDev *bdev=p->bdev;
|
||||
CheckLTBlkDev(bdev);
|
||||
while (cnt>0) {
|
||||
if (bdev->flags & LTBDF_READ_CACHE) {
|
||||
while (cnt) {
|
||||
tempc=LTDCFindBlk(p,blk); //TODO preempt
|
||||
if (tempc) {
|
||||
MemCpy(buf,&tempc->body,BLK_SIZE);
|
||||
cnt--;
|
||||
buf+=BLK_SIZE;
|
||||
blk++;
|
||||
} else
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (cnt) {
|
||||
l=cnt;
|
||||
if (l>bdev->max_reads)
|
||||
l=bdev->max_reads;
|
||||
blk2=blk;
|
||||
sec=blk2%FDC_DISK_SECTORS+1;blk2=blk2/FDC_DISK_SECTORS;
|
||||
head=blk2%FDC_DRIVE_HEADS;
|
||||
cyl=blk2/FDC_DRIVE_HEADS;
|
||||
if (!FDCReadTrack(bdev,cyl,head,blk-(sec-1)))
|
||||
okay=FALSE;
|
||||
MemCpy(buf,FDC_DMA_BUF+BLK_SIZE*(sec-1),l*BLK_SIZE);
|
||||
if (bdev->flags & LTBDF_READ_CACHE)
|
||||
LTDCAdd(DriveToPartition(bdev->partition_base),
|
||||
FDC_DMA_BUF,blk-(sec-1),FDC_DISK_SECTORS);
|
||||
buf+=l*BLK_SIZE;
|
||||
blk+=l;
|
||||
cnt-=l;
|
||||
disk_status_display.u2[0]=disk_status_display.u2[0]-l;
|
||||
}
|
||||
}
|
||||
return okay;
|
||||
}
|
||||
|
||||
BoolU4 FDCWriteBlk2(LTBlkDev *bdev,U1 *buf, U1 cyl, U1 head,U1 sec,U8 blk)
|
||||
{
|
||||
I8 i;
|
||||
U8 size=BLK_SIZE*bdev->max_writes-1;
|
||||
BoolU4 old_preempt;
|
||||
|
||||
old_preempt=Preempt(OFF);
|
||||
for (i=0;i<FDC_retries;i++) { //Retry up to 10 times
|
||||
FDCSeek(bdev,cyl,head);
|
||||
|
||||
MemCpy(FDC_DMA_BUF,buf,size+1);
|
||||
OutP(0x0A,0x42); //Shut down old DMA
|
||||
OutP(0x09,0x02);
|
||||
OutP(0x08,0x00); //ctrl
|
||||
OutP(0x0B,0x5A); //mode Write
|
||||
OutP(0x0C,0);
|
||||
OutP(0x04,FDC_DMA_BUF & 0xFF); //addr
|
||||
OutP(0x04,(FDC_DMA_BUF>>8) & 0xFF);
|
||||
OutP(0x81,FDC_DMA_BUF>>16); //set page
|
||||
OutP(0x0C,0);
|
||||
OutP(0x05,size.u1[0]); //cnt
|
||||
OutP(0x05,size.u1[1]);
|
||||
OutP(0x0A,0x02); //Start new DMA
|
||||
OutP(0x09,0x06);
|
||||
|
||||
FDCSendCmdU1(bdev,0xC5);
|
||||
FDCSendCmdU1(bdev,head<<2);
|
||||
FDCSendCmdU1(bdev,cyl);
|
||||
FDCSendCmdU1(bdev,head);
|
||||
FDCSendCmdU1(bdev,sec);
|
||||
FDCSendCmdU1(bdev,BLK_SIZE>>8);
|
||||
FDCSendCmdU1(bdev,FDC_DISK_SECTORS); //last sec
|
||||
FDCSendCmdU1(bdev,0x1B); //gap
|
||||
FDCSendCmdU1(bdev,0xFF);
|
||||
FDCWaitIrq(bdev);
|
||||
if (bdev->status[2] || bdev->status[1] ||
|
||||
bdev->status[0]) {
|
||||
coutln "FDC Write Error:",bdev->status[0],bdev->status[1],bdev->status[2];
|
||||
FDCReset(bdev);
|
||||
} else {
|
||||
Preempt(old_preempt);
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
coutln "FDC Write Failed!!! Blk:",blk;
|
||||
Preempt(old_preempt);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
BoolU4 FDCWBlks(LTPartition *p,U1 *buf, U8 blk, U8 cnt)
|
||||
{
|
||||
BoolU4 okay=TRUE;
|
||||
U8 l,blk2;
|
||||
U1 cyl,head,sec;
|
||||
LTBlkDev *bdev=p->bdev;
|
||||
CheckLTBlkDev(bdev);
|
||||
while (cnt>0) {
|
||||
l=cnt;
|
||||
if (l>bdev->max_writes)
|
||||
l=bdev->max_writes;
|
||||
blk2=blk;
|
||||
sec=blk2%FDC_DISK_SECTORS+1;blk2=blk2/FDC_DISK_SECTORS;
|
||||
head=blk2%FDC_DRIVE_HEADS;
|
||||
cyl=blk2/FDC_DRIVE_HEADS;
|
||||
if (!FDCWriteBlk2(bdev,buf,cyl,head,sec,blk))
|
||||
okay=FALSE;
|
||||
buf+=l*BLK_SIZE;
|
||||
blk+=l;
|
||||
cnt-=l;
|
||||
disk_status_display.u2[0]=disk_status_display.u2[0]-l;
|
||||
}
|
||||
return okay;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//The following definitions were copied from Linux source code
|
||||
/* ATA/ATAPI Cmds pre T13 Spec */
|
||||
#define WIN_NOP 0x00
|
||||
#define CFA_REQ_EXT_ERROR_CODE 0x03 /* CFA Request Extended Error Code */
|
||||
#define WIN_SRST 0x08 /* ATAPI soft reset cmd */
|
||||
#define WIN_DEV_RESET 0x08
|
||||
#define WIN_RESTORE 0x10
|
||||
#define WIN_READ 0x20 /* 28-Bit */
|
||||
#define WIN_READ_EXT 0x24 /* 48-Bit */
|
||||
#define WIN_READDMA_EXT 0x25 /* 48-Bit */
|
||||
#define WIN_READDMA_QUEUED_EXT 0x26 /* 48-Bit */
|
||||
#define WIN_READ_NATIVE_MAX_EXT 0x27 /* 48-Bit */
|
||||
#define WIN_MULTREAD_EXT 0x29 /* 48-Bit */
|
||||
#define WIN_WRITE 0x30 /* 28-Bit */
|
||||
#define WIN_WRITE_EXT 0x34 /* 48-Bit */
|
||||
#define WIN_WRITEDMA_EXT 0x35 /* 48-Bit */
|
||||
#define WIN_WRITEDMA_QUEUED_EXT 0x36 /* 48-Bit */
|
||||
#define WIN_SET_MAX_EXT 0x37 /* 48-Bit */
|
||||
#define CFA_WRITE_SECT_WO_ERASE 0x38 /* CFA Write Sectors without erase */
|
||||
#define WIN_MULTWRITE_EXT 0x39 /* 48-Bit */
|
||||
#define WIN_WRITE_VERIFY 0x3C /* 28-Bit */
|
||||
#define WIN_VERIFY 0x40 /* 28-Bit - Read Verify Sectors */
|
||||
#define WIN_VERIFY_EXT 0x42 /* 48-Bit */
|
||||
#define WIN_FORMAT 0x50
|
||||
#define WIN_INIT 0x60
|
||||
#define WIN_SEEK 0x70
|
||||
#define CFA_TRANSLATE_SECTOR 0x87 /* CFA Translate Sector */
|
||||
#define WIN_DIAGNOSE 0x90
|
||||
#define WIN_SPECIFY 0x91 /* set Drive geometry translation */
|
||||
#define WIN_DOWNLOAD_MICROCODE 0x92
|
||||
#define WIN_STANDBYNOW2 0x94
|
||||
#define WIN_SETIDLE2 0x97
|
||||
#define WIN_CHECKPOWERMODE2 0x98
|
||||
#define WIN_SLEEPNOW2 0x99
|
||||
#define WIN_PACKETCMD 0xA0 /* Send a packet cmd. */
|
||||
#define WIN_PIDENTIFY 0xA1 /* IDEntify ATAPI dev */
|
||||
#define WIN_QUEUED_SERVICE 0xA2
|
||||
#define WIN_SMART 0xB0 /* self-monitoring and reporting */
|
||||
#define CFA_ERASE_SECTORS 0xC0
|
||||
#define WIN_MULTREAD 0xC4 /* read sectors using multiple mode*/
|
||||
#define WIN_MULTWRITE 0xC5 /* write sectors using multiple mode */
|
||||
#define WIN_SETMULT 0xC6 /* enable/disable multiple mode */
|
||||
#define WIN_READDMA_QUEUED 0xC7 /* read sectors using Queued DMA transfers */
|
||||
#define WIN_READDMA 0xC8 /* read sectors using DMA transfers */
|
||||
#define WIN_WRITEDMA 0xCA /* write sectors using DMA transfers */
|
||||
#define WIN_WRITEDMA_QUEUED 0xCC /* write sectors using Queued DMA transfers */
|
||||
#define CFA_WRITE_MULTI_WO_ERASE 0xCD /* CFA Write multiple without erase */
|
||||
#define WIN_GETMEDIASTATUS 0xDA
|
||||
#define WIN_DOORLOCK 0xDE /* lock door ON removable drives */
|
||||
#define WIN_DOORUNLOCK 0xDF /* unlock door ON removable drives */
|
||||
#define WIN_STANDBYNOW1 0xE0
|
||||
#define WIN_IDLEIMMEDIATE 0xE1 /* force Drive to become "ready" */
|
||||
#define WIN_STANDBY 0xE2 /* Set dev in Standby Mode */
|
||||
#define WIN_SETIDLE1 0xE3
|
||||
#define WIN_READ_BUFFER 0xE4 /* force read only 1 sector */
|
||||
#define WIN_CHECKPOWERMODE1 0xE5
|
||||
#define WIN_SLEEPNOW1 0xE6
|
||||
#define WIN_FLUSH_CACHE 0xE7
|
||||
#define WIN_WRITE_BUFFER 0xE8 /* force write only 1 sector */
|
||||
#define WIN_FLUSH_CACHE_EXT 0xEA /* 48-Bit */
|
||||
#define WIN_IDENTIFY 0xEC /* ask Drive to IDEntify itself */
|
||||
#define WIN_MEDIAELTECT 0xED
|
||||
#define WIN_IDENTIFY_DMA 0xEE /* same as WIN_IDENTIFY, but DMA */
|
||||
#define WIN_SETFEATURES 0xEF /* set special Drive features */
|
||||
#define EXAU1_ENABLE_NEST 0xF0
|
||||
#define WIN_SECURITY_SET_PASS 0xF1
|
||||
#define WIN_SECURITY_UNLOCK 0xF2
|
||||
#define WIN_SECURITY_ERASE_PREPARE 0xF3
|
||||
#define WIN_SECURITY_ERASE_UNIT 0xF4
|
||||
#define WIN_SECURITY_FREEZE_LOCK 0xF5
|
||||
#define WIN_SECURITY_DISABLE 0xF6
|
||||
#define WIN_READ_NATIVE_MAX 0xF8 /* return the native maximum address */
|
||||
#define WIN_SET_MAX 0xF9
|
||||
#define DISABLE_SEAGATE 0xFB
|
||||
|
||||
/* Bits of HD_STATUS */
|
||||
#define ERR_STAT 0x01
|
||||
#define INDEX_STAT 0x02
|
||||
#define ECC_STAT 0x04 /* Corrected error */
|
||||
#define DRQ_STAT 0x08
|
||||
#define SEEK_STAT 0x10
|
||||
#define WRERR_STAT 0x20
|
||||
#define READY_STAT 0x40
|
||||
#define BUSY_STAT 0x80
|
||||
; /*here for compiler bug*/
|
||||
#define BAD_R_STAT (BUSY_STAT | ERR_STAT)
|
||||
#define BAD_W_STAT (BAD_R_STAT | WRERR_STAT)
|
||||
#define BAD_STAT (BAD_R_STAT | DRQ_STAT)
|
||||
#define DRIVE_READY (READY_STAT | SEEK_STAT)
|
||||
#define DATA_READY (DRQ_STAT)
|
||||
|
||||
#define IDE_DATA_REG 0
|
||||
#define IDE_FEATURE_REG 1
|
||||
#define IDE_NSECTOR_REG 2
|
||||
#define IDE_SECTOR_REG 3
|
||||
#define IDE_LCYL_REG 4
|
||||
#define IDE_HCYL_REG 5
|
||||
#define IDE_SELECT_REG 6
|
||||
#define IDE_STATUS 7
|
||||
#define IDE_CMD 7
|
||||
#define IDE_CONTROL_REG 0
|
||||
|
||||
void Irq0EHandler()
|
||||
{
|
||||
Bts(&sys_irq_flags,14);
|
||||
}
|
||||
|
||||
void Irq0FHandler()
|
||||
{
|
||||
Bts(&sys_irq_flags,15);
|
||||
}
|
||||
|
||||
void ATASelectBlk28(LTBlkDev *bdev,U8 blk,U8 cnt)
|
||||
{
|
||||
OutP(bdev->base1+IDE_CONTROL_REG,0x8);
|
||||
OutP(bdev->base0+IDE_SECTOR_REG,blk);
|
||||
OutP(bdev->base0+IDE_NSECTOR_REG,cnt);
|
||||
OutP(bdev->base0+IDE_LCYL_REG,blk.u1[1]);
|
||||
OutP(bdev->base0+IDE_HCYL_REG,blk.u1[2]);
|
||||
OutP(bdev->base0+IDE_SELECT_REG,0xE0|bdev->unit<<4|blk.u1[3]);
|
||||
}
|
||||
|
||||
/*************
|
||||
void ATASelectBlk48(LTBlkDev *bdev,U8 blk,U8 cnt)
|
||||
{//Untested
|
||||
OutP(bdev->base1+IDE_CONTROL_REG,0x8);
|
||||
OutP(bdev->base0+IDE_NSECTOR_REG,cnt.u1[1]);
|
||||
OutP(bdev->base0+IDE_SECTOR_REG,blk_lo.u1[3]);
|
||||
OutP(bdev->base0+IDE_LCYL_REG,blk_hi);
|
||||
OutP(bdev->base0+IDE_HCYL_REG,blk_hi.u1[1]);
|
||||
|
||||
OutP(bdev->base0+IDE_NSECTOR_REG,cnt);
|
||||
OutP(bdev->base0+IDE_SECTOR_REG,blk_lo);
|
||||
OutP(bdev->base0+IDE_LCYL_REG,blk_lo.u1[1]);
|
||||
OutP(bdev->base0+IDE_HCYL_REG,blk_lo.u1[2]);
|
||||
OutP(bdev->base0+IDE_SELECT_REG,0xE0|bdev->unit<<4);
|
||||
}
|
||||
***************/
|
||||
|
||||
void IDEWaitNotBusy(LTBlkDev *bdev)
|
||||
{
|
||||
while (InP(bdev->base0+IDE_STATUS) & BUSY_STAT)
|
||||
SwapInNext;
|
||||
}
|
||||
|
||||
void ATANop(LTBlkDev *bdev)
|
||||
{
|
||||
OutP(bdev->base0+IDE_SELECT_REG,0xE0|bdev->unit<<4);
|
||||
OutP(bdev->base0+IDE_FEATURE_REG,0);
|
||||
OutP(bdev->base0+IDE_CMD,WIN_NOP);
|
||||
IDEWaitNotBusy(bdev);
|
||||
}
|
||||
|
||||
void ATACmd(LTBlkDev *bdev,U1 cmd)
|
||||
{
|
||||
OutP(bdev->base0+IDE_FEATURE_REG,0);
|
||||
OutP(bdev->base0+IDE_CMD,cmd);
|
||||
bdev->last_jiffy=jiffies;
|
||||
}
|
||||
|
||||
/*******
|
||||
U8 ATAPIStat(LTBlkDev *bdev)
|
||||
{
|
||||
return InP(bdev->base0+IDE_STATUS)+
|
||||
256*(InP(bdev->base0+IDE_NSECTOR_REG)+
|
||||
256* InP(bdev->base0+IDE_FEATURE_REG) );
|
||||
}
|
||||
**********/
|
||||
|
||||
void ATAPIWritePktWord(LTBlkDev *bdev,U2 w)
|
||||
{
|
||||
while (!(InP(bdev->base0+IDE_STATUS)&DATA_READY))
|
||||
SwapInNext;
|
||||
OutPW(bdev->base0+IDE_DATA_REG,w.u1[1]+256*w.u1[0]);
|
||||
bdev->last_jiffy=jiffies;
|
||||
}
|
||||
|
||||
void IDEWaitForDrive(LTBlkDev *bdev)
|
||||
{
|
||||
while (Bts(&sys_irq_busy_flags,bdev->irq))
|
||||
SwapInNext;
|
||||
Btr(&sys_irq_flags,bdev->irq);
|
||||
}
|
||||
|
||||
/********
|
||||
void IDEWaitForIrq(LTBlkDev *bdev)
|
||||
{
|
||||
BoolU4 old_flags=GetFlags;
|
||||
Sti;
|
||||
while (!Btr(&sys_irq_flags,bdev->irq))
|
||||
SwapInNext;
|
||||
SetFlags(old_flags);
|
||||
}
|
||||
*********/
|
||||
|
||||
void ATAPISeek(LTBlkDev *bdev,U8 blk)
|
||||
{
|
||||
OutP(bdev->base1+IDE_CONTROL_REG,0x8);
|
||||
OutP(bdev->base0+IDE_SELECT_REG,0xE0|bdev->unit<<4);
|
||||
OutP(bdev->base0+IDE_LCYL_REG,bdev->blk_size);
|
||||
OutP(bdev->base0+IDE_HCYL_REG,bdev->blk_size.u1[1]);
|
||||
ATACmd(bdev,WIN_PACKETCMD);
|
||||
ATAPIWritePktWord(bdev,0x2B00); //Seek
|
||||
ATAPIWritePktWord(bdev,blk>>16);
|
||||
ATAPIWritePktWord(bdev,blk);
|
||||
ATAPIWritePktWord(bdev,0);
|
||||
ATAPIWritePktWord(bdev,0);
|
||||
ATAPIWritePktWord(bdev,0x0000);
|
||||
IDEWaitNotBusy(bdev);
|
||||
}
|
||||
|
||||
void ATAPIStartStop(LTBlkDev *bdev,BoolU4 start)
|
||||
{
|
||||
OutP(bdev->base0+IDE_SELECT_REG,0xE0|bdev->unit<<4);
|
||||
ATACmd(bdev,WIN_PACKETCMD);
|
||||
ATAPIWritePktWord(bdev,0x1B00); //Start/Stop
|
||||
ATAPIWritePktWord(bdev,0x0000);
|
||||
if (start)
|
||||
ATAPIWritePktWord(bdev,0x0100);
|
||||
else
|
||||
ATAPIWritePktWord(bdev,0x0000);
|
||||
ATAPIWritePktWord(bdev,0x0000);
|
||||
ATAPIWritePktWord(bdev,0x0000);
|
||||
ATAPIWritePktWord(bdev,0x0000);
|
||||
IDEWaitNotBusy(bdev);
|
||||
}
|
||||
|
||||
void IDEInit(LTBlkDev *bdev,BoolU4 unlock)
|
||||
{
|
||||
U8 blk=0x0F000000; //TODO:fix this?
|
||||
BoolU4 old_preempt=Preempt(OFF);
|
||||
CheckLTBlkDev(bdev);
|
||||
if (unlock) {
|
||||
Btr(&sys_irq_busy_flags,bdev->irq);
|
||||
IDEWaitForDrive(bdev);
|
||||
}
|
||||
// not using irqs
|
||||
// Btr(&sys_irq_flags,bdev->irq);
|
||||
|
||||
if (!(bdev->flags & LTBDF_HAS_BEEN_RESET)) {
|
||||
OutP(bdev->base0+IDE_SELECT_REG,0xE0|bdev->unit<<4);
|
||||
ATACmd(bdev,WIN_DEV_RESET);
|
||||
IDEWaitNotBusy(bdev);
|
||||
bdev->flags=bdev->flags | LTBDF_HAS_BEEN_RESET;
|
||||
}
|
||||
if (bdev->type==LTBDT_ATA) {
|
||||
OutP(bdev->base0+IDE_SELECT_REG,0xE0|bdev->unit<<4);
|
||||
ATACmd(bdev,WIN_READ_NATIVE_MAX);
|
||||
IDEWaitNotBusy(bdev);
|
||||
//TODO:do this right
|
||||
ATASelectBlk28(bdev,blk,0);
|
||||
ATACmd(bdev,WIN_SET_MAX);
|
||||
IDEWaitNotBusy(bdev);
|
||||
} else {
|
||||
ATAPIStartStop(bdev,TRUE);
|
||||
ATAPISeek(bdev,0);
|
||||
}
|
||||
Btr(&sys_irq_flags,bdev->irq);
|
||||
if (unlock)
|
||||
Btr(&sys_irq_busy_flags,bdev->irq);
|
||||
Preempt(old_preempt);
|
||||
}
|
||||
|
||||
/**********
|
||||
void IDEWaitReady(LTBlkDev *bdev)
|
||||
{
|
||||
U8 i=0;
|
||||
while (!(InP(bdev->base0+IDE_STATUS) & READY_STAT)) {
|
||||
if (!(++i & 0xFFF))
|
||||
IDEInit(bdev,FALSE);
|
||||
ATANop(bdev);
|
||||
SwapInNext;
|
||||
}
|
||||
}
|
||||
***********/
|
||||
|
||||
void ATAPIWaitReady(LTBlkDev *bdev)
|
||||
{
|
||||
U8 pass=0;
|
||||
BoolU4 cont;
|
||||
do {
|
||||
IDEWaitNotBusy(bdev);
|
||||
if (pass)
|
||||
SwapInNext;
|
||||
ATANop(bdev);
|
||||
if (InP(bdev->base0+IDE_STATUS) & READY_STAT) {
|
||||
if (!bdev->last_jiffy || pass>16 ||
|
||||
(jiffies>bdev->last_jiffy+JIFFY_FREQ<<1)) {
|
||||
ATAPIStartStop(bdev,TRUE);
|
||||
}
|
||||
cont=FALSE;
|
||||
} else {
|
||||
if (pass>16)
|
||||
IDEInit(bdev,FALSE);
|
||||
cont=TRUE;
|
||||
}
|
||||
pass++;
|
||||
} while (cont || InP(bdev->base0+IDE_FEATURE_REG));
|
||||
}
|
||||
|
||||
void ATAReadBlks2(LTBlkDev *bdev,U1 *buf, U8 cnt)
|
||||
{
|
||||
U8 U2s_avail,sectors_avail;
|
||||
while (cnt) {
|
||||
while (InP(bdev->base0+IDE_STATUS) & DATA_READY!=DATA_READY)
|
||||
SwapInNext;
|
||||
|
||||
// while (!(sectors_avail=cnt-InP(bdev->base0+IDE_NSECTOR_REG)))
|
||||
// SwapInNext;
|
||||
sectors_avail=1;
|
||||
|
||||
U2s_avail=sectors_avail*BLK_SIZE>>1;
|
||||
RepInSW(buf,U2s_avail,bdev->base0+IDE_DATA_REG);
|
||||
buf+=U2s_avail<<1;
|
||||
cnt-=sectors_avail;
|
||||
}
|
||||
IDEWaitNotBusy(bdev);
|
||||
Btr(&sys_irq_flags,bdev->irq);
|
||||
}
|
||||
|
||||
|
||||
/***********
|
||||
void ATAReadBlksExt(LTBlkDev *bdev,U1 *buf, U8 blk, U8 cnt)
|
||||
{// Untested
|
||||
BoolU4 old_preempt=Preempt(OFF);
|
||||
IDEWaitForDrive(bdev);
|
||||
ATASelectBlk48(bdev,blk,0,cnt);
|
||||
ATACmd(bdev,WIN_MULTREAD_EXT);
|
||||
ATAReadBlks2(bdev,buf,cnt);
|
||||
Btr(&sys_irq_busy_flags,bdev->irq);
|
||||
Preempt(old_preempt);
|
||||
}
|
||||
*************/
|
||||
|
||||
void ATAReadBlks(LTBlkDev *bdev,U1 *buf, U8 blk, U8 cnt)
|
||||
{
|
||||
BoolU4 old_preempt=Preempt(OFF);
|
||||
IDEWaitForDrive(bdev);
|
||||
ATASelectBlk28(bdev,blk,cnt);
|
||||
ATACmd(bdev,WIN_MULTREAD);
|
||||
ATAReadBlks2(bdev,buf,cnt);
|
||||
Btr(&sys_irq_busy_flags,bdev->irq);
|
||||
Preempt(old_preempt);
|
||||
}
|
||||
|
||||
void ATAPIReadBlks2(LTBlkDev *bdev,U1 *buf, U8 blk, U8 cnt)
|
||||
{
|
||||
U8 U2s_avail;
|
||||
U1 *done_add=buf+cnt*bdev->blk_size;
|
||||
BoolU4 old_preempt=Preempt(OFF);
|
||||
|
||||
if (!cnt)
|
||||
return;
|
||||
IDEWaitForDrive(bdev);
|
||||
ATAPIWaitReady(bdev);
|
||||
OutP(bdev->base1+IDE_CONTROL_REG,0x8);
|
||||
OutP(bdev->base0+IDE_SELECT_REG,0xE0|bdev->unit<<4);
|
||||
OutP(bdev->base0+IDE_LCYL_REG,bdev->blk_size);
|
||||
OutP(bdev->base0+IDE_HCYL_REG,bdev->blk_size.u1[1]);
|
||||
ATACmd(bdev,WIN_PACKETCMD);
|
||||
ATAPIWritePktWord(bdev,0xA800);
|
||||
ATAPIWritePktWord(bdev,blk.u2[1]);
|
||||
ATAPIWritePktWord(bdev,blk);
|
||||
ATAPIWritePktWord(bdev,cnt.u2[1]);
|
||||
ATAPIWritePktWord(bdev,cnt);
|
||||
ATAPIWritePktWord(bdev,0x0000);
|
||||
while (buf<done_add) {
|
||||
while (!(InP(bdev->base0+IDE_STATUS) & DATA_READY))
|
||||
SwapInNext;
|
||||
if (U2s_avail=(InP(bdev->base0+IDE_HCYL_REG)<<8+InP(bdev->base0+IDE_LCYL_REG))>>1) {
|
||||
if (buf+U2s_avail<<1>done_add)
|
||||
U2s_avail=(done_add-buf)>>1;
|
||||
RepInSW(buf,U2s_avail,bdev->base0+IDE_DATA_REG);
|
||||
buf+=U2s_avail<<1;
|
||||
}
|
||||
}
|
||||
IDEWaitNotBusy(bdev);
|
||||
// ATAPIStartStop(bdev,FALSE);
|
||||
Btr(&sys_irq_busy_flags,bdev->irq);
|
||||
Preempt(old_preempt);
|
||||
}
|
||||
|
||||
void ATAPIReadBlks(LTBlkDev *bdev,U1 *buf, U8 blk, U8 cnt)
|
||||
{
|
||||
LTPartition *p=DriveToPartition(bdev->partition_base);
|
||||
U8 dv=bdev->blk_size/BLK_SIZE,l,blk2,
|
||||
l2=bdev->max_reads<<1+dv<<1;
|
||||
U1 *cd_buf=MAlloc(BLK_SIZE*l2);
|
||||
if (cnt) {
|
||||
if (blk<=bdev->max_reads)
|
||||
blk2=0;
|
||||
else
|
||||
blk2=((blk-bdev->max_reads)/dv)*dv;
|
||||
if (blk2+l2>p->size)
|
||||
l2=p->size-blk2;
|
||||
l=(l2+dv-1)/dv;
|
||||
ATAPIReadBlks2(bdev,cd_buf,blk2/dv,l);
|
||||
if (bdev->flags & LTBDF_READ_CACHE)
|
||||
LTDCAdd(p,cd_buf,blk2,l*dv);
|
||||
MemCpy(buf,cd_buf+(blk-blk2)*BLK_SIZE,cnt*BLK_SIZE);
|
||||
}
|
||||
Free(cd_buf);
|
||||
}
|
||||
|
||||
void IDERBlks(LTPartition *p,U1 *buf, U8 blk, U8 cnt)
|
||||
{
|
||||
U8 l;
|
||||
LTBlkDev *bdev=p->bdev;
|
||||
CheckLTBlkDev(bdev);
|
||||
while (cnt>0) {
|
||||
l=cnt;
|
||||
if (l>bdev->max_reads)
|
||||
l=bdev->max_reads;
|
||||
if (bdev->type==LTBDT_ATAPI)
|
||||
ATAPIReadBlks(bdev,buf,blk,l);
|
||||
else
|
||||
ATAReadBlks(bdev,buf,blk,l);
|
||||
buf+=l*BLK_SIZE;
|
||||
blk+=l;
|
||||
cnt-=l;
|
||||
disk_status_display.u2[0]=disk_status_display.u2[0]-l;
|
||||
}
|
||||
}
|
||||
|
||||
//This is for low level disk access
|
||||
//Call WBlks() instead
|
||||
void ATAWriteBlks(LTBlkDev *bdev,U1 *buf, U8 blk, U8 cnt)
|
||||
{
|
||||
U8 U2s_avail,sectors_avail;
|
||||
BoolU4 old_preempt=Preempt(OFF);
|
||||
IDEWaitForDrive(bdev);
|
||||
ATASelectBlk28(bdev,blk,cnt);
|
||||
ATACmd(bdev,WIN_MULTWRITE);
|
||||
while (cnt) {
|
||||
while (InP(bdev->base0+IDE_STATUS) & DRIVE_READY!=DRIVE_READY)
|
||||
SwapInNext;
|
||||
while (InP(bdev->base0+IDE_STATUS) & DATA_READY!=DATA_READY)
|
||||
SwapInNext;
|
||||
//TODO
|
||||
sectors_avail=1;
|
||||
U2s_avail=sectors_avail*BLK_SIZE>>1;
|
||||
RepOutSW(buf,U2s_avail,bdev->base0+IDE_DATA_REG);
|
||||
buf+=U2s_avail<<1;
|
||||
cnt-=sectors_avail;
|
||||
}
|
||||
IDEWaitNotBusy(bdev);
|
||||
Btr(&sys_irq_busy_flags,bdev->irq);
|
||||
Preempt(old_preempt);
|
||||
}
|
||||
|
||||
void ATAPISync(LTBlkDev *bdev)
|
||||
{
|
||||
OutP(bdev->base1+IDE_CONTROL_REG,0x8);
|
||||
OutP(bdev->base0+IDE_SELECT_REG,0xE0|bdev->unit<<4);
|
||||
OutP(bdev->base0+IDE_LCYL_REG,bdev->blk_size);
|
||||
OutP(bdev->base0+IDE_HCYL_REG,bdev->blk_size.u1[1]);
|
||||
ATACmd(bdev,WIN_PACKETCMD);
|
||||
ATAPIWritePktWord(bdev,0x3500); //Sync
|
||||
ATAPIWritePktWord(bdev,0x0000);
|
||||
ATAPIWritePktWord(bdev,0x0000);
|
||||
ATAPIWritePktWord(bdev,0x0000);
|
||||
ATAPIWritePktWord(bdev,0x0000);
|
||||
ATAPIWritePktWord(bdev,0x0000);
|
||||
IDEWaitNotBusy(bdev);
|
||||
}
|
||||
|
||||
void ATAPIClose(LTBlkDev *bdev)
|
||||
{
|
||||
OutP(bdev->base1+IDE_CONTROL_REG,0x8);
|
||||
OutP(bdev->base0+IDE_SELECT_REG,0xE0|bdev->unit<<4);
|
||||
OutP(bdev->base0+IDE_LCYL_REG,bdev->blk_size);
|
||||
OutP(bdev->base0+IDE_HCYL_REG,bdev->blk_size.u1[1]);
|
||||
ATACmd(bdev,WIN_PACKETCMD);
|
||||
ATAPIWritePktWord(bdev,0x5B00); //Close
|
||||
ATAPIWritePktWord(bdev,0x0200);
|
||||
ATAPIWritePktWord(bdev,0x0000);
|
||||
ATAPIWritePktWord(bdev,0x0000);
|
||||
ATAPIWritePktWord(bdev,0x0000);
|
||||
ATAPIWritePktWord(bdev,0x0000);
|
||||
IDEWaitNotBusy(bdev);
|
||||
}
|
||||
|
||||
void ATAPIWriteBlks(LTBlkDev *bdev,U1 *buf, U8 blk, U8 cnt)
|
||||
{
|
||||
U8 U2s_avail;
|
||||
U1 *buf2;
|
||||
|
||||
ATAPISeek(bdev,blk);
|
||||
|
||||
OutP(bdev->base0+IDE_FEATURE_REG,0);
|
||||
OutP(bdev->base0+IDE_LCYL_REG,bdev->blk_size);
|
||||
OutP(bdev->base0+IDE_HCYL_REG,bdev->blk_size.u1[1]);
|
||||
OutP(bdev->base0+IDE_SELECT_REG,0xE0|bdev->unit<<4);
|
||||
OutP(bdev->base0+IDE_CMD,WIN_PACKETCMD);
|
||||
ATAPIWritePktWord(bdev,0x0400); //FMT
|
||||
ATAPIWritePktWord(bdev,blk.u2[1]);
|
||||
ATAPIWritePktWord(bdev,blk);
|
||||
ATAPIWritePktWord(bdev,cnt.u2[1]);
|
||||
ATAPIWritePktWord(bdev,cnt);
|
||||
ATAPIWritePktWord(bdev,0x0000);
|
||||
IDEWaitNotBusy(bdev);
|
||||
|
||||
ATAPISeek(bdev,blk);
|
||||
|
||||
OutP(bdev->base1+IDE_CONTROL_REG,0x8);
|
||||
OutP(bdev->base0+IDE_SELECT_REG,0xE0|bdev->unit<<4);
|
||||
OutP(bdev->base0+IDE_LCYL_REG,bdev->blk_size);
|
||||
OutP(bdev->base0+IDE_HCYL_REG,bdev->blk_size.u1[1]);
|
||||
ATACmd(bdev,WIN_PACKETCMD);
|
||||
ATAPIWritePktWord(bdev,0xAA00); //Write
|
||||
ATAPIWritePktWord(bdev,blk.u2[1]);
|
||||
ATAPIWritePktWord(bdev,blk);
|
||||
ATAPIWritePktWord(bdev,cnt.u2[1]);
|
||||
ATAPIWritePktWord(bdev,cnt);
|
||||
ATAPIWritePktWord(bdev,0x0000);
|
||||
buf2=buf+bdev->blk_size*cnt;
|
||||
while (buf<buf2) {
|
||||
while (InP(bdev->base0+IDE_STATUS) & DRIVE_READY!=DRIVE_READY)
|
||||
SwapInNext;
|
||||
while (InP(bdev->base0+IDE_STATUS) & DATA_READY!=DATA_READY)
|
||||
SwapInNext;
|
||||
U2s_avail=(InP(bdev->base0+IDE_HCYL_REG)<<8+InP(bdev->base0+IDE_LCYL_REG))>>1;
|
||||
if (buf+U2s_avail<<1>buf2)
|
||||
U2s_avail=(buf2-buf)>>1;
|
||||
if (U2s_avail) {
|
||||
RepOutSW(buf,U2s_avail,bdev->base0+IDE_DATA_REG);
|
||||
buf+=U2s_avail<<1;
|
||||
}
|
||||
}
|
||||
IDEWaitNotBusy(bdev);
|
||||
}
|
||||
|
||||
//TODO: needs to be fixed so it does more than one blk at
|
||||
//a time when it calls ATAWriteBlks.
|
||||
void IDEWBlks(LTPartition *p,U1 *buf, U8 blk, U8 cnt)
|
||||
{
|
||||
U8 l,dv;
|
||||
LTBlkDev *bdev=p->bdev;
|
||||
CheckLTBlkDev(bdev);
|
||||
dv=bdev->blk_size/BLK_SIZE;
|
||||
if (bdev->type==LTBDT_ATAPI) {
|
||||
IDEWaitForDrive(bdev);
|
||||
ATAPIWaitReady(bdev);
|
||||
}
|
||||
while (cnt>0) {
|
||||
l=cnt;
|
||||
if (l>bdev->max_writes)
|
||||
l=bdev->max_writes;
|
||||
if (bdev->type==LTBDT_ATAPI)
|
||||
ATAPIWriteBlks(bdev,buf,blk/dv,(l+dv-1)/dv);
|
||||
else
|
||||
ATAWriteBlks(bdev,buf,blk,l);
|
||||
buf+=l*BLK_SIZE;
|
||||
blk+=l;
|
||||
cnt-=l;
|
||||
disk_status_display.u2[0]=disk_status_display.u2[0]-l;
|
||||
}
|
||||
if (bdev->type==LTBDT_ATAPI) {
|
||||
ATAPISync(bdev);
|
||||
// ATAPIStartStop(bdev,FALSE);
|
||||
Btr(&sys_irq_busy_flags,bdev->irq);
|
||||
}
|
||||
}
|
||||
|
||||
+1984
File diff suppressed because it is too large.
Load diff
+1014
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,345 @@
|
||||
void InitSysGlbls()
|
||||
{
|
||||
sys_timer=0;
|
||||
jiffies=0;
|
||||
rnd_SEED = 93186752;
|
||||
sys_cur_focus_task=Fs;
|
||||
num_spawned_users=0;
|
||||
compiled_lines=0;
|
||||
ext[EXT_IRQ00]=&SimpleTimerIrq;
|
||||
|
||||
StrCpy(sys_temp_filename,"::/LT/DOC/TEMP.TXZ");
|
||||
|
||||
sys_macro_queue.next=&sys_macro_queue;
|
||||
sys_macro_queue.last=&sys_macro_queue;
|
||||
macro_util_tss=NULL;
|
||||
ip_inhibit_win_operations=FALSE;
|
||||
|
||||
LTDCBase=NULL;
|
||||
LTDCHashTable=NULL;
|
||||
|
||||
exe {
|
||||
I1 *buf,*buf2;
|
||||
LTDate ltdt;
|
||||
|
||||
buf=PmtStr("Start-up Accnt(ENTER will prompt):","");
|
||||
buf2=PmtStr("Wordstat directory list(separated by ';'):","");
|
||||
ExePrintF("sys_startup_account=\"%s\";\r\n",buf);
|
||||
ExePrintF("wordstat_mask=\"%s\";\r\n",buf2);
|
||||
Free(buf);
|
||||
Free(buf2);
|
||||
ltdt=GetCurTimeLTDate;
|
||||
ExePrintF("sys_compile_time=\"%D %T\";\r\n",ltdt.date,ltdt.time);
|
||||
buf=PmtStr("Disk Cache Size (ENTER will use default of %s Bytes):","0x1000000");
|
||||
ExePrintF("LTDCInitCache(%s);",buf);
|
||||
Free(buf);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void AddModuleHash(I1 *name,U8 base)
|
||||
{
|
||||
SysHashEntry *temph,**temph1;
|
||||
temph=MAllocZ(sizeof(SysHashEntry));
|
||||
temph->type=HTT_MODULE|HTT_PUBLIC;
|
||||
temph->use_cnt=0;
|
||||
temph->user0=base;
|
||||
temph->source_link=NULL;
|
||||
temph->string=NewString(name);
|
||||
temph1=FindHashBucket(temph->string,Fs->hash_table);
|
||||
temph->next=*temph1;
|
||||
*temph1=temph;
|
||||
}
|
||||
|
||||
void AddOsMapSymbols()
|
||||
{
|
||||
SysHashEntry *temph,**temph1;
|
||||
I1 *sptr;
|
||||
U1 *ptr;
|
||||
U4 *dd;
|
||||
U8 type;
|
||||
I8 i,code;
|
||||
|
||||
code=sys_boot_base;
|
||||
AddModuleHash("/LT/OSMain/OS",code);
|
||||
ptr=sys_boot_header_base;
|
||||
while ((type=*ptr++)!=EIE_END) { //PASS 1
|
||||
dd=ptr;
|
||||
ptr+=4;
|
||||
i=*dd;
|
||||
sptr=ptr;
|
||||
ptr+=StrLen(sptr)+1;
|
||||
if (type<=EIE_LIT_EXPORT) {
|
||||
temph=MAllocZ(sizeof(SysHashEntry));
|
||||
temph->type=HTT_SYS_SYMBOL;
|
||||
temph->use_cnt=0;
|
||||
temph->user0=i+code;
|
||||
temph->source_link=NULL;
|
||||
temph->string=NewString(sptr);
|
||||
temph1=FindHashBucket(temph->string,Fs->hash_table);
|
||||
temph->next=*temph1;
|
||||
*temph1=temph;
|
||||
} else if (type<EIE_MAIN) {
|
||||
} else if (type==EIE_MAIN) {
|
||||
} else if (type==EIE_ABSOLUTE_ADDRESS) {
|
||||
ptr+=i*sizeof(U4);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
U1 *Load(I1 *filename,BoolU4 no_abs=FALSE)
|
||||
{
|
||||
I1 *fbuf,*fbuf2;
|
||||
U1 *code,*ptr,etype,*bb;
|
||||
I1 *sptr,*absname;
|
||||
U2 *ww;
|
||||
U4 *dd;
|
||||
U8 size,cnt;
|
||||
BinFileHeaderStruct *bfh;
|
||||
I8 i,j,l;
|
||||
SysHashEntry *temph,**temph1,*saved_hash_ptr=NULL;
|
||||
ClassStruct *tempc;
|
||||
GlblVarStruct *tempg;
|
||||
|
||||
fbuf=DefaultExtension(filename,"BIZ");
|
||||
bfh=ReadFile(fbuf,&size); //TODO: align to para
|
||||
code=bfh+sizeof(BinFileHeaderStruct);
|
||||
|
||||
if (ArcCheckSum(bfh,bfh->file_size)!=LT_XSUM)
|
||||
throw(EXCEPT_ARC_XSUM);
|
||||
|
||||
absname=AbsoluteFileName(fbuf);
|
||||
Free(fbuf);
|
||||
fbuf=NewString(absname);
|
||||
fbuf2=NewString(absname);
|
||||
RemoveLastSeg(fbuf,".",fbuf2);
|
||||
if (fbuf[1]==':' && StrLen(fbuf)>2)
|
||||
AddModuleHash(fbuf+2,code);
|
||||
Free(fbuf);
|
||||
Free(fbuf2);
|
||||
|
||||
ptr=bfh+bfh->header_offset;
|
||||
while ((etype=*ptr++)!=EIE_END) { //PASS 1
|
||||
dd=ptr;
|
||||
ptr+=sizeof(U4);
|
||||
i=*dd;
|
||||
sptr=ptr;
|
||||
ptr+=StrLen(sptr)+1;
|
||||
if (etype<=EIE_LIT_EXPORT) {
|
||||
temph=MAllocZ(sizeof(SysHashEntry));
|
||||
temph->string=NewString(sptr);
|
||||
temph->type=HTT_SYS_SYMBOL;
|
||||
temph->use_cnt=0;
|
||||
l=StrLen(absname);
|
||||
temph->source_link=MAlloc(l+4);
|
||||
StrCpy(temph->source_link,"FI:");
|
||||
StrCat(temph->source_link,absname);
|
||||
if (etype==EIE_LIT_EXPORT)
|
||||
temph->user0=i;
|
||||
else
|
||||
temph->user0=i+code;
|
||||
temph1=FindHashBucket(temph->string,Fs->hash_table);
|
||||
temph->next=*temph1;
|
||||
*temph1=temph;
|
||||
} else if (etype<EIE_MAIN) {
|
||||
if (*sptr)
|
||||
saved_hash_ptr=FindLocalHash(sptr,HTT_ALL);
|
||||
if (!saved_hash_ptr)
|
||||
coutln SysText("ST_UNRESOLVED_REFERENCE"),sptr;
|
||||
else {
|
||||
bb=code+i;
|
||||
ww=code+i;
|
||||
dd=code+i;
|
||||
if (saved_hash_ptr->type & HTT_FUNCTION) {
|
||||
tempc=saved_hash_ptr;
|
||||
if (etype & 1)
|
||||
i=tempc->executable_address;
|
||||
else
|
||||
i=tempc->executable_address-code;
|
||||
} else if (saved_hash_ptr->type & HTT_GLBL_VAR) {
|
||||
tempg=saved_hash_ptr;
|
||||
if (etype & 1)
|
||||
i=tempg->data_address;
|
||||
else
|
||||
i=tempg->data_address-code;
|
||||
} else {
|
||||
if (etype & 1)
|
||||
i=saved_hash_ptr->user0;
|
||||
else
|
||||
i=saved_hash_ptr->user0-code;
|
||||
}
|
||||
if (etype<=EIE_LIT_U1)
|
||||
*bb=i+*bb;
|
||||
else if (etype<=EIE_LIT_U2)
|
||||
*ww=i+*ww;
|
||||
else if (etype<=EIE_LIT_U4)
|
||||
*dd=i+*dd;
|
||||
}
|
||||
} else if (etype==EIE_ABSOLUTE_ADDRESS) {
|
||||
if (no_abs)
|
||||
ptr+=i*sizeof(U4);
|
||||
else {
|
||||
cnt=i;
|
||||
for (j=0;j<cnt;j++) {
|
||||
dd=ptr;
|
||||
ptr+=sizeof(U4);
|
||||
dd=code+*dd;
|
||||
*dd+=code;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ptr=bfh+bfh->header_offset;
|
||||
while ((etype=*ptr++)!=EIE_END) { //PASS 2
|
||||
dd=ptr;
|
||||
ptr+=sizeof(U4);
|
||||
i=*dd;
|
||||
sptr=ptr;
|
||||
ptr+=StrLen(sptr)+1;
|
||||
if (etype<=EIE_LIT_EXPORT) {
|
||||
} else if (etype<EIE_MAIN) {
|
||||
} else if (etype==EIE_MAIN) {
|
||||
Run(i+code);
|
||||
} else if (etype==EIE_ABSOLUTE_ADDRESS) {
|
||||
ptr+=sizeof(U4)*i;
|
||||
}
|
||||
}
|
||||
Free(absname);
|
||||
return bfh;
|
||||
}
|
||||
|
||||
void InitTimer()
|
||||
{
|
||||
OutP(0x43,0x34);
|
||||
OutP(0x40,SYS_TIMER0_PERIOD);
|
||||
OutP(0x40,SYS_TIMER0_PERIOD>>8);
|
||||
}
|
||||
|
||||
void InitIrqs()
|
||||
{ //Init 8259
|
||||
OutP(0x20,0x11); //IW1
|
||||
OutP(0xA0,0x11); //IW1
|
||||
PortNop;
|
||||
OutP(0x21,0x20); //IW2
|
||||
OutP(0xA1,0x28); //IW2
|
||||
PortNop;
|
||||
OutP(0x21,0x04); //IW3
|
||||
OutP(0xA1,0x02); //IW3
|
||||
PortNop;
|
||||
OutP(0x21,0x0D); //IW4
|
||||
OutP(0xA1,0x09); //IW4
|
||||
PortNop;
|
||||
OutP(0x21,0x20); //Mask
|
||||
OutP(0xA1,0x2F); //Mask
|
||||
PortNop;
|
||||
}
|
||||
|
||||
GrBitMap *GrBitMapNew(U8 type,U8 width,U8 height)
|
||||
{ //This only allows widths which are divisible by 8
|
||||
GrBitMap *result;
|
||||
result=MAllocZ(sizeof(GrBitMap));
|
||||
result->type=type;
|
||||
result->width=width;
|
||||
result->internal_width=(width+7)&-8;
|
||||
result->height=height;
|
||||
result->left_margin=0;
|
||||
result->right_margin=width;
|
||||
result->top_margin=0;
|
||||
result->bottom_margin=height;
|
||||
switch (type) {
|
||||
case BMT_COLOR4:
|
||||
result->plane_size=(result->internal_width*result->height)>>3;
|
||||
result->body=MAllocZ(result->plane_size<<2);
|
||||
break;
|
||||
case BMT_MONO:
|
||||
result->plane_size=(result->internal_width*result->height)>>3;
|
||||
result->body=MAllocZ(result->plane_size);
|
||||
break;
|
||||
default:
|
||||
throw(EXCEPT_GRAPHICS,1);
|
||||
}
|
||||
result->pen_width=1;
|
||||
result->r=MAllocZ(9<<3);
|
||||
result->r[0].u4[1]=1;
|
||||
result->r[4].u4[1]=1;
|
||||
result->r[8].u4[1]=1;
|
||||
return result;
|
||||
}
|
||||
|
||||
void InitGraphics(I8 mode)
|
||||
{
|
||||
dc_col=0;
|
||||
//TODO reinit VGA without BIOS
|
||||
grmode=mode;
|
||||
grfont=SYS_FONT_8x8;
|
||||
switch (grmode) {
|
||||
case 1:
|
||||
grwidth=640;
|
||||
grheight=480;
|
||||
break;
|
||||
case 2:
|
||||
grwidth=800;
|
||||
grheight=600;
|
||||
break;
|
||||
}
|
||||
//TODO free old allocated stuff
|
||||
grbase=GrBitMapNew(BMT_COLOR4,grwidth,grheight);
|
||||
grbase->flags|=BMF_SCREEN_BITMAP;
|
||||
grbase2=GrBitMapNew(BMT_COLOR4,grwidth+64,grheight+64);
|
||||
grbase2->left_margin=32;
|
||||
grbase2->right_margin=grbase2->internal_width-32;
|
||||
grbase2->top_margin=32;
|
||||
grbase2->bottom_margin=grbase2->height-32;
|
||||
grbase2->flags|=BMF_SCREEN_BITMAP;
|
||||
vga_image=MAllocZ(grwidth*grheight>>1);
|
||||
textbase=MAlloc(grwidth/FONT_WIDTH*(grheight/FONT_HEIGHT)<<2);
|
||||
GrClear2(grbase);
|
||||
ClearWindowText;
|
||||
|
||||
OutP(VGA_SC_INDEX,VGA_MAP_MASK);
|
||||
OutP(VGA_SC_DATA,0x0F);
|
||||
MemSet(0xA0000,0,grheight*grwidth>>3);
|
||||
}
|
||||
|
||||
asm {CP_OS_MAIN:}
|
||||
void OsMain()
|
||||
{
|
||||
void my_AdamStartUpFile();
|
||||
adam_tss=Fs;
|
||||
|
||||
InitTimer;
|
||||
InitIrqs;
|
||||
ext=MAllocZ(EXT_TABLE_SIZE<<2);
|
||||
InitGraphics(grmode);
|
||||
|
||||
$FG,5$//$BK,1$WARNING$BK,0$ do not do cout before here (null ext[])
|
||||
//DbgNum(), DbgStr() are okay, however.$FG$
|
||||
|
||||
coutln "InitSysTask";
|
||||
InitSysTask;
|
||||
coutln "AddOsMapSymbols";
|
||||
AddOsMapSymbols;
|
||||
coutln "InitSysGlbls";
|
||||
InitSysGlbls;
|
||||
coutln "LoadSysStrings";
|
||||
LoadSysStrings;
|
||||
coutln "ENABLE IRQ's";
|
||||
SetFlags(SYS_DEFAULT_FLAGS);
|
||||
InitKeyboard;
|
||||
coutln "InitAllBlkDevs";
|
||||
InitAllBlkDevs;
|
||||
coutln "Select Default Drive";
|
||||
SelectDefaultDrive;
|
||||
cout "Loading Compiler...";
|
||||
|
||||
Cd("/LT/COMPILE");
|
||||
Load("CMP");
|
||||
coutln "Done";
|
||||
my_AdamStartUpFile=FindExtern("AdamStartUpFile");
|
||||
my_AdamStartUpFile();
|
||||
ContinueServantTask; //Never to return
|
||||
}
|
||||
|
||||
asm { ALIGN 16,0x90
|
||||
SYS_CS_SIZE::}
|
||||
@@ -0,0 +1,259 @@
|
||||
//The following font came from FreeDOS
|
||||
ALIGN 8,0x90
|
||||
SYS_FONT_8x8::
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x10,0x00; // SHIFT_SPACE
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00; // SPACE
|
||||
DU1 0x18,0x3c,0x3c,0x18,0x18,0x00,0x18,0x00; // !
|
||||
DU1 0x6C,0x6C,0x6C,0x00,0x00,0x00,0x00,0x00; // "
|
||||
DU1 0x36,0x36,0x7F,0x36,0x7F,0x36,0x36,0x00; // #
|
||||
DU1 0x0C,0x3F,0x68,0x3E,0x0B,0x7E,0x18,0x00; // $$
|
||||
DU1 0x60,0x66,0x0C,0x18,0x30,0x66,0x06,0x00; // %
|
||||
DU1 0x38,0x6C,0x6C,0x38,0x6D,0x66,0x3B,0x00; // &
|
||||
DU1 0x18,0x18,0x18,0x00,0x00,0x00,0x00,0x00; // '
|
||||
DU1 0x0C,0x18,0x30,0x30,0x30,0x18,0x0C,0x00; // (
|
||||
DU1 0x30,0x18,0x0C,0x0C,0x0C,0x18,0x30,0x00; // )
|
||||
DU1 0x00,0x18,0x7E,0x3C,0x7E,0x18,0x00,0x00; // *
|
||||
DU1 0x00,0x18,0x18,0x7E,0x18,0x18,0x00,0x00; // +
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x30; // ,
|
||||
DU1 0x00,0x00,0x00,0x7E,0x00,0x00,0x00,0x00; // -
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x00; // .
|
||||
DU1 0x00,0x06,0x0C,0x18,0x30,0x60,0x00,0x00; // /
|
||||
DU1 0x3C,0x66,0x6E,0x7E,0x76,0x66,0x3C,0x00; // 0
|
||||
DU1 0x18,0x38,0x18,0x18,0x18,0x18,0x7E,0x00; // 1
|
||||
DU1 0x3C,0x66,0x06,0x0C,0x18,0x30,0x7E,0x00; // 2
|
||||
DU1 0x3C,0x66,0x06,0x1C,0x06,0x66,0x3C,0x00; // 3
|
||||
DU1 0x0C,0x1C,0x3C,0x6C,0x7E,0x0C,0x0C,0x00; // 4
|
||||
DU1 0x7E,0x60,0x7C,0x06,0x06,0x66,0x3C,0x00; // 5
|
||||
DU1 0x1C,0x30,0x60,0x7C,0x66,0x66,0x3C,0x00; // 6
|
||||
DU1 0x7E,0x06,0x0C,0x18,0x30,0x30,0x30,0x00; // 7
|
||||
DU1 0x3C,0x66,0x66,0x3C,0x66,0x66,0x3C,0x00; // 8
|
||||
DU1 0x3C,0x66,0x66,0x3E,0x06,0x0C,0x38,0x00; // 9
|
||||
DU1 0x00,0x00,0x18,0x18,0x00,0x18,0x18,0x00; // :
|
||||
DU1 0x00,0x00,0x18,0x18,0x00,0x18,0x18,0x30; // ;
|
||||
DU1 0x0C,0x18,0x30,0x60,0x30,0x18,0x0C,0x00; // <
|
||||
DU1 0x00,0x00,0x7E,0x00,0x7E,0x00,0x00,0x00; // =
|
||||
DU1 0x30,0x18,0x0C,0x06,0x0C,0x18,0x30,0x00; // >
|
||||
DU1 0x3C,0x66,0x0C,0x18,0x18,0x00,0x18,0x00; // ?
|
||||
DU1 0x3C,0x66,0x6E,0x6A,0x6E,0x60,0x3C,0x00; // @
|
||||
DU1 0x3C,0x66,0x66,0x7E,0x66,0x66,0x66,0x00; // A
|
||||
DU1 0x7C,0x66,0x66,0x7C,0x66,0x66,0x7C,0x00; // B
|
||||
DU1 0x3C,0x66,0x60,0x60,0x60,0x66,0x3C,0x00; // C
|
||||
DU1 0x78,0x6C,0x66,0x66,0x66,0x6C,0x78,0x00; // D
|
||||
DU1 0x7E,0x60,0x60,0x7C,0x60,0x60,0x7E,0x00; // E
|
||||
DU1 0x7E,0x60,0x60,0x7C,0x60,0x60,0x60,0x00; // F
|
||||
DU1 0x3C,0x66,0x60,0x6E,0x66,0x66,0x3C,0x00; // G
|
||||
DU1 0x66,0x66,0x66,0x7E,0x66,0x66,0x66,0x00; // H
|
||||
DU1 0x7E,0x18,0x18,0x18,0x18,0x18,0x7E,0x00; // I
|
||||
DU1 0x3E,0x0C,0x0C,0x0C,0x0C,0x6C,0x38,0x00; // J
|
||||
DU1 0x66,0x6C,0x78,0x70,0x78,0x6C,0x66,0x00; // K
|
||||
DU1 0x60,0x60,0x60,0x60,0x60,0x60,0x7E,0x00; // L
|
||||
DU1 0x63,0x77,0x7F,0x6B,0x6B,0x63,0x63,0x00; // M
|
||||
DU1 0x66,0x66,0x76,0x7E,0x6E,0x66,0x66,0x00; // N
|
||||
DU1 0x3C,0x66,0x66,0x66,0x66,0x66,0x3C,0x00; // O
|
||||
DU1 0x7C,0x66,0x66,0x7C,0x60,0x60,0x60,0x00; // P
|
||||
DU1 0x3C,0x66,0x66,0x66,0x6A,0x6C,0x36,0x00; // Q
|
||||
DU1 0x7C,0x66,0x66,0x7C,0x6C,0x66,0x66,0x00; // R
|
||||
DU1 0x3C,0x66,0x60,0x3C,0x06,0x66,0x3C,0x00; // S
|
||||
DU1 0x7E,0x18,0x18,0x18,0x18,0x18,0x18,0x00; // T
|
||||
DU1 0x66,0x66,0x66,0x66,0x66,0x66,0x3C,0x00; // U
|
||||
DU1 0x66,0x66,0x66,0x66,0x66,0x3C,0x18,0x00; // V
|
||||
DU1 0x63,0x63,0x6B,0x6B,0x7F,0x77,0x63,0x00; // W
|
||||
DU1 0x66,0x66,0x3C,0x18,0x3C,0x66,0x66,0x00; // X
|
||||
DU1 0x66,0x66,0x66,0x3C,0x18,0x18,0x18,0x00; // Y
|
||||
DU1 0x7E,0x06,0x0C,0x18,0x30,0x60,0x7E,0x00; // Z
|
||||
DU1 0x7C,0x60,0x60,0x60,0x60,0x60,0x7C,0x00; // [
|
||||
DU1 0x00,0x60,0x30,0x18,0x0C,0x06,0x00,0x00; // \
|
||||
DU1 0x3E,0x06,0x06,0x06,0x06,0x06,0x3E,0x00; // ]
|
||||
DU1 0x3C,0x66,0x00,0x00,0x00,0x00,0x00,0x00; // ^
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xFF; // _
|
||||
DU1 0x30,0x18,0x00,0x00,0x00,0x00,0x00,0x00; // ?
|
||||
DU1 0x00,0x00,0x3C,0x06,0x3E,0x66,0x3E,0x00; // a
|
||||
DU1 0x60,0x60,0x7C,0x66,0x66,0x66,0x7C,0x00; // b
|
||||
DU1 0x00,0x00,0x3C,0x66,0x60,0x66,0x3C,0x00; // c
|
||||
DU1 0x06,0x06,0x3E,0x66,0x66,0x66,0x3E,0x00; // D
|
||||
DU1 0x00,0x00,0x3C,0x66,0x7E,0x60,0x3C,0x00; // e
|
||||
DU1 0x1C,0x30,0x30,0x7C,0x30,0x30,0x30,0x00; // f
|
||||
DU1 0x00,0x00,0x3E,0x66,0x66,0x3E,0x06,0x3C; // g
|
||||
DU1 0x60,0x60,0x7C,0x66,0x66,0x66,0x66,0x00; // h
|
||||
DU1 0x18,0x00,0x38,0x18,0x18,0x18,0x3C,0x00; // i
|
||||
DU1 0x18,0x00,0x38,0x18,0x18,0x18,0x18,0x70; // j
|
||||
DU1 0x60,0x60,0x66,0x6C,0x78,0x6C,0x66,0x00; // k
|
||||
DU1 0x38,0x18,0x18,0x18,0x18,0x18,0x3C,0x00; // l
|
||||
DU1 0x00,0x00,0x36,0x7F,0x6B,0x6B,0x63,0x00; // m
|
||||
DU1 0x00,0x00,0x7C,0x66,0x66,0x66,0x66,0x00; // n
|
||||
DU1 0x00,0x00,0x3C,0x66,0x66,0x66,0x3C,0x00; // o
|
||||
DU1 0x00,0x00,0x7C,0x66,0x66,0x7C,0x60,0x60; // p
|
||||
DU1 0x00,0x00,0x3E,0x66,0x66,0x3E,0x06,0x07; // q
|
||||
DU1 0x00,0x00,0x6C,0x76,0x60,0x60,0x60,0x00; // r
|
||||
DU1 0x00,0x00,0x3E,0x60,0x3C,0x06,0x7C,0x00; // s
|
||||
DU1 0x30,0x30,0x7C,0x30,0x30,0x30,0x1C,0x00; // t
|
||||
DU1 0x00,0x00,0x66,0x66,0x66,0x66,0x3E,0x00; // u
|
||||
DU1 0x00,0x00,0x66,0x66,0x66,0x3C,0x18,0x00; // v
|
||||
DU1 0x00,0x00,0x63,0x6B,0x6B,0x7F,0x36,0x00; // w
|
||||
DU1 0x00,0x00,0x66,0x3C,0x18,0x3C,0x66,0x00; // x
|
||||
DU1 0x00,0x00,0x66,0x66,0x66,0x3E,0x06,0x3C; // y
|
||||
DU1 0x00,0x00,0x7E,0x0C,0x18,0x30,0x7E,0x00; // z
|
||||
DU1 0x0C,0x18,0x18,0x70,0x18,0x18,0x0C,0x00; // {
|
||||
DU1 0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x00; // |
|
||||
DU1 0x30,0x18,0x18,0x0E,0x18,0x18,0x30,0x00; // }
|
||||
DU1 0x31,0x6B,0x46,0x00,0x00,0x00,0x00,0x00; // ~
|
||||
DU1 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF; //
|
||||
DU1 0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24; //128
|
||||
DU1 0x3C,0x3C,0x3C,0x3C,0x3C,0x3C,0x3C,0x3C; //129
|
||||
DU1 0x00,0x00,0xFF,0x00,0x00,0xFF,0x00,0x00; //130
|
||||
DU1 0x00,0x00,0xFF,0xFF,0xFF,0xFF,0x00,0x00; //131
|
||||
DU1 0x00,0x00,0x3F,0x20,0x20,0x27,0x24,0x24; //132
|
||||
DU1 0x00,0x00,0x3F,0x3F,0x3F,0x3F,0x3C,0x3C; //133
|
||||
DU1 0x00,0x00,0xFC,0x04,0x04,0xE4,0x24,0x24; //134
|
||||
DU1 0x00,0x00,0xFC,0xFC,0xFC,0xFC,0x3C,0x3C; //135
|
||||
DU1 0x24,0x24,0x27,0x20,0x20,0x3F,0x00,0x00; //136
|
||||
DU1 0x3C,0x3C,0x3F,0x3F,0x3F,0x3F,0x00,0x00; //137
|
||||
DU1 0x24,0x24,0xE4,0x04,0x04,0xFC,0x00,0x00; //138
|
||||
DU1 0x3C,0x3C,0xFC,0xFC,0xFC,0xFC,0x00,0x00; //139
|
||||
DU1 0x00,0x7E,0x7E,0x66,0x66,0x7E,0x7E,0x00; //140
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x22,0x88,0x22,0x88,0x22,0x88,0x22,0x88;
|
||||
DU1 0x55,0xaa,0x55,0xaa,0x55,0xaa,0x55,0xaa;
|
||||
DU1 0xdd,0x77,0xdd,0x77,0xdd,0x77,0xdd,0x77;
|
||||
DU1 0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18;
|
||||
DU1 0x18,0x18,0x18,0xf8,0x18,0x18,0x18,0x18;
|
||||
DU1 0x18,0x18,0xf8,0x18,0xf8,0x18,0x18,0x18;
|
||||
DU1 0x66,0x66,0x66,0xe6,0x66,0x66,0x66,0x66;
|
||||
DU1 0x00,0x00,0x00,0xfe,0x66,0x66,0x66,0x66;
|
||||
DU1 0x00,0x00,0xf8,0x18,0xf8,0x18,0x18,0x18;
|
||||
DU1 0x66,0x66,0xe6,0x06,0xe6,0x66,0x66,0x66;
|
||||
DU1 0x66,0x66,0x66,0x66,0x66,0x66,0x66,0x66;
|
||||
DU1 0x00,0x00,0xfe,0x06,0xe6,0x66,0x66,0x66;
|
||||
DU1 0x66,0x66,0xe6,0x06,0xfe,0x00,0x00,0x00;
|
||||
DU1 0x66,0x66,0x66,0xfe,0x00,0x00,0x00,0x00;
|
||||
DU1 0x18,0x18,0xf8,0x18,0xf8,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0xf8,0x18,0x18,0x18,0x18;
|
||||
DU1 0x18,0x18,0x18,0x1f,0x00,0x00,0x00,0x00;
|
||||
DU1 0x18,0x18,0x18,0xff,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0xff,0x18,0x18,0x18,0x18;
|
||||
DU1 0x18,0x18,0x18,0x1f,0x18,0x18,0x18,0x18;
|
||||
DU1 0x00,0x00,0x00,0xff,0x00,0x00,0x00,0x00;
|
||||
DU1 0x18,0x18,0x18,0xff,0x18,0x18,0x18,0x18;
|
||||
DU1 0x18,0x18,0x1f,0x18,0x1f,0x18,0x18,0x18;
|
||||
DU1 0x66,0x66,0x66,0x67,0x66,0x66,0x66,0x66;
|
||||
DU1 0x66,0x66,0x67,0x60,0x7f,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x7f,0x60,0x67,0x66,0x66,0x66;
|
||||
DU1 0x66,0x66,0xe7,0x00,0xff,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0xff,0x00,0xe7,0x66,0x66,0x66;
|
||||
DU1 0x66,0x66,0x67,0x60,0x67,0x66,0x66,0x66;
|
||||
DU1 0x00,0x00,0xff,0x00,0xff,0x00,0x00,0x00;
|
||||
DU1 0x66,0x66,0xe7,0x00,0xe7,0x66,0x66,0x66;
|
||||
DU1 0x18,0x18,0xff,0x00,0xff,0x00,0x00,0x00;
|
||||
DU1 0x66,0x66,0x66,0xff,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0xff,0x00,0xff,0x18,0x18,0x18;
|
||||
DU1 0x00,0x00,0x00,0xff,0x66,0x66,0x66,0x66;
|
||||
DU1 0x66,0x66,0x66,0x7f,0x00,0x00,0x00,0x00;
|
||||
DU1 0x18,0x18,0x1f,0x18,0x1f,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x1f,0x18,0x1f,0x18,0x18,0x18;
|
||||
DU1 0x00,0x00,0x00,0x7f,0x66,0x66,0x66,0x66;
|
||||
DU1 0x66,0x66,0x66,0xff,0x66,0x66,0x66,0x66;
|
||||
DU1 0x18,0x18,0xff,0x18,0xff,0x18,0x18,0x18;
|
||||
DU1 0x18,0x18,0x18,0xf8,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x1f,0x18,0x18,0x18,0x18;
|
||||
DU1 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff;
|
||||
DU1 0x00,0x00,0x00,0x00,0xff,0xff,0xff,0xff;
|
||||
DU1 0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0;
|
||||
DU1 0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f;
|
||||
DU1 0xff,0xff,0xff,0xff,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
DU1 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00;
|
||||
@@ -0,0 +1,887 @@
|
||||
ALIGN 8,0x90
|
||||
IRQ_VECTORS::
|
||||
DU4 IRQ00,IRQ01,IRQ02,IRQ03;
|
||||
DU4 IRQ04,IRQ05,IRQ06,IRQ07;
|
||||
DU4 IRQ08,IRQ09,IRQ0A,IRQ0B;
|
||||
DU4 IRQ0C,IRQ0D,IRQ0E,IRQ0F;
|
||||
DU4 IRQ10,IRQ11,IRQ12,IRQ13;
|
||||
DU4 IRQ14,IRQ15,IRQ16,IRQ17;
|
||||
DU4 IRQ18,IRQ19,IRQ1A,IRQ1B;
|
||||
DU4 IRQ1C,IRQ1D,IRQ1E,IRQ1F;
|
||||
DU4 IRQ20,IRQ21,IRQ22,IRQ23;
|
||||
DU4 IRQ24,IRQ25,IRQ26,IRQ27;
|
||||
DU4 IRQ28,IRQ29,IRQ2A,IRQ2B;
|
||||
DU4 IRQ2C,IRQ2D,IRQ2E,IRQ2F;
|
||||
DU4 IRQ30,IRQ31,IRQ32,IRQ33;
|
||||
DU4 IRQ34,IRQ35,IRQ36,IRQ37;
|
||||
DU4 IRQ38,IRQ39,IRQ3A,IRQ3B;
|
||||
DU4 IRQ3C,IRQ3D,IRQ3E,IRQ3F;
|
||||
DU4 IRQ40,IRQ41,IRQ42,IRQ43;
|
||||
DU4 IRQ44,IRQ45,IRQ46,IRQ47;
|
||||
DU4 IRQ48,IRQ49,IRQ4A,IRQ4B;
|
||||
DU4 IRQ4C,IRQ4D,IRQ4E,IRQ4F;
|
||||
DU4 IRQ50,IRQ51,IRQ52,IRQ53;
|
||||
DU4 IRQ54,IRQ55,IRQ56,IRQ57;
|
||||
DU4 IRQ58,IRQ59,IRQ5A,IRQ5B;
|
||||
DU4 IRQ5C,IRQ5D,IRQ5E,IRQ5F;
|
||||
|
||||
////***************** INTERRUPT ROUTINES ***************
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ00: PUSHAD
|
||||
MOV EDX,0
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ01: PUSHAD
|
||||
MOV EDX,1
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ02: PUSHAD
|
||||
MOV EDX,2
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ03: PUSHAD
|
||||
MOV EDX,3
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ04: PUSHAD
|
||||
MOV EDX,4
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ05: PUSHAD
|
||||
MOV EDX,5
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ06: PUSHAD
|
||||
MOV EDX,6
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ07: PUSHAD
|
||||
MOV EDX,7
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ08: PUSHAD
|
||||
MOV EDX,8
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ09: PUSHAD
|
||||
MOV EDX,9
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ0A: PUSHAD
|
||||
MOV EDX,0x0A
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ0B: PUSHAD
|
||||
MOV EDX,0x0B
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ0C: PUSHAD
|
||||
MOV EDX,0x0C
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ0D: PUSHAD
|
||||
MOV EDX,0x0D
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ0E: PUSHAD
|
||||
MOV EDX,0x0E
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ0F: PUSHAD
|
||||
MOV EDX,0x0F
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ10: PUSHAD
|
||||
MOV EDX,0x10
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ11: PUSHAD
|
||||
MOV EDX,0x11
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ12: PUSHAD
|
||||
MOV EDX,0x12
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ13: PUSHAD
|
||||
MOV EDX,0x13
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ14: PUSHAD
|
||||
MOV EDX,0x14
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ15: PUSHAD
|
||||
MOV EDX,0x15
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ16: PUSHAD
|
||||
MOV EDX,0x16
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ17: PUSHAD
|
||||
MOV EDX,0x17
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ18: PUSHAD
|
||||
MOV EDX,0x18
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ19: PUSHAD
|
||||
MOV EDX,0x19
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ1A: PUSHAD
|
||||
MOV EDX,0x1A
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ1B: PUSHAD
|
||||
MOV EDX,0x1B
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ1C: PUSHAD
|
||||
MOV EDX,0x1C
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ1D: PUSHAD
|
||||
MOV EDX,0x1D
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ1E: PUSHAD
|
||||
MOV EDX,0x1E
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ1F: PUSHAD
|
||||
MOV EDX,0x1F
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ20: STI
|
||||
CLD
|
||||
PUSHAD
|
||||
MOV EAX,U4 [SYS_EXTERN_TABLE]
|
||||
MOV EAX,U4 EXT_IRQ00*4[EAX]
|
||||
OR EAX,EAX
|
||||
JZ @@2
|
||||
MOV EBP,ESP
|
||||
PUSH 0
|
||||
PUSH U4 SP_EIP[EBP]
|
||||
CALL EAX
|
||||
ADD ESP,8
|
||||
@@2: MOV AL,0x20 //ACKNOWLEDGE INTERRUPT
|
||||
OUT 0x20,AL
|
||||
POPAD
|
||||
BT U4 [SYS_FLAGS],SYSf_PREEMPTIVE
|
||||
JC IRQ_SWAP_IN_NEXT
|
||||
IRET
|
||||
|
||||
IRQ_SWAP_IN_NEXT:
|
||||
CLI
|
||||
CALL SAVE_CONTEXT //PREEMPTIVE
|
||||
|
||||
MOV EBP,ESP
|
||||
MOV EAX,[EBP]
|
||||
MOV U4 FS:[TSS_EIP],EAX
|
||||
MOV EAX,8[EBP]
|
||||
MOV U4 FS:[TSS_EFLAGS],EAX
|
||||
ADD EBP,12
|
||||
MOV U4 FS:[TSS_ESP],EBP
|
||||
|
||||
MOV ESI,U4 FS:[TSS_NEXT_TSS]
|
||||
MOV AX,U2 TSS_FS[ESI]
|
||||
MOV FS,AX
|
||||
JMP U4 SWAP_IN_NEXT_PART2
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ21:: CLD
|
||||
PUSHAD
|
||||
CALL U4 CP_KBD_HANDLER+4
|
||||
MOV AL,0x20 //ACKNOWLEDGE INTERRUPT
|
||||
OUT 0x20,AL
|
||||
POPAD
|
||||
IRET
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ22: PUSHAD
|
||||
MOV EDX,0x22
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ23: CLD
|
||||
PUSHAD
|
||||
MOV EAX,U4 [SYS_EXTERN_TABLE]
|
||||
MOV EAX,U4 EXT_IRQ03*4[EAX]
|
||||
OR EAX,EAX
|
||||
JZ @@231
|
||||
CALL EAX
|
||||
@@231: MOV AL,0x20 //ACKNOWLEDGE INTERRUPT
|
||||
OUT 0x20,AL
|
||||
POPAD
|
||||
IRET
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ24: CLD
|
||||
PUSHAD
|
||||
MOV EAX,U4 [SYS_EXTERN_TABLE]
|
||||
MOV EAX,U4 EXT_IRQ04*4[EAX]
|
||||
OR EAX,EAX
|
||||
JZ @@241
|
||||
CALL EAX
|
||||
@@241: MOV AL,0x20 //ACKNOWLEDGE INTERRUPT
|
||||
OUT 0x20,AL
|
||||
POPAD
|
||||
IRET
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ25: PUSHAD
|
||||
MOV EDX,0x25
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ26: CLD
|
||||
PUSHAD
|
||||
MOV EAX,U4 [SYS_EXTERN_TABLE]
|
||||
MOV EAX,U4 EXT_IRQ06*4[EAX]
|
||||
OR EAX,EAX
|
||||
JZ @@261
|
||||
CALL EAX
|
||||
@@261: MOV AL,0x20 //ACKNOWLEDGE INTERRUPT
|
||||
OUT 0x20,AL
|
||||
POPAD
|
||||
IRET
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ27: CLD
|
||||
PUSHAD
|
||||
MOV EAX,U4 [SYS_EXTERN_TABLE]
|
||||
MOV EAX,U4 EXT_IRQ07*4[EAX]
|
||||
OR EAX,EAX
|
||||
JZ @@271
|
||||
CALL EAX
|
||||
@@271: MOV AL,0x20 //ACKNOWLEDGE INTERRUPT
|
||||
OUT 0x20,AL
|
||||
POPAD
|
||||
IRET
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ28: PUSHAD
|
||||
MOV EDX,0x28
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ29: PUSHAD
|
||||
MOV EDX,0x29
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ2A: PUSHAD
|
||||
MOV EDX,0x2A
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ2B: PUSHAD
|
||||
MOV EDX,0x2B
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ2C: CLD
|
||||
PUSHAD
|
||||
MOV EAX,U4 [SYS_EXTERN_TABLE]
|
||||
MOV EAX,U4 EXT_IRQ0C*4[EAX]
|
||||
OR EAX,EAX
|
||||
JZ @@2C1
|
||||
CALL EAX
|
||||
@@2C1: MOV AL,0x20
|
||||
OUT 0xA0,AL
|
||||
MOV AL,0x20
|
||||
OUT 0x20,AL
|
||||
POPAD
|
||||
IRET
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ2D: PUSHAD
|
||||
MOV EDX,0x2D
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ2E: CLD
|
||||
PUSHAD
|
||||
MOV EAX,U4 [SYS_EXTERN_TABLE]
|
||||
MOV EAX,U4 EXT_IRQ0E*4[EAX]
|
||||
OR EAX,EAX
|
||||
JZ @@2E1
|
||||
CALL EAX
|
||||
@@2E1: MOV AL,0x20
|
||||
OUT 0xA0,AL
|
||||
MOV AL,0x20
|
||||
OUT 0x20,AL
|
||||
POPAD
|
||||
IRET
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ2F: CLD
|
||||
PUSHAD
|
||||
MOV EAX,U4 [SYS_EXTERN_TABLE]
|
||||
MOV EAX,U4 EXT_IRQ0F*4[EAX]
|
||||
OR EAX,EAX
|
||||
JZ @@2F1
|
||||
CALL EAX
|
||||
@@2F1: MOV AL,0x20
|
||||
OUT 0xA0,AL
|
||||
MOV AL,0x20
|
||||
OUT 0x20,AL
|
||||
POPAD
|
||||
IRET
|
||||
|
||||
//************************************ SOFTWARE INT'S ******************************
|
||||
TEST_AND_ENABLE_IRQS:
|
||||
PUSH EBP
|
||||
MOV EBP,ESP
|
||||
//16[ebp]=flags
|
||||
//12[ebp]=cs
|
||||
// 8[ebp]=iret
|
||||
// 4[ebp]=ret
|
||||
// 0[ebp]=ebp
|
||||
BT U4 16[EBP],9
|
||||
JNC @@TEI1
|
||||
STI
|
||||
@@TEI1: POP EBP
|
||||
RET
|
||||
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ30: CALL TEST_AND_ENABLE_IRQS
|
||||
PUSHAD
|
||||
PUSH 0
|
||||
PUSH ESI
|
||||
CALL CP_PUT_SYSTEXT+4
|
||||
ADD ESP,8
|
||||
POPAD
|
||||
IRET
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ31: CALL TEST_AND_ENABLE_IRQS
|
||||
PUSHAD
|
||||
CALL PUT_I1
|
||||
POPAD
|
||||
IRET
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ32: CALL TEST_AND_ENABLE_IRQS
|
||||
PUSHAD
|
||||
MOV ESI,MSG_GETCHAR
|
||||
CALL FIND_EXTERN
|
||||
JNZ @@3210
|
||||
CALL GET_KEY
|
||||
INT I_PUT_I1
|
||||
XOR EDX,EDX
|
||||
JMP @@3220
|
||||
@@3210: PUSH 0
|
||||
PUSH 0
|
||||
CALL ESI
|
||||
ADD ESP,8
|
||||
@@3220: MOV EBP,ESP
|
||||
MOV U4 SP_EAX[EBP],EAX
|
||||
MOV U4 SP_EDX[EBP],EDX
|
||||
POPAD
|
||||
IRET
|
||||
|
||||
|
||||
COUT_JOIN::
|
||||
OR EBX,EBX
|
||||
JZ U4 @@100
|
||||
@@20: MOV EDX,U4 [EBP]
|
||||
MOV EAX,U4 8[EBP]
|
||||
PUSHAD
|
||||
|
||||
CMP EDX,IT_NUM_IT+IT_I1
|
||||
JNE @@25
|
||||
PUSH ESI
|
||||
MOV ESI,EAX
|
||||
CALL PUT_STRING
|
||||
POP ESI
|
||||
JMP @@29
|
||||
@@25: CMP EDX,IT_U8
|
||||
JE @@26
|
||||
CMP EDX,IT_I8
|
||||
JNE @@24
|
||||
@@26: MOV EAX,U4 12[EBP]
|
||||
CALL PUT_HEX
|
||||
MOV EAX,U4 8[EBP]
|
||||
CALL PUT_HEX
|
||||
JMP @@29
|
||||
@@24: CMP EDX,IT_U4
|
||||
JE @@21
|
||||
CMP EDX,IT_I4
|
||||
JNE @@21A
|
||||
@@21: CALL PUT_HEX
|
||||
JMP @@29
|
||||
@@21A: CMP EDX,IT_U2
|
||||
JE @@22
|
||||
CMP EDX,IT_I2
|
||||
JNE @@22A
|
||||
@@22: CALL PUT_HEX_U2
|
||||
JMP @@29
|
||||
@@22A: CMP EDX,IT_U1
|
||||
JNE @@23
|
||||
CALL PUT_HEX_U1
|
||||
JMP @@29
|
||||
@@23: CMP EDX,IT_DOUBLE
|
||||
JNE @@30
|
||||
PUSH U4 12[EBP]
|
||||
PUSH U4 8[EBP]
|
||||
CALL CP_PUT_FLOAT+4
|
||||
ADD ESP,8
|
||||
JMP @@29
|
||||
@@30: CMP EDX,IT_I1
|
||||
JNE @@21
|
||||
CALL PUT_I1
|
||||
|
||||
@@29: POPAD
|
||||
SUB EBP,16
|
||||
DEC EBX
|
||||
JNZ U4 @@20
|
||||
@@100: RET
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ33:: CALL TEST_AND_ENABLE_IRQS //COUT
|
||||
PUSH EBP
|
||||
MOV EBP,ESP
|
||||
MOV EBX,EAX //GET PARAM CNT
|
||||
ADD EBX,EBX
|
||||
LEA EBP,16-16[EBP+EBX*8]
|
||||
MOV EBX,EAX //GET PARAM CNT
|
||||
CALL COUT_JOIN
|
||||
POP EBP
|
||||
IRET
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ34: CALL TEST_AND_ENABLE_IRQS
|
||||
PUSHAD
|
||||
SUB ESP,16 //Space for param1 & param2
|
||||
PUSH EDX //mask
|
||||
PUSH EAX //mask
|
||||
MOV EAX,ESP
|
||||
ADD EAX,16
|
||||
PUSH 0
|
||||
PUSH 0
|
||||
PUSH 0 //¶m2
|
||||
PUSH EAX //¶m2
|
||||
SUB EAX,8
|
||||
PUSH 0 //¶m1
|
||||
PUSH EAX //¶m1
|
||||
MOV ESI,MSG_PEEK_MSG
|
||||
CALL FIND_EXTERN
|
||||
CALL ESI
|
||||
ADD ESP,32
|
||||
POP EBX //param1
|
||||
ADD ESP,4
|
||||
POP EDX //param2
|
||||
ADD ESP,4
|
||||
MOV EBP,ESP
|
||||
MOV U4 SP_EAX[EBP],EAX
|
||||
MOV U4 SP_EBX[EBP],EBX
|
||||
MOV U4 SP_EDX[EBP],EDX
|
||||
POPAD
|
||||
IRET
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ35: CALL TEST_AND_ENABLE_IRQS
|
||||
PUSHAD
|
||||
SUB ESP,16 //Space for param1 & param2
|
||||
PUSH EDX //mask
|
||||
PUSH EAX //mask
|
||||
MOV EAX,ESP
|
||||
ADD EAX,16
|
||||
PUSH 0
|
||||
PUSH 0
|
||||
PUSH 0 //¶m2
|
||||
PUSH EAX //¶m2
|
||||
SUB EAX,8
|
||||
PUSH 0 //¶m1
|
||||
PUSH EAX //¶m1
|
||||
MOV ESI,MSG_GET_MSG_NO_WAIT
|
||||
CALL FIND_EXTERN
|
||||
CALL ESI
|
||||
ADD ESP,32
|
||||
POP EBX //param1
|
||||
ADD ESP,4
|
||||
POP EDX //param2
|
||||
MOV EBP,ESP
|
||||
ADD ESP,4
|
||||
MOV U4 SP_EAX[EBP],EAX
|
||||
MOV U4 SP_EBX[EBP],EBX
|
||||
MOV U4 SP_EDX[EBP],EDX
|
||||
POPAD
|
||||
IRET
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ36:: CALL TEST_AND_ENABLE_IRQS
|
||||
PUSHAD
|
||||
MOV ESI,MSG_FLUSH_MSGS
|
||||
CALL FIND_EXTERN
|
||||
XOR EAX,EAX
|
||||
OR ESI,ESI
|
||||
JZ @@1
|
||||
CALL ESI
|
||||
@@1: MOV EBP,ESP
|
||||
MOV U4 SP_EDX[EBP],EDX
|
||||
MOV U4 SP_EAX[EBP],EAX
|
||||
POPAD
|
||||
IRET
|
||||
|
||||
CP_FLUSH_MSGS::
|
||||
INT I_FLUSH_MSGS
|
||||
RET
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ37: CALL TEST_AND_ENABLE_IRQS
|
||||
PUSHAD
|
||||
SUB ESP,16 //Space for param1 & param2
|
||||
PUSH EDX //mask
|
||||
PUSH EAX //mask
|
||||
MOV EAX,ESP
|
||||
ADD EAX,16
|
||||
PUSH 0
|
||||
PUSH 0
|
||||
PUSH 0 //¶m2
|
||||
PUSH EAX //¶m2
|
||||
SUB EAX,8
|
||||
PUSH 0 //¶m1
|
||||
PUSH EAX //¶m1
|
||||
MOV ESI,MSG_GET_MSG
|
||||
CALL FIND_EXTERN
|
||||
CALL ESI
|
||||
ADD ESP,32
|
||||
POP EBX //param1
|
||||
ADD ESP,4
|
||||
POP EDX //param2
|
||||
ADD ESP,4
|
||||
MOV EBP,ESP
|
||||
MOV U4 SP_EAX[EBP],EAX
|
||||
MOV U4 SP_EBX[EBP],EBX
|
||||
MOV U4 SP_EDX[EBP],EDX
|
||||
POPAD
|
||||
IRET
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ38:: CALL TEST_AND_ENABLE_IRQS
|
||||
CALL PUT_STRING
|
||||
IRET
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ39:: CALL TEST_AND_ENABLE_IRQS
|
||||
PUSH EBP
|
||||
MOV EBP,ESP
|
||||
MOV EBX,EAX //GET PARAM CNT
|
||||
ADD EBX,EBX
|
||||
LEA EBP,16-16[EBP+EBX*8]
|
||||
MOV EBX,EAX //GET PARAM CNT
|
||||
CALL COUT_JOIN
|
||||
CALL CRLF
|
||||
POP EBP
|
||||
IRET
|
||||
|
||||
ALIGN 8,0x90 //I_DEBUG
|
||||
IRQ3A:: CLI
|
||||
CLD
|
||||
PUSHAD
|
||||
CALL SAVE_CONTEXT
|
||||
MOV EAX,U4 [SYS_EXTERN_TABLE]
|
||||
MOV EAX,U4 EXT_DEBUG*4[EAX]
|
||||
OR EAX,EAX
|
||||
JZ @@3A1
|
||||
CALL EAX
|
||||
@@3A1: POPAD
|
||||
IRET
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ3B: PUSHAD
|
||||
MOV EDX,0x3B
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ3C: PUSHAD
|
||||
MOV EDX,0x3C
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ3D: PUSHAD
|
||||
MOV EDX,0x3D
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ3E: PUSHAD
|
||||
MOV EDX,0x3E
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ3F: PUSHAD
|
||||
MOV EDX,0x3F
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ40: PUSHAD
|
||||
MOV EDX,0x40
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ41: PUSHAD
|
||||
MOV EDX,0x41
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ42: PUSHAD
|
||||
MOV EDX,0x42
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ43: PUSHAD
|
||||
MOV EDX,0x43
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ44: PUSHAD
|
||||
MOV EDX,0x44
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ45: PUSHAD
|
||||
MOV EDX,0x45
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ46: PUSHAD
|
||||
MOV EDX,0x46
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ47: PUSHAD
|
||||
MOV EDX,0x47
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ48: PUSHAD
|
||||
MOV EDX,0x48
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ49: PUSHAD
|
||||
MOV EDX,0x49
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ4A: PUSHAD
|
||||
MOV EDX,0x4A
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ4B: PUSHAD
|
||||
MOV EDX,0x4B
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ4C: PUSHAD
|
||||
MOV EDX,0x4C
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ4D: PUSHAD
|
||||
MOV EDX,0x4D
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ4E: PUSHAD
|
||||
MOV EDX,0x4E
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ4F: PUSHAD
|
||||
MOV EDX,0x4F
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ50: PUSHAD
|
||||
MOV EDX,0x50
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ51: PUSHAD
|
||||
MOV EDX,0x51
|
||||
JMP U4 IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ52: PUSHAD
|
||||
MOV EDX,0x52
|
||||
JMP IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ53: PUSHAD
|
||||
MOV EDX,0x53
|
||||
JMP IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ54: PUSHAD
|
||||
MOV EDX,0x54
|
||||
JMP IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ55: PUSHAD
|
||||
MOV EDX,0x55
|
||||
JMP IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ56: PUSHAD
|
||||
MOV EDX,0x56
|
||||
JMP IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ57: PUSHAD
|
||||
MOV EDX,0x57
|
||||
JMP IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ58: PUSHAD
|
||||
MOV EDX,0x58
|
||||
JMP IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ59: PUSHAD
|
||||
MOV EDX,0x59
|
||||
JMP IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ5A: PUSHAD
|
||||
MOV EDX,0x5A
|
||||
JMP IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ5B: PUSHAD
|
||||
MOV EDX,0x5B
|
||||
JMP IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ5C: PUSHAD
|
||||
MOV EDX,0x5C
|
||||
JMP IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ5D: PUSHAD
|
||||
MOV EDX,0x5D
|
||||
JMP IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ5E: PUSHAD
|
||||
MOV EDX,0x5E
|
||||
JMP IRQFAULT
|
||||
|
||||
ALIGN 8,0x90
|
||||
IRQ5F: PUSHAD
|
||||
MOV EDX,0x5F
|
||||
JMP IRQFAULT
|
||||
|
||||
FAULT_DESC: DU1 "FAULT TASK",0;
|
||||
|
||||
CP_FAULT::
|
||||
PUSHAD
|
||||
MOV EBP,ESP
|
||||
MOV EDX,U4 SP_PARAM1[EBP]
|
||||
IRQFAULT::
|
||||
CLD
|
||||
PUSH EDX //Save IRQNUM
|
||||
MOV U4 [SYS_CUR_FOCUS_TASK],0
|
||||
|
||||
MOV EAX,U4 FS:[TSS_DBG]
|
||||
OR EAX,EAX
|
||||
JNZ @@10
|
||||
PUSH 0
|
||||
PUSH U4 DEFAULT_STACK
|
||||
PUSH 0
|
||||
PUSH 0 ///Use parent account
|
||||
PUSH 0
|
||||
PUSH U4 FS:[TSS_ABSOLUTE_ADDRESS]
|
||||
PUSH 0
|
||||
PUSH U4 FAULT_DESC
|
||||
PUSH 0
|
||||
PUSH U4 CP_FAULT_CMD_LINE+4
|
||||
CALL CP_SPAWN_TASK+4
|
||||
ADD ESP,40
|
||||
|
||||
@@10: POP U4 TSS_USER_AUX0[EAX]
|
||||
PUSH 0
|
||||
PUSH EAX
|
||||
MOV EAX,U4 [SYS_EXTERN_TABLE]
|
||||
MOV EAX,U4 EXT_WINDOW_TO_TOP*4[EAX]
|
||||
OR EAX,EAX
|
||||
JZ @@20
|
||||
CALL EAX
|
||||
@@20: ADD ESP,8
|
||||
POPAD
|
||||
BTS U4 FS:[TSS_TASK_FLAGS],TSSf_SUSPENDED
|
||||
JMP U4 IRQ_SWAP_IN_NEXT
|
||||
|
||||
GET_MACHINE_REGS::
|
||||
PUSH EBP
|
||||
MOV EBP,ESP
|
||||
MOV EBX,SF_PARAM1[EBP]
|
||||
|
||||
DU1 0x0F,0x20,0xC0;
|
||||
MOV U4 [EBX],EAX
|
||||
DU1 0x0F,0x20,0xD0;
|
||||
MOV U4 4[EBX],EAX
|
||||
DU1 0x0F,0x20,0xD8;
|
||||
MOV U4 8[EBX],EAX
|
||||
DU1 0x0F,0x20,0xE0;
|
||||
MOV U4 12[EBX],EAX
|
||||
|
||||
DU1 0x0F,0x21,0xC0;
|
||||
MOV U4 16[EBX],EAX
|
||||
DU1 0x0F,0x21,0xC8;
|
||||
MOV U4 20[EBX],EAX
|
||||
DU1 0x0F,0x21,0xD0;
|
||||
MOV U4 24[EBX],EAX
|
||||
DU1 0x0F,0x21,0xD8;
|
||||
MOV U4 28[EBX],EAX
|
||||
DU1 0x0F,0x21,0xF0;
|
||||
MOV U4 32[EBX],EAX
|
||||
DU1 0x0F,0x21,0xF8;
|
||||
MOV U4 36[EBX],EAX
|
||||
|
||||
POP EBP
|
||||
RET
|
||||
|
||||
Binary file not shown.
@@ -0,0 +1,62 @@
|
||||
U1 *AMAlloc(U8 size)
|
||||
{
|
||||
U1 *result=MAlloc(size,adam_tss);
|
||||
return result;
|
||||
}
|
||||
|
||||
void AFree(U1 *add)
|
||||
{
|
||||
Free(add,adam_tss);
|
||||
}
|
||||
|
||||
U1 *AMAllocIdentical(U1 *src)
|
||||
{
|
||||
U8 size=MSize(src);
|
||||
U1 *result=MAlloc(size,adam_tss);
|
||||
MemCpy(result,src,size);
|
||||
}
|
||||
|
||||
U1 *MAllocIdentical(U1 *src,TssStruct *tss=NULL)
|
||||
{
|
||||
U8 size=MSize(src);
|
||||
U1 *result=MAlloc(size,tss);
|
||||
MemCpy(result,src,size);
|
||||
}
|
||||
|
||||
I1 *ANewString(I1 *buf)
|
||||
{
|
||||
U8 size=StrLen(buf)+1;
|
||||
U1 *result=MAlloc(size,adam_tss);
|
||||
MemCpy(result,buf,size);
|
||||
}
|
||||
|
||||
I1 *NewString(I1 *buf,TssStruct *tss=NULL)
|
||||
{
|
||||
U8 size=StrLen(buf)+1;
|
||||
U1 *result=MAlloc(size,tss);
|
||||
MemCpy(result,buf,size);
|
||||
}
|
||||
|
||||
U1 *AMAllocZ(U8 size)
|
||||
{
|
||||
U1 *result=MAlloc(size,adam_tss);
|
||||
MemSet(result,0,size);
|
||||
return result;
|
||||
}
|
||||
|
||||
U1 *MAllocZ(U8 size,TssStruct *tss=NULL)
|
||||
{
|
||||
U1 *result=MAlloc(size,tss);
|
||||
MemSet(result,0,size);
|
||||
return result;
|
||||
}
|
||||
|
||||
void DelLinkedList(U4 *list)
|
||||
{
|
||||
U4 *d;
|
||||
while (list) {
|
||||
d=*list;
|
||||
Free(list);
|
||||
list=d;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,877 @@
|
||||
BoolU4 AssignBit(U1 *field,U8 bit,U8 val)
|
||||
{
|
||||
if (val)
|
||||
return Bts(field,bit);
|
||||
else
|
||||
return Btr(field,bit);
|
||||
}
|
||||
|
||||
void PortNop()
|
||||
{
|
||||
InP(0x379); //This is an innoculous ISA (parallel port)
|
||||
//access which should take
|
||||
//fixed time on all machines.
|
||||
//It takes 1.66uS
|
||||
}
|
||||
|
||||
void Exit()
|
||||
{
|
||||
Bts(&Fs->task_flags,TSSf_KILL_TASK);
|
||||
while (TRUE)
|
||||
SwapInNext;
|
||||
}
|
||||
|
||||
void Kill(TssStruct *tss)
|
||||
{
|
||||
Bts(&tss->task_flags,TSSf_KILL_TASK);
|
||||
}
|
||||
|
||||
void SimpleTimerIrq()
|
||||
{
|
||||
U8 old_flags=GetFlags;
|
||||
Cli;
|
||||
jiffies++;
|
||||
sys_timer+=SYS_TIMER0_PERIOD+1;
|
||||
SetFlags(old_flags);
|
||||
}
|
||||
|
||||
U8 ReadSysTimer()
|
||||
{
|
||||
U8 i,old_flags=GetFlags;
|
||||
U8 result;
|
||||
Cli;
|
||||
OutP(0x43,0); //Latch Timer0
|
||||
i=InP(0x40);
|
||||
i+=(InP(0x40)<<8);
|
||||
result=sys_timer+SYS_TIMER0_PERIOD-i;
|
||||
SetFlags(old_flags);
|
||||
return result;
|
||||
}
|
||||
|
||||
U8 ExceptDepth(TssStruct *tss=NULL)
|
||||
{
|
||||
U8 result=0;
|
||||
ExceptStruct *tempt;
|
||||
if (!tss) tss=Fs;
|
||||
tempt=tss->next_except;
|
||||
while (tempt!=&tss->next_except) {
|
||||
result++;
|
||||
tempt=tempt->next;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
asm {
|
||||
CP_TEST_EXCEPT::
|
||||
MOV EAX,U4 FS:[TSS_LAST_EXCEPT]
|
||||
MOV EBP,U4 EXCEPT_EBP[EAX]
|
||||
MOV ESI,U4 EXCEPT_ESI[EAX]
|
||||
MOV EDI,U4 EXCEPT_EDI[EAX]
|
||||
CALL U4 EXCEPT_HANDLER_START[EAX]
|
||||
RET
|
||||
|
||||
CP_CATCH_EXCEPT::
|
||||
MOV EAX,U4 FS:[TSS_LAST_EXCEPT]
|
||||
MOV EDX,U4 EXCEPT_HANDLER_SKIP[EAX]
|
||||
MOV ESP,U4 EXCEPT_ESP[EAX]
|
||||
JMP EDX
|
||||
|
||||
CP_SAVE_EXCEPT_ESI_EDI::
|
||||
PUSH EBP
|
||||
MOV EBP,ESP
|
||||
MOV EAX,SF_PARAM1[EBP]
|
||||
MOV U4 EXCEPT_ESI[EAX],ESI
|
||||
MOV U4 EXCEPT_EDI[EAX],EDI
|
||||
POP EBP
|
||||
RET
|
||||
};
|
||||
|
||||
LTextern CP_TEST_EXCEPT void TestExcept();
|
||||
LTextern CP_CATCH_EXCEPT void TakeExcept();
|
||||
LTextern CP_SAVE_EXCEPT_ESI_EDI void SaveExceptRegs(ExceptStruct *t);
|
||||
|
||||
exe {NoRegVar(ON);}
|
||||
void SysTry(U1 *start_label,U1 *skip_label,U8 my_ebp,U8 my_esp)
|
||||
{
|
||||
U4 *ptr=GetBasePtr;
|
||||
ExceptStruct *tempt=MAlloc(sizeof(ExceptStruct));
|
||||
tempt->handler_start=start_label;
|
||||
tempt->handler_skip=skip_label;
|
||||
tempt->esp=my_esp+8;
|
||||
tempt->ebp=my_ebp;
|
||||
SaveExceptRegs(tempt);
|
||||
InsQue(tempt,Fs->last_except);
|
||||
}
|
||||
|
||||
void SysCatch()
|
||||
{
|
||||
ExceptStruct *tempt=Fs->last_except;
|
||||
RemQue(tempt);
|
||||
Free(tempt);
|
||||
}
|
||||
|
||||
void throw(...)
|
||||
{
|
||||
ExceptStruct *tempt=Fs->last_except;
|
||||
U8 i;
|
||||
|
||||
AdamLog("Depth:%02X Tsk:%08X throw(",
|
||||
ExceptDepth(Fs),Fs); //TODO: fix compiler--"(FS)"
|
||||
for (i=0;i<argc;i++)
|
||||
AdamLog("%X,",argv[i]);
|
||||
AdamLog(");\r\n");
|
||||
|
||||
Fs->except_argc=argc;
|
||||
Fs->except_argv=argv;
|
||||
Fs->except_ebp=GetBasePtr;
|
||||
Fs->catch_except=FALSE;
|
||||
while (tempt!=&Fs->next_except) {
|
||||
TestExcept;
|
||||
if (Fs->catch_except)
|
||||
TakeExcept;
|
||||
SetBasePtr(Fs->except_ebp);
|
||||
RemQue(tempt);
|
||||
Free(tempt);
|
||||
tempt=Fs->last_except;
|
||||
}
|
||||
PutSysText("ST_UNHANDLED_EXCEPTION");
|
||||
while (TRUE)
|
||||
SwapInNext;
|
||||
}
|
||||
exe {NoRegVar(OFF);}
|
||||
|
||||
void KbdCmdSend(U8 port, U1 val)
|
||||
{
|
||||
U8 timeout;
|
||||
for (timeout=50000;
|
||||
(InP(KEYB_CTRL)&2) && timeout;timeout--)
|
||||
PortNop;
|
||||
if (timeout)
|
||||
OutP(port, val);
|
||||
else
|
||||
throw(EXCEPT_LOCAL);
|
||||
}
|
||||
|
||||
I8 KbdCmdRead()
|
||||
{
|
||||
U8 timeout;
|
||||
for (timeout=50000; timeout; timeout--) {
|
||||
if (InP(KEYB_CTRL) & 1)
|
||||
return InP(KEYB_PORT);
|
||||
else
|
||||
PortNop;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
void KbdCmdFlush()
|
||||
{
|
||||
I8 i;
|
||||
for (i=0;i<1000;i++) {
|
||||
if (InP(KEYB_CTRL) & 1) {
|
||||
InP(KEYB_PORT);
|
||||
i=0;
|
||||
} else
|
||||
PortNop;
|
||||
}
|
||||
}
|
||||
|
||||
void KbdSetLEDs(U8 sc)
|
||||
{
|
||||
U8 old_flags=GetFlags;
|
||||
U1 v=0;
|
||||
AssignBit(&v,0,Bt(&sc,SCf_SCROLL));
|
||||
AssignBit(&v,1,Bt(&sc,SCf_NUM));
|
||||
AssignBit(&v,2,Bt(&sc,SCf_CAPS));
|
||||
Cli;
|
||||
KbdCmdSend(KEYB_PORT,0xED);
|
||||
KbdCmdSend(KEYB_PORT,v);
|
||||
SetFlags(old_flags);
|
||||
}
|
||||
|
||||
void KbdMouseCmdAck(U1 val)
|
||||
{
|
||||
U1 b;
|
||||
U8 timeout=32;
|
||||
BoolU4 cont=TRUE;
|
||||
while (cont && timeout) {
|
||||
try {
|
||||
KbdCmdSend(KEYB_CTRL,0xD4);
|
||||
KbdCmdSend(KEYB_PORT,val);
|
||||
b=KbdCmdRead;
|
||||
if (b==0xFA)
|
||||
cont=FALSE;
|
||||
} catch
|
||||
Fs->catch_except=TRUE;
|
||||
timeout--;
|
||||
}
|
||||
if (cont)
|
||||
throw(EXCEPT_LOCAL);
|
||||
}
|
||||
|
||||
void InitKeyboard()
|
||||
{
|
||||
KbdCmdSend(KEYB_PORT,0xF0);
|
||||
KbdCmdSend(KEYB_PORT,0x02);
|
||||
KbdSetLEDs(sys_cur_scan_code);
|
||||
}
|
||||
|
||||
U1 scan_code_map[0x100]={
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0,SC_SHIFT,0,0,0,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
||||
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,SC_CR,SC_CTRL,0,0,
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0x35,0,0,0,SC_ALT,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0,0,SC_HOME,SC_CURSOR_UP,SC_PAGE_UP,0,SC_CURSOR_LEFT,0,SC_CURSOR_RIGHT,0,SC_END,
|
||||
SC_CURSOR_DOWN,SC_PAGE_DOWN,SC_INSERT,SC_DELETE,0,0,0,0,0,0,0,0,SC_GUI,0,0,0,
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
||||
};
|
||||
|
||||
|
||||
U1 num_lock_map[0x100]={
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0,0,8,9,10,0,5,6,7,0,2,
|
||||
3,4,11,0x34,0,0,0,0,0,0,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
||||
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,SC_CR,SC_CTRL,0,0,
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0x35,0,0,0,SC_ALT,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0,0,SC_HOME,SC_CURSOR_UP,SC_PAGE_UP,0,SC_CURSOR_LEFT,0,SC_CURSOR_RIGHT,0,SC_END,
|
||||
SC_CURSOR_DOWN,SC_PAGE_DOWN,SC_INSERT,SC_DELETE,0,0,0,0,0,0,0,0,SC_GUI,0,0,0,
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
||||
};
|
||||
|
||||
|
||||
asm {CP_KBD_HANDLER::}
|
||||
void KbdHandler()
|
||||
{
|
||||
void kbd_hand2();
|
||||
U8 sc=sys_cur_scan_code&~0x1FF,
|
||||
sc2=InP(KEYB_PORT),sc3,sc_raw;
|
||||
Bts(&sys_irq_flags,1);
|
||||
if (sc2==0xE0) {
|
||||
sys_cur_scan_code|=SCF_PRIOR_E0;
|
||||
return;
|
||||
}
|
||||
AssignBit(&sc2,SCf_KEY_UP,sc2 & 0x80);
|
||||
AssignBit(&sc2,SCf_E0_PREFIX,Btr(&sc,SCf_PRIOR_E0));
|
||||
sc_raw=sc2;
|
||||
if (sc & SCF_NUM) {
|
||||
if (sc3=num_lock_map[sc2.u1[0]])
|
||||
sc2.u1[0]=sc3;
|
||||
} else {
|
||||
if (sc3=scan_code_map[sc2.u1[0]])
|
||||
sc2.u1[0]=sc3;
|
||||
}
|
||||
if (sc2==SC_SHIFT) {
|
||||
sc|=SCF_SHIFT;
|
||||
goto new_key_done;
|
||||
}
|
||||
if (sc2==SC_SHIFT+SCF_KEY_UP) {
|
||||
sc&=~SCF_SHIFT;
|
||||
goto new_key_done;
|
||||
}
|
||||
|
||||
if (sc2==SC_CTRL) {
|
||||
sc|=SCF_CTRL;
|
||||
goto new_key_done;
|
||||
}
|
||||
if (sc2==SC_CTRL+SCF_KEY_UP) {
|
||||
sc&=~SCF_CTRL;
|
||||
goto new_key_done;
|
||||
}
|
||||
|
||||
if (sc2==SC_ALT) {
|
||||
sc|=SCF_ALT;
|
||||
goto new_key_done;
|
||||
}
|
||||
if (sc2==SC_ALT+SCF_KEY_UP) {
|
||||
sc&=~SCF_ALT;
|
||||
goto new_key_done;
|
||||
}
|
||||
|
||||
if (sc2==SC_CAPS)
|
||||
goto new_key_done;
|
||||
if (sc2==SC_CAPS+SCF_KEY_UP) {
|
||||
sc^=SCF_CAPS;
|
||||
KbdSetLEDs(sc);
|
||||
goto new_key_done;
|
||||
}
|
||||
|
||||
if (sc2==SC_NUM)
|
||||
goto new_key_done;
|
||||
if (sc2==SC_NUM+SCF_KEY_UP) {
|
||||
sc^=SCF_NUM;
|
||||
KbdSetLEDs(sc);
|
||||
goto new_key_done;
|
||||
}
|
||||
|
||||
if (sc2==SC_SCROLL)
|
||||
goto new_key_done;
|
||||
if (sc2==SC_SCROLL+SCF_KEY_UP) {
|
||||
sc^=SCF_SCROLL;
|
||||
KbdSetLEDs(sc);
|
||||
goto new_key_done;
|
||||
}
|
||||
|
||||
if (sc & SCF_CTRL && sc & SCF_ALT) {
|
||||
if (sc2==SC_DELETE) {
|
||||
Bts(&sys_flags,SYSf_CTRL_ALT_DEL);
|
||||
goto mostly_done;
|
||||
}
|
||||
if (sc2==1) {
|
||||
Bts(&sys_flags,SYSf_CTRL_ALT_ESC);
|
||||
goto mostly_done;
|
||||
}
|
||||
if (sc2==15) {
|
||||
Bts(&sys_flags,SYSf_CTRL_ALT_TAB);
|
||||
goto mostly_done;
|
||||
}
|
||||
if (sc2==0x2D) {
|
||||
Bts(&sys_flags,SYSf_CTRL_ALT_X);
|
||||
goto mostly_done;
|
||||
}
|
||||
if (sc2==0x2E) {
|
||||
Bts(&sys_flags,SYSf_CTRL_ALT_C);
|
||||
goto mostly_done;
|
||||
}
|
||||
}
|
||||
|
||||
new_key_done:
|
||||
sc|=SCF_NEW_KEY;
|
||||
mostly_done:
|
||||
sys_cur_scan_code=sc|sc2;
|
||||
sys_cur_raw_scan_code=sc|sc_raw;
|
||||
if (kbd_hand2=ext[EXT_IRQ01])
|
||||
kbd_hand2();
|
||||
Btr(&sys_irq_flags,1);
|
||||
}
|
||||
|
||||
U8 DivU8(U8 n1,U8 n2)
|
||||
{
|
||||
U8 r_lo=n1,r_hi=0;
|
||||
U8 i;
|
||||
for (i=0;i<64;i++) {
|
||||
if (r_lo & 0x8000000000000000) {
|
||||
r_hi<<=1;
|
||||
r_hi++;
|
||||
} else
|
||||
r_hi<<=1;
|
||||
r_lo<<=1;
|
||||
if (r_hi>=n2) {
|
||||
r_hi-=n2;
|
||||
r_lo++;
|
||||
}
|
||||
}
|
||||
return r_lo;
|
||||
}
|
||||
|
||||
I8 DivI8(I8 n1,I8 n2)
|
||||
{
|
||||
U8 r_lo,r_hi=0;
|
||||
U8 i;
|
||||
BoolU4 signed;
|
||||
if (n1<0) {
|
||||
signed=TRUE;
|
||||
n1=-n1;
|
||||
} else
|
||||
signed=FALSE;
|
||||
if (n2<0) {
|
||||
signed=!signed;
|
||||
n2=-n2;
|
||||
}
|
||||
r_lo=n1;
|
||||
for (i=0;i<64;i++) {
|
||||
if (r_lo & 0x8000000000000000) {
|
||||
r_hi<<=1;
|
||||
r_hi++;
|
||||
} else
|
||||
r_hi<<=1;
|
||||
r_lo<<=1;
|
||||
if (r_hi>=n2) {
|
||||
r_hi-=n2;
|
||||
r_lo++;
|
||||
}
|
||||
}
|
||||
return (signed) ? -r_lo:r_lo;
|
||||
}
|
||||
|
||||
U8 ModU8(U8 n1,U8 n2)
|
||||
{
|
||||
U8 r_lo=n1,r_hi=0;
|
||||
U8 i;
|
||||
for (i=0;i<64;i++) {
|
||||
if (r_lo & 0x8000000000000000) {
|
||||
r_hi<<=1;
|
||||
r_hi++;
|
||||
} else
|
||||
r_hi<<=1;
|
||||
r_lo<<=1;
|
||||
if (r_hi>=n2) {
|
||||
r_hi-=n2;
|
||||
r_lo++;
|
||||
}
|
||||
}
|
||||
return r_hi;
|
||||
}
|
||||
|
||||
I8 ModI8(I8 n1,I8 n2)
|
||||
{
|
||||
U8 r_lo,r_hi=0;
|
||||
U8 i;
|
||||
BoolU4 signed;
|
||||
if (n1<0) {
|
||||
signed=TRUE;
|
||||
n1=-n1;
|
||||
} else
|
||||
signed=FALSE;
|
||||
if (n2<0) {
|
||||
signed=!signed;
|
||||
n2=-n2;
|
||||
}
|
||||
r_lo=n1;
|
||||
for (i=0;i<64;i++) {
|
||||
if (r_lo & 0x8000000000000000) {
|
||||
r_hi<<=1;
|
||||
r_hi++;
|
||||
} else
|
||||
r_hi<<=1;
|
||||
r_lo<<=1;
|
||||
if (r_hi>=n2) {
|
||||
r_hi-=n2;
|
||||
r_lo++;
|
||||
}
|
||||
}
|
||||
return (signed) ? -r_hi:r_hi;
|
||||
}
|
||||
|
||||
LTDate BootTime()
|
||||
//Roughly 49,710ths of a second since boot
|
||||
{
|
||||
return DivU8(ReadSysTimer<<14,1833333*3*3*3/125);
|
||||
}
|
||||
|
||||
U2 RandU2() //TODO: fix this
|
||||
{
|
||||
LTDate i=BootTime;
|
||||
rnd_SEED^=MulU8(rnd_SEED,0x56234)+i.date^i.time^jiffies+ModU8(rnd_SEED,0x7635);
|
||||
return rnd_SEED.u2[0];
|
||||
}
|
||||
|
||||
U8 RandU4()
|
||||
{
|
||||
U8 result=0;
|
||||
result.u2[0]=RandU2;
|
||||
result.u2[1]=RandU2;
|
||||
return result;
|
||||
}
|
||||
|
||||
I8 ToUpper(I8 ch)
|
||||
{
|
||||
if (ch>='a' && ch<='z')
|
||||
return ch+'A'-'a';
|
||||
else
|
||||
return ch;
|
||||
}
|
||||
|
||||
I8 AtoI(I1 *st,I8 radix=10,I1 **end_ptr=NULL)
|
||||
{
|
||||
BoolU4 neg=FALSE;
|
||||
I1 ch;
|
||||
I8 result=0,k=0;
|
||||
if (radix<2||radix>36) return 0;
|
||||
while (*st==CH_SPACE || *st==CH_SHIFT_SPACE || *st==CH_TAB)
|
||||
st++;
|
||||
if (*st=='-') {
|
||||
st++;
|
||||
neg=TRUE;
|
||||
}
|
||||
if (*st=='+') st++;
|
||||
while (ch=ToUpper(*st++)) {
|
||||
k++;
|
||||
if (radix==10) {
|
||||
if (ch>='0' && ch<='9')
|
||||
result=MulI8(result,10)+ch-'0';
|
||||
else if (k==2 && !result) {
|
||||
if (ch=='X')
|
||||
radix=16;
|
||||
else if (ch=='B')
|
||||
radix=2;
|
||||
else if (ch=='o')
|
||||
radix=8;
|
||||
else
|
||||
break;
|
||||
} else
|
||||
break;
|
||||
} else if (radix>10) {
|
||||
if (ch>='0' && ch<='9')
|
||||
result=MulI8(result,radix)+ch-'0';
|
||||
else if (ch>='A' && ch<='A'+radix-11)
|
||||
result=MulI8(result,radix)+ch-'A'+10;
|
||||
else
|
||||
break;
|
||||
} else {
|
||||
if (ch>='0' && ch<='0'+radix-1)
|
||||
result=MulI8(result,radix)+ch-'0';
|
||||
else
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (end_ptr) *end_ptr=st-1;
|
||||
return (neg)? -result:result;
|
||||
}
|
||||
|
||||
|
||||
void BusyWait(U8 uS) //Loosely timed
|
||||
{
|
||||
U8 i;
|
||||
for (i=0;i<uS;i++)
|
||||
PortNop;
|
||||
}
|
||||
|
||||
void Sleep(U8 mS)
|
||||
{
|
||||
U8 old_flags=GetFlags;
|
||||
U8 target_jiffies=jiffies+(mS*JIFFY_FREQ/1000);
|
||||
Sti;
|
||||
do SwapInNext;
|
||||
while (jiffies<target_jiffies);
|
||||
SetFlags(old_flags);
|
||||
}
|
||||
|
||||
void Sound(U8 freq)
|
||||
{
|
||||
U8 p,old_flags=GetFlags;
|
||||
if (Bt(&sys_flags,SYSf_NO_SOUND))
|
||||
return;
|
||||
if (freq) {
|
||||
p=SYS_TIMER_FREQ/freq;
|
||||
Cli;
|
||||
OutP(0x43,0xB6);
|
||||
OutP(0x42,p);
|
||||
OutP(0x42,p.u1[1]);
|
||||
OutP(0x61,3);
|
||||
SetFlags(old_flags);
|
||||
} else
|
||||
OutP(0x61,0);
|
||||
}
|
||||
|
||||
void Beep(U8 freq=500,BoolU4 busy=FALSE)
|
||||
{
|
||||
Sound(freq);
|
||||
if (busy) BusyWait(500000);
|
||||
else Sleep(500);
|
||||
Sound(0);
|
||||
if (busy) BusyWait(200000);
|
||||
else Sleep(200);
|
||||
}
|
||||
|
||||
BoolU4 Externs2Imports(BoolU4 val) {
|
||||
return AssignBit(&Fs->last_lex->flags,LFf_EXTERNS_TO_IMPORTS,val);
|
||||
}
|
||||
|
||||
BoolU4 KeepPrivate(BoolU4 val) {
|
||||
return AssignBit(&Fs->last_lex->flags,LFf_KEEP_PRIVATE,val);
|
||||
}
|
||||
|
||||
BoolU4 PTrace(BoolU4 val) {
|
||||
return AssignBit(&Fs->last_lex->flags,LFf_PARSE_TRACE,val);
|
||||
}
|
||||
|
||||
BoolU4 OTrace(BoolU4 val) {
|
||||
return AssignBit(&Fs->last_lex->flags,LFf_OPT_TRACE,val);
|
||||
}
|
||||
|
||||
BoolU4 CTrace(BoolU4 val) {
|
||||
return AssignBit(&Fs->last_lex->flags,LFf_COMPILE_TRACE,val);
|
||||
}
|
||||
|
||||
BoolU4 LTrace(BoolU4 val) {
|
||||
return AssignBit(&Fs->last_lex->flags,LFf_LEX_TRACE,val);
|
||||
}
|
||||
|
||||
BoolU4 NoRegVar(BoolU4 val) {
|
||||
return AssignBit(&Fs->last_lex->flags,LFf_NO_REG_VAR,val);
|
||||
}
|
||||
|
||||
BoolU4 Echo(BoolU4 val) {
|
||||
return AssignBit(&Fs->last_lex->flags,LFf_ECHO,val);
|
||||
}
|
||||
|
||||
BoolU4 SysEcho(BoolU4 val) {
|
||||
return AssignBit(&Fs->last_lex->flags,LFf_ECHO,val);
|
||||
}
|
||||
|
||||
BoolU4 Silent(BoolU4 val) {
|
||||
return AssignBit(&Fs->crt_flags,CRTf_SILENT,val);
|
||||
}
|
||||
|
||||
BoolU4 Preempt(BoolU4 val) {
|
||||
return AssignBit(&sys_flags,SYSf_PREEMPTIVE,val);
|
||||
}
|
||||
|
||||
BoolU4 SysDbg(BoolU4 val) {
|
||||
return AssignBit(&sys_flags,SYSf_DEBUG,val);
|
||||
}
|
||||
|
||||
BoolU4 IsSysDbg() {
|
||||
return Bt(&sys_flags,SYSf_DEBUG);
|
||||
}
|
||||
|
||||
BoolU4 Raw(BoolU4 val) {
|
||||
if (val) {
|
||||
OutP(VGA_SC_INDEX,VGA_MAP_MASK);
|
||||
OutP(VGA_SC_DATA,0x0F);
|
||||
}
|
||||
return AssignBit(&sys_flags,SYSf_RAW_CRT_OUT,val);
|
||||
}
|
||||
|
||||
BoolU4 IsRaw() {
|
||||
return Bt(&sys_flags,SYSf_RAW_CRT_OUT);
|
||||
}
|
||||
|
||||
U1 *Caller()
|
||||
{
|
||||
U4 *bp=GetBasePtr;
|
||||
bp=*bp+4;
|
||||
return *bp;
|
||||
}
|
||||
|
||||
U1 *CallerCaller()
|
||||
{
|
||||
U4 *bp=GetBasePtr;
|
||||
bp=*bp;
|
||||
bp=*bp+4;
|
||||
return *bp;
|
||||
}
|
||||
|
||||
void DbgStr(I1 *st,U8 mS=100)
|
||||
{
|
||||
BoolU4 old_flags=GetFlags;
|
||||
BoolU4 old_raw;
|
||||
Cli;
|
||||
old_raw=Raw(ON);
|
||||
cout "DbgStr(",st,")";
|
||||
BusyWait(mS<<10);
|
||||
SetFlags(old_flags);
|
||||
Raw(old_raw);
|
||||
}
|
||||
|
||||
void DbgNum(U8 num,U8 mS=100)
|
||||
{
|
||||
BoolU4 old_flags=GetFlags;
|
||||
BoolU4 old_raw;
|
||||
Cli;
|
||||
old_raw=Raw(ON);
|
||||
cout "DbgNum(",num,")";
|
||||
BusyWait(mS<<10);
|
||||
SetFlags(old_flags);
|
||||
Raw(old_raw);
|
||||
}
|
||||
|
||||
void DbgF(double d,U8 mS=100)
|
||||
{
|
||||
BoolU4 old_flags=GetFlags;
|
||||
BoolU4 old_raw;
|
||||
Cli;
|
||||
old_raw=Raw(ON);
|
||||
cout "DbgF(",d,")";
|
||||
BusyWait(mS<<10);
|
||||
SetFlags(old_flags);
|
||||
Raw(old_raw);
|
||||
}
|
||||
|
||||
void DbgAdd(U4 *add,U8 mS=100)
|
||||
{
|
||||
BoolU4 old_flags=GetFlags;
|
||||
BoolU4 old_raw;
|
||||
Cli;
|
||||
old_raw=Raw(ON);
|
||||
PrintF("DbgAdd(%P)",add);
|
||||
BusyWait(mS<<10);
|
||||
SetFlags(old_flags);
|
||||
Raw(old_raw);
|
||||
}
|
||||
|
||||
void DbgD(U4 *add,U8 cnt=0x80,U8 mS=100)
|
||||
{
|
||||
BoolU4 old_flags=GetFlags;
|
||||
BoolU4 old_raw;
|
||||
Cli;
|
||||
old_raw=Raw(ON);
|
||||
D(add,cnt);
|
||||
BusyWait(mS<<10);
|
||||
SetFlags(old_flags);
|
||||
Raw(old_raw);
|
||||
}
|
||||
|
||||
void DbgDm(U4 *add,U8 cnt=0x80,U8 mS=100)
|
||||
{
|
||||
BoolU4 old_flags=GetFlags;
|
||||
BoolU4 old_raw;
|
||||
Cli;
|
||||
old_raw=Raw(ON);
|
||||
Dm(add,cnt);
|
||||
BusyWait(mS<<10);
|
||||
SetFlags(old_flags);
|
||||
Raw(old_raw);
|
||||
}
|
||||
|
||||
|
||||
SysHashEntry *FindLocalHash(I1 *st,U8 mask)
|
||||
{
|
||||
return FindHashEntry(st,Fs->hash_table,mask);
|
||||
}
|
||||
|
||||
void Beeps(U8 j,BoolU4 busy)
|
||||
{
|
||||
U8 i,f;
|
||||
for (i=0;i<8;i++) {
|
||||
if (Bt(&j,i+24)) {
|
||||
f=200;
|
||||
if (Bt(&j,i+8))
|
||||
f+=400;
|
||||
if (Bt(&j,i+16))
|
||||
f+=800;
|
||||
Sound(f);
|
||||
if (busy) {
|
||||
if (Bt(&j,i))
|
||||
BusyWait(300000);
|
||||
else
|
||||
BusyWait(100000);
|
||||
} else {
|
||||
if (Bt(&j,i))
|
||||
Sleep(400);
|
||||
else
|
||||
Sleep(150);
|
||||
}
|
||||
Sound(0);
|
||||
}
|
||||
if (busy)
|
||||
BusyWait(150000);
|
||||
else
|
||||
Sleep(300);
|
||||
}
|
||||
}
|
||||
|
||||
void UnrecoverableSysError(U8 j)
|
||||
{
|
||||
Cli;
|
||||
while (TRUE) {
|
||||
Beeps(j,TRUE);
|
||||
Raw(ON);
|
||||
coutln "Unrecoverable SysError:",j;
|
||||
BusyWait(500000);
|
||||
}
|
||||
}
|
||||
|
||||
asm {CP_BREAK::}
|
||||
void Break()
|
||||
{
|
||||
ReleaseTaskPartitions;
|
||||
IntFlushMsgs;
|
||||
throw(EXCEPT_BREAK);
|
||||
}
|
||||
|
||||
void ThrowDivide(U1 *eip)
|
||||
{
|
||||
throw(EXCEPT_ARITHMETIC,eip);
|
||||
}
|
||||
|
||||
void ThrowFloating(U1 *eip)
|
||||
{
|
||||
throw(EXCEPT_FLOATING,eip);
|
||||
}
|
||||
|
||||
|
||||
SysHashEntry *FindPSect(U8 add,I8 *offset)
|
||||
{
|
||||
SysHashEntry *result=NULL,*temph;
|
||||
SysHashTable *h=Fs->hash_table;
|
||||
ClassStruct *tempc;
|
||||
U8 i,best=0x8000,j;
|
||||
|
||||
while (h) {
|
||||
for (i=0;i<=h->mask;i++) {
|
||||
temph=h->body[i];
|
||||
while (temph) {
|
||||
if (temph->type&HTT_FUNCTION) {
|
||||
tempc=temph;
|
||||
j=tempc->executable_address;
|
||||
} else
|
||||
j=temph->user0;
|
||||
j=add-j;
|
||||
if (temph->type&(HTT_SYS_SYMBOL|HTT_FUNCTION)) {
|
||||
if (j<best) {
|
||||
best=j;
|
||||
result=temph;
|
||||
}
|
||||
}
|
||||
temph=temph->next;
|
||||
}
|
||||
}
|
||||
h=h->next;
|
||||
}
|
||||
*offset=best;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
U8 GetS(I1 *buf,U8 size)
|
||||
{
|
||||
I8 ch;
|
||||
I1 *buf2;
|
||||
U8 i=0;
|
||||
void my_SysGetS();
|
||||
if (!size || !buf) return 0;
|
||||
i=FindExtern("SysGetS");
|
||||
if (i) {
|
||||
my_SysGetS=i;
|
||||
buf2=my_SysGetS();
|
||||
if (StrLen(buf2)>size-1) {
|
||||
MemCpy(buf,buf2,size-1);
|
||||
buf[size-1]=0;
|
||||
} else
|
||||
StrCpy(buf,buf2);
|
||||
i=StrLen(buf);
|
||||
Free(buf2);
|
||||
} else {
|
||||
while (TRUE) {
|
||||
ch=GetKey;
|
||||
if (ch==CH_CR) {
|
||||
PutChar(ch);
|
||||
break;
|
||||
} if (ch==CH_BACKSPACE) {
|
||||
if (i>0) {
|
||||
i--;
|
||||
PutChar(ch);
|
||||
}
|
||||
} else {
|
||||
if (i<size-1) {
|
||||
buf[i++]=ch;
|
||||
PutChar(ch);
|
||||
}
|
||||
}
|
||||
}
|
||||
buf[i]=0;
|
||||
}
|
||||
return i;
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,30 @@
|
||||
#include "ADAMK.HPZ"
|
||||
asm {
|
||||
#include "OSINC"
|
||||
ALIGN 16,0x90
|
||||
SYS_CS_START::
|
||||
#include "OSMAIN"
|
||||
#include "IRQHAND"
|
||||
#include "MEM"
|
||||
#include "FONT8x8"
|
||||
#include "SYSUTILS"
|
||||
#include "SCHED"
|
||||
#include "CHARIO"
|
||||
}
|
||||
#include "ADAMK2.HPZ"
|
||||
#include "START"
|
||||
#include "MEM"
|
||||
#include "CRT"
|
||||
#include "MISC"
|
||||
#include "CMD"
|
||||
#include "DATE"
|
||||
#include "STRINGS"
|
||||
#include "SYSTEXT"
|
||||
#include "SPRINTF"
|
||||
#include "QSORT"
|
||||
#include "COMPRESS"
|
||||
#include "DISK1"
|
||||
#include "DISK2"
|
||||
#include "DISK3"
|
||||
#include "DISK4"
|
||||
#include "END"
|
||||
+2369
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,287 @@
|
||||
STRUC 0
|
||||
SF_EBP: DU4 ?;
|
||||
SF_EIP: DU4 ?;
|
||||
SF_PARAM1: DU8 ?;
|
||||
SF_PARAM2: DU8 ?;
|
||||
SF_PARAM3: DU8 ?;
|
||||
SF_PARAM4: DU8 ?;
|
||||
SF_PARAM5: DU8 ?;
|
||||
SF_PARAM6: DU8 ?;
|
||||
SF_PARAM7: DU8 ?;
|
||||
SF_PARAM8: DU8 ?;
|
||||
ENDS
|
||||
|
||||
STRUC 0
|
||||
SFI_EBP: DU4 ?;
|
||||
SFI_EIP: DU4 ?;
|
||||
SFI_CS: DU4 ?;
|
||||
SFI_FLAGS: DU4 ?;
|
||||
SFI_PARAM1: DU8 ?;
|
||||
SFI_PARAM2: DU8 ?;
|
||||
SFI_PARAM3: DU8 ?;
|
||||
SFI_PARAM4: DU8 ?;
|
||||
SFI_PARAM5: DU8 ?;
|
||||
SFI_PARAM6: DU8 ?;
|
||||
SFI_PARAM7: DU8 ?;
|
||||
SFI_PARAM8: DU8 ?;
|
||||
ENDS
|
||||
|
||||
STRUC 0
|
||||
NULL_SEL: DU4 ?,?;
|
||||
SYS_BOOT_DS_SEL: DU4 ?,?;
|
||||
SYS_BOOT_CS_SEL: DU4 ?,?;
|
||||
SYS_CS_SEL: DU4 ?,?;
|
||||
ZERO_DS_SEL: DU4 ?,?;
|
||||
//ADAM_TSS_SEL: DU4 ?,?;
|
||||
FIRST_FREE_SEL:
|
||||
ENDS
|
||||
|
||||
|
||||
STRUC 0
|
||||
EXCEPT_NEXT: DU4 ?;
|
||||
EXCEPT_LAST: DU4 ?;
|
||||
EXCEPT_HANDLER_START: DU4 ?;
|
||||
EXCEPT_HANDLER_SKIP: DU4 ?;
|
||||
EXCEPT_ESP: DU4 ?;
|
||||
EXCEPT_EBP: DU4 ?;
|
||||
EXCEPT_ESI: DU4 ?;
|
||||
EXCEPT_EDI: DU4 ?;
|
||||
EXCEPT_STRUCT_SIZE:
|
||||
ENDS
|
||||
|
||||
STRUC 0
|
||||
MB_NEXT: DU4 ?;
|
||||
MB_LAST: DU4 ?;
|
||||
MB_SIZE: DU4 ?;
|
||||
MB_STRUCT_SIZE:
|
||||
ENDS
|
||||
|
||||
STRUC 0 //AVAILABLE TO MALLOC MEM
|
||||
UUM_NEXT: DU4 ?;
|
||||
UUM_SIZE: DU4 ?;
|
||||
UUM_STRUCT_SIZE:
|
||||
ENDS
|
||||
|
||||
#define USED_USER_MEM_SIZE -4
|
||||
|
||||
|
||||
STRUC 0
|
||||
BPT_NEXT:: DU4 ?;
|
||||
BPT_FLAGS:: DU4 ?;
|
||||
BPT_ADDRESS:: DU4 ?;
|
||||
BPT_U1:: DU1 ?;
|
||||
ENDS
|
||||
|
||||
STRUC 0
|
||||
TSS_BACK_LINK: DU4 ?;
|
||||
TSS_ESP0: DU4 ?;
|
||||
TSS_SS0: DU4 ?;
|
||||
TSS_ESP1: DU4 ?;
|
||||
TSS_SS1: DU4 ?;
|
||||
TSS_ESP2: DU4 ?;
|
||||
TSS_SS2: DU4 ?;
|
||||
TSS_CR3: DU4 ?;
|
||||
TSS_EIP: DU4 ?;
|
||||
TSS_EFLAGS: DU4 ?;
|
||||
TSS_EAX: DU4 ?;
|
||||
TSS_ECX: DU4 ?;
|
||||
TSS_EDX: DU4 ?;
|
||||
TSS_EBX: DU4 ?;
|
||||
TSS_ESP: DU4 ?;
|
||||
TSS_EBP: DU4 ?;
|
||||
TSS_ESI: DU4 ?;
|
||||
TSS_EDI: DU4 ?;
|
||||
TSS_ES: DU4 ?;
|
||||
TSS_CS: DU4 ?;
|
||||
TSS_SS: DU4 ?;
|
||||
TSS_DS: DU4 ?;
|
||||
TSS_FS: DU4 ?;
|
||||
TSS_GS: DU4 ?;
|
||||
TSS_LDTR: DU4 ?;
|
||||
TSS_TASK_SWITCH_EXCEPT: DU2 ?;
|
||||
TSS_IO_BITMAP_PTR: DU2 ?;
|
||||
TSS_IO_BITMAP: DU1 (MAXIO/8) DUP (?);
|
||||
|
||||
TSS_TASK_DESCRIPTOR: DU1 (TSS_DESC_LENGTH+1) DUP (?);
|
||||
|
||||
TSS_UPDATE_WINDOW: DU4 ?;
|
||||
TSS_CUR_LTF: DU4 ?;
|
||||
TSS_AUX_LTF: DU4 ?;
|
||||
TSS_EDIT_PLUGINS: DU4 ?;
|
||||
TSS_SCROLL_SPEED: DU4 ?;
|
||||
TSS_CRT_WIDTH: DU4 ?;
|
||||
TSS_CRT_HEIGHT: DU4 ?;
|
||||
TSS_TEXT_ATTRIBUTE: DU1 ?;
|
||||
TSS_BORDER_ATTRIBUTE: DU1 ?;
|
||||
DU2 ?; //Unused
|
||||
TSS_WINDOW_LEFT: DU4 ?;
|
||||
TSS_WINDOW_RIGHT: DU4 ?;
|
||||
TSS_WINDOW_TOP: DU4 ?;
|
||||
TSS_WINDOW_BOTTOM: DU4 ?;
|
||||
TSS_CURSOR_HOR: DU4 ?;
|
||||
TSS_CURSOR_VERT: DU4 ?;
|
||||
|
||||
TSS_WINDOW_PIXEL_LEFT: DU4 ?; //These are derived
|
||||
TSS_WINDOW_PIXEL_RIGHT: DU4 ?;
|
||||
TSS_WINDOW_PIXEL_TOP: DU4 ?;
|
||||
TSS_WINDOW_PIXEL_BOTTOM: DU4 ?;
|
||||
|
||||
TSS_SCROLL_X: DU4 ?;
|
||||
TSS_SCROLL_Y: DU4 ?;
|
||||
|
||||
TSS_CRT_FLAGS: DU4 ?;
|
||||
|
||||
TSS_ABSOLUTE_ADDRESS: DU4 ?;
|
||||
TSS_PARENT_TSS: DU4 ?;
|
||||
TSS_NEXT_TSS: DU4 ?; //ABSOLUTE ADDRESS OF NEXT TSS
|
||||
TSS_LAST_TSS: DU4 ?; //ABSOLUTE ADDRESS OF LAST TSS
|
||||
TSS_INPUT_FILTER_TSS: DU4 ?;
|
||||
TSS_NEXT_SIBLING_TSS: DU4 ?;
|
||||
TSS_LAST_SIBLING_TSS: DU4 ?;
|
||||
TSS_NEXT_CHILD_TSS: DU4 ?;
|
||||
TSS_LAST_CHILD_TSS: DU4 ?;
|
||||
TSS_FPU: DU1 108 DUP(?);
|
||||
TSS_WINDOW_BORDER_PIXEL_LEFT: DU4 ?; //These are derived
|
||||
TSS_WINDOW_BORDER_PIXEL_RIGHT: DU4 ?;
|
||||
TSS_WINDOW_BORDER_PIXEL_TOP: DU4 ?;
|
||||
TSS_WINDOW_BORDER_PIXEL_BOTTOM: DU4 ?;
|
||||
TSS_TASK_FLAGS: DU4 ?;
|
||||
TSS_STACK_BASE: DU4 ?;
|
||||
TSS_NEXT_MEM_BLK: DU4 ?;
|
||||
TSS_LAST_MEM_BLK: DU4 ?;
|
||||
TSS_HEAP_HASH: DU1 HEAP_HASH_SIZE DUP (?);
|
||||
TSS_MALLOC_FREE_LIST: DU4 ?;
|
||||
TSS_NEXT_EXCEPT: DU4 ?;
|
||||
TSS_LAST_EXCEPT: DU4 ?;
|
||||
TSS_EXCEPT_EBP: DU4 ?;
|
||||
TSS_EXCEPT_ARGC: DU4 ?;
|
||||
TSS_EXCEPT_ARGV: DU4 ?;
|
||||
TSS_CATCH_EXCEPT: DU4 ?;
|
||||
TSS_BPT_LIST: DU4 ?;
|
||||
TSS_NEXT_ODE: DU4 ?;
|
||||
TSS_LAST_ODE: DU4 ?;
|
||||
TSS_HASH_TABLE: DU4 ?;
|
||||
TSS_ACCOUNT: DU4 ?;
|
||||
TSS_OPTIMIZATION: DU4 ?;
|
||||
TSS_NEXT_SERVANT_CMD: DU4 ?;
|
||||
TSS_LAST_SERVANT_CMD: DU4 ?;
|
||||
TSS_NEXT_MASTER_CMD: DU4 ?;
|
||||
TSS_LAST_MASTER_CMD: DU4 ?;
|
||||
TSS_NEXT_LEX: DU4 ?;
|
||||
TSS_LAST_LEX: DU4 ?;
|
||||
|
||||
TSS_CUR_PARTITION: DU4 ?;
|
||||
TSS_CUR_DIR: DU4 ?;
|
||||
|
||||
TSS_END_TASK_CB: DU4 ?;
|
||||
TSS_USER_NUM: DU4 ?;
|
||||
TSS_ANSWERS: DU8 8 DUP(?);
|
||||
TSS_DOUBLE_ANSWERS: DU8 8 DUP(?);
|
||||
TSS_ANSWERS_TYPES: DU4 8 DUP(?);
|
||||
TSS_ANSWERS_DISPLAYED: DU4 ?;
|
||||
TSS_DBG: DU4 ?;
|
||||
TSS_POPUP: DU4 ?;
|
||||
TSS_RMTCHNL: DU4 ?;
|
||||
TSS_USER_AUX0: DU4 ?;
|
||||
TSS_USER_AUX1: DU4 ?;
|
||||
TSS_USER_AUX2: DU4 ?;
|
||||
TSS_USER_AUX3: DU4 ?;
|
||||
TSS_STRUCT_SIZE:
|
||||
ENDS
|
||||
STRUC 0
|
||||
HT_NEXT: DU4 ?;
|
||||
HT_MASK: DU4 ?;
|
||||
HT_BODY:
|
||||
ENDS
|
||||
|
||||
STRUC 0
|
||||
HTE_NEXT: DU4 ?;
|
||||
HTE_STRING: DU4 ?;
|
||||
HTE_TYPE: DU4 ?;
|
||||
HTE_USE_CNT: DU4 ?;
|
||||
HTE_SOURCE_LINK: DU4 ?;
|
||||
HTE_DEBUG: DU4 ?;
|
||||
HTE_USER0: DU4 ?;
|
||||
ENDS
|
||||
|
||||
STRUC 0
|
||||
SP_EDI: DU4 ?;
|
||||
SP_ESI: DU4 ?;
|
||||
SP_EBP: DU4 ?;
|
||||
SP_ESP: DU4 ?;
|
||||
SP_EBX: DU4 ?;
|
||||
SP_EDX: DU4 ?;
|
||||
SP_ECX: DU4 ?;
|
||||
SP_EAX: DU4 ?;
|
||||
SP_STRUCT_SIZE:
|
||||
SP_EIP: DU4 ?;
|
||||
SP_PARAM1: DU8 ?;
|
||||
SP_PARAM2: DU8 ?;
|
||||
SP_PARAM3: DU8 ?;
|
||||
SP_PARAM4: DU8 ?;
|
||||
SP_PARAM5: DU8 ?;
|
||||
SP_PARAM6: DU8 ?;
|
||||
SP_PARAM7: DU8 ?;
|
||||
SP_PARAM8: DU8 ?;
|
||||
SP_PARAM9: DU8 ?;
|
||||
SP_PARAM10: DU8 ?;
|
||||
SP_PARAM11: DU8 ?;
|
||||
SP_PARAM12: DU8 ?;
|
||||
ENDS
|
||||
|
||||
STRUC 0
|
||||
C_HASH_NEXT: DU4 ?;
|
||||
C_HASH_STRING: DU4 ?;
|
||||
C_HASH_TYPE: DU4 ?;
|
||||
C_USE_CNT: DU4 ?;
|
||||
C_SOURCE_LINK: DU4 ?;
|
||||
C_DEBUG: DU4 ?;
|
||||
C_MEM_CNT: DU2 ?;
|
||||
C_PARAM_CNT: DU2 ?; //FOR FUNCTIONS
|
||||
C_SIZE: DU4 ?; //Must be in same position as HTE_USER1
|
||||
C_MEM_LIST: DU4 ?; //MEMBER LIST
|
||||
C_MEM_LIST_LAST: DU4 ?;
|
||||
C_STATEMENTS: DU4 ?; //For functions
|
||||
ENDS
|
||||
|
||||
STRUC 0
|
||||
IC_CODE: DU4 ?;
|
||||
IC_FLAGS: DU4 ?;
|
||||
IC_DATA: DU8 ?;
|
||||
IC_CLASS: DU4 ?;
|
||||
IC_LINE: DU4 ?;
|
||||
IC_STRUCT_SIZE:
|
||||
ENDS
|
||||
|
||||
STRUC 0
|
||||
ATE_NEXT: DU4 ?;
|
||||
ATE_BASECODE: DU2 ?;
|
||||
ATE_CH: DU1 ?,?;
|
||||
ATE_STRUCT_SIZE:
|
||||
ENDS
|
||||
|
||||
STRUC 0
|
||||
ACS_SRC_SIZE: DU8 ?;
|
||||
ACS_SRC_POS: DU8 ?;
|
||||
ACS_SRC_BUF: DU4 ?;
|
||||
ACS_DST_SIZE: DU8 ?;
|
||||
ACS_DST_POS: DU8 ?;
|
||||
ACS_DST_BUF: DU4 ?;
|
||||
ACS_MIN_BITS: DU4 ?;
|
||||
ACS_MIN_TABLE_ENTRY: DU4 ?;
|
||||
ACS_CUR_ENTRY: DU4 ?;
|
||||
ACS_CUR_BITS_IN_USE: DU4 ?;
|
||||
ACS_NEXT_ENTRY: DU4 ?;
|
||||
ACS_NEXT_BITS_IN_USE: DU4 ?;
|
||||
ACS_STACK_PTR: DU4 ?;
|
||||
ACS_STACK_BASE: DU4 ?;
|
||||
ACS_FREE_INDEX: DU4 ?;
|
||||
ACS_FREE_LIMIT: DU4 ?;
|
||||
ACS_SAVED_BASECODE: DU4 ?;
|
||||
ACS_ENTRY_USED: DU4 ?;
|
||||
ACS_LAST_CH: DU1 ?,?,?,?;
|
||||
ACS_COMPRESS: DU8 ARC_MAX_TABLE_ENTRY+1 DUP(?);
|
||||
ACS_HASH: DU4 ARC_MAX_TABLE_ENTRY+1 DUP(?);
|
||||
ACS_STRUCT_SIZE:
|
||||
ENDS
|
||||
|
||||
@@ -0,0 +1,360 @@
|
||||
USE16
|
||||
JMP U2 J_START2
|
||||
////**************************PROCEDURE*************************
|
||||
// ASM Global variables required for 16-bit start-up
|
||||
ALIGN 4,0x90
|
||||
SYS_BOOT_BASE:: DU4 ?; //Fixed offset from start used by reboot_J
|
||||
SYS_BOOT_HEADER_BASE:: DU4 ?;
|
||||
OS_32START:: DU4 INIT_OS;
|
||||
|
||||
ALIGN 16,0x90
|
||||
GDTTAB:: DU1 MAXGDT*8 DUP(0);
|
||||
SYS_BOOT_CODE:: DU4 0xFF;
|
||||
SYS_MEMBLKS:: DU4 0;
|
||||
FREE_GDT_LIST:: DU4 0;
|
||||
ADAM_TSS:: DU1 TSS_STRUCT_SIZE DUP(0);
|
||||
SYS_TEMP_PTR:: DU4 0,0;
|
||||
|
||||
////**************************PROCEDURE*************************
|
||||
//EBX is SYS_BOOT_CODE (value passed from boot blk)
|
||||
J_START2::
|
||||
MOV AX,(0xA0000-2*BLK_SIZE)/16
|
||||
MOV SS,AX
|
||||
MOV SP,2*BLK_SIZE
|
||||
PUSH EBX //will be SYS_BOOT_CODE
|
||||
MOV AX,0xB800
|
||||
MOV ES,AX
|
||||
MOV U4 ES:[0],('L'+0xF000)+0x10000*('T'+0xF000)
|
||||
MOV U4 ES:[4],0
|
||||
MOV ECX,1200000 //Delay
|
||||
CALL BUSY_WAIT
|
||||
|
||||
CALL U2 GET_IP
|
||||
GET_IP:
|
||||
POP BX
|
||||
SUB BX,GET_IP
|
||||
SHR BX,4
|
||||
MOV AX,CS
|
||||
ADD AX,BX
|
||||
PUSH AX
|
||||
PUSH U2 J_START3
|
||||
RETF
|
||||
J_START3::
|
||||
//XSUM OSMain
|
||||
MOV AX,CS
|
||||
DEC AX
|
||||
MOV DS,AX
|
||||
XOR ESI,ESI
|
||||
MOV ECX,U4 8[ESI] //Get length
|
||||
SHR ECX,4
|
||||
MOV EBX,LT_XSUM
|
||||
@@2: LODSD
|
||||
XOR EBX,EAX
|
||||
LODSD
|
||||
XOR EBX,EAX
|
||||
LODSD
|
||||
XOR EBX,EAX
|
||||
LODSD
|
||||
XOR EBX,EAX
|
||||
XOR ESI,ESI
|
||||
MOV AX,DS
|
||||
INC AX
|
||||
MOV DS,AX
|
||||
LOOP @@2
|
||||
MOV U4 ES:[4],'O'+65536*'K'+0xF000F000
|
||||
OR EBX,EBX
|
||||
JZ J_CONT_START
|
||||
|
||||
//XSUM Error
|
||||
MOV U4 ES:[4],'X'+65536*'M'+0xF000F000
|
||||
@@3: JMP @@3
|
||||
|
||||
BUSY_WAIT::
|
||||
MOV DX,0x379 //Par Port
|
||||
@@1: IN AL,DX
|
||||
DEC ECX
|
||||
JNZ @@1
|
||||
RET
|
||||
////**************************PROCEDURE*************************
|
||||
J_CONT_START:
|
||||
STI
|
||||
//Enter Graphics Mode
|
||||
exe {
|
||||
I8 ch,video_mode;
|
||||
do {
|
||||
CrLf;
|
||||
coutln "1) VGA 640x480x16";
|
||||
coutln "2) SVGA 800x600x16--not supported by all computers";
|
||||
cout "Video Mode:";
|
||||
ch=GetChar;
|
||||
} while (ch<'1' || ch>'2');
|
||||
video_mode=ch-'0';
|
||||
switch (video_mode) {
|
||||
case 1:
|
||||
ExePutS("MOV AX,0x12");
|
||||
break;
|
||||
case 2:
|
||||
ExePutS("MOV AX,0x6A");
|
||||
break;
|
||||
}
|
||||
}
|
||||
INT 0x10 //ENABLE VGA
|
||||
|
||||
//Get memory map
|
||||
MOV AX,0xE801
|
||||
INT 0x15
|
||||
MOV AX,CS
|
||||
MOV DS,AX
|
||||
ADD DX,0x101
|
||||
MOV U2 [SYS_MEMBLKS+2],DX
|
||||
|
||||
CLI
|
||||
|
||||
//Enable A20
|
||||
IN AL,0x92
|
||||
OR AL,2
|
||||
OUT 0x92,AL
|
||||
|
||||
CLD //Start with known registers
|
||||
MOV AX,CS
|
||||
MOV DS,AX
|
||||
MOV ES,AX
|
||||
MOV FS,AX
|
||||
MOV GS,AX
|
||||
XOR EAX,EAX
|
||||
XOR EBX,EBX
|
||||
XOR ECX,ECX
|
||||
XOR EDX,EDX
|
||||
XOR ESI,ESI
|
||||
XOR EDI,EDI
|
||||
XOR EBP,EBP
|
||||
|
||||
XOR EAX,EAX
|
||||
MOV AX,CS
|
||||
SHL EAX,4
|
||||
MOV U4 [SYS_BOOT_BASE],EAX
|
||||
|
||||
POP U4 [SYS_BOOT_CODE]
|
||||
|
||||
MOV BX,CS
|
||||
DEC BX
|
||||
MOV GS,BX
|
||||
MOV EBX,U4 GS:[4]
|
||||
ADD EAX,EBX
|
||||
SUB EAX,16
|
||||
MOV U4 [SYS_BOOT_HEADER_BASE],EAX
|
||||
|
||||
MOV U4 [GDTTAB+SYS_BOOT_DS_SEL],0x000FFFF
|
||||
MOV U4 [GDTTAB+SYS_BOOT_DS_SEL+4],0x0CF9200
|
||||
MOV U4 [GDTTAB+SYS_BOOT_CS_SEL],0x000FFFF
|
||||
MOV U4 [GDTTAB+SYS_BOOT_CS_SEL+4],0x0CF9A00
|
||||
MOV EAX,U4 [SYS_BOOT_BASE]
|
||||
ADD U4 [GDTTAB+SYS_BOOT_DS_SEL+2],EAX
|
||||
ADD U4 [GDTTAB+SYS_BOOT_CS_SEL+2],EAX
|
||||
|
||||
// SETUP POINTER TO LIMIT AND BASE
|
||||
//OF GDT. USE ENTRY (0) BECAUSE IT IS
|
||||
//INVALID.
|
||||
MOV U2 [SYS_TEMP_PTR],MAXGDT*8-1
|
||||
MOV EAX,U4 [SYS_BOOT_BASE]
|
||||
ADD EAX,GDTTAB+NULL_SEL
|
||||
MOV U4 [SYS_TEMP_PTR+2],EAX
|
||||
MOV U2 [SYS_TEMP_PTR+6],0
|
||||
|
||||
// LGDT FU2 SYS_TEMP_PTR
|
||||
DU1 0x67,0x0F,0x01,0x15;
|
||||
DU4 SYS_TEMP_PTR;
|
||||
|
||||
// MOV EAX,CR0 //ENTER PROTECTED MODE!!
|
||||
DU1 0x0F,0x20,0xC0;
|
||||
|
||||
OR AL,1
|
||||
|
||||
|
||||
// MOV CR0,EAX
|
||||
DU1 0x0F,0x22,0xC0;
|
||||
|
||||
DU1 0x66,0xEA; //JMP SYS_CS_SEL:INIT_OS
|
||||
DU4 INIT_OS;
|
||||
DU2 SYS_BOOT_CS_SEL;
|
||||
////**************************PROCEDURE*************************
|
||||
// ASM Global variables not required for 16-bit start-up
|
||||
ALIGN 8,0x90
|
||||
IDTTAB:: DU1 MAXIDT*8 DUP(0);
|
||||
SYS_HEAP_BASE:: DU4 0x100000;
|
||||
SYS_HEAP_LIMIT:: DU4 0;
|
||||
|
||||
exe {
|
||||
ExePrintF("SYS_GRMODE:: DU4 %d;",video_mode);
|
||||
}
|
||||
SYS_GRWIDTH:: DU4 ?;
|
||||
SYS_GRHEIGHT:: DU4 ?;
|
||||
|
||||
SYS_FLAGS:: DU4 0x8; //RAW_CRT_OUT=8
|
||||
SYS_IRQ_FLAGS:: DU4 0;
|
||||
SYS_IRQ_BUSY_FLAGS:: DU4 0;
|
||||
SYS_TEXTBASE:: DU4 0;
|
||||
SYS_GRBASE:: DU4 0;
|
||||
SYS_GRBASE2:: DU4 0;
|
||||
SYS_CUR_RAW_SCAN_CODE:: DU4 0;
|
||||
SYS_CUR_SCAN_CODE:: DU4 0;
|
||||
SYS_EXTERN_TABLE:: DU4 0;
|
||||
MEM_FREE_LIST:: DU4 0;
|
||||
FREE_PAGE_HASH:: DU4 FREE_PAGE_HASH_SIZE DUP(0);
|
||||
FREE_PAGE_HASH2:: DU4 32 DUP(0);
|
||||
PROGRESS1:: DU8 0;
|
||||
PROGRESS2:: DU8 0;
|
||||
PROGRESS3:: DU8 0;
|
||||
PROGRESS4:: DU8 0;
|
||||
SYS_SWAPS_CNTER:: DU4 0;
|
||||
SYS_CUR_FOCUS_TASK:: DU4 0;
|
||||
|
||||
|
||||
////**************************PROCEDURE*************************
|
||||
ALIGN 16,0x90
|
||||
USE32
|
||||
INIT_OS::
|
||||
MOV AX,SYS_BOOT_DS_SEL //LOAD DS SELECTOR
|
||||
MOV DS,AX
|
||||
MOV ES,AX
|
||||
|
||||
MOV U4 [GDTTAB+ZERO_DS_SEL],0x0000FFFF
|
||||
MOV U4 [GDTTAB+ZERO_DS_SEL+4],0x00CF9200
|
||||
MOV U4 [GDTTAB+SYS_CS_SEL],0x0000FFFF
|
||||
MOV U4 [GDTTAB+SYS_CS_SEL+4],0x00CF9A00
|
||||
|
||||
//INIT FREE GDT ENTRIES
|
||||
MOV U4 [FREE_GDT_LIST],0
|
||||
MOV ECX,MAXGDT-FIRST_FREE_SEL/8
|
||||
MOV EAX,FIRST_FREE_SEL
|
||||
@@3: MOV EBX,U4 [FREE_GDT_LIST]
|
||||
MOV U4 GDTTAB[EAX],EBX
|
||||
MOV U4 [FREE_GDT_LIST],EAX
|
||||
ADD EAX,8
|
||||
LOOP @@3
|
||||
|
||||
//Patch absolute addresses
|
||||
MOV ESI,U4 [SYS_BOOT_HEADER_BASE]
|
||||
MOV EDI,U4 [SYS_BOOT_BASE]
|
||||
MOV AX,ZERO_DS_SEL
|
||||
MOV DS,AX
|
||||
MOV ES,AX
|
||||
MOV ECX,U4 1[ESI]
|
||||
LEA ESI,U4 1+4+1[ESI]
|
||||
@@10: LODSD
|
||||
ADD EAX,EDI
|
||||
ADD U4 [EAX],EDI
|
||||
LOOP @@10
|
||||
|
||||
MOV AX,ZERO_DS_SEL
|
||||
MOV DS,AX
|
||||
MOV ES,AX
|
||||
MOV FS,AX
|
||||
MOV GS,AX
|
||||
MOV SS,AX
|
||||
MOV ESP,0x800000 //TEMP
|
||||
|
||||
DU1 0xEA; //JMP SYS_CS_SEL:CONT_INIT_OS
|
||||
DU4 CONT_INIT_OS;
|
||||
DU2 SYS_CS_SEL;
|
||||
|
||||
CONT_INIT_OS::
|
||||
MOV U4 [SYS_HEAP_BASE],0x100000
|
||||
CALL INIT_MEM
|
||||
|
||||
//INIT INTERRUPT TABLE
|
||||
MOV ECX,MAXIDT
|
||||
MOV EDI,IDTTAB
|
||||
MOV ESI,IRQ_VECTORS
|
||||
@@1: LODSW
|
||||
STOSW
|
||||
MOV AX,SYS_CS_SEL
|
||||
STOSW
|
||||
MOV AX,0x8E00 //E=32-bit irq gate
|
||||
STOSW
|
||||
MOVSW
|
||||
LOOP @@1
|
||||
|
||||
MOV U2 [SYS_TEMP_PTR],MAXIDT*8-1
|
||||
MOV U4 [SYS_TEMP_PTR+2],IDTTAB
|
||||
MOV U2 [SYS_TEMP_PTR+6],0
|
||||
// LIDT FU2 SYS_TEMP_PTR
|
||||
DU1 0x0F,0x01,0x1D;
|
||||
DU4 SYS_TEMP_PTR;
|
||||
|
||||
//INIT SYSTEM TSS
|
||||
PUSH 0
|
||||
PUSH DEFAULT_STACK
|
||||
PUSH 0
|
||||
PUSH ADAM_TSS
|
||||
CALL CP_INIT_TSS+4
|
||||
ADD ESP,16
|
||||
MOV FS,AX
|
||||
MOV ESP,U4 FS:[TSS_ESP]
|
||||
|
||||
CALL INIT_FLOATING_CONSTANTS
|
||||
|
||||
JMP U4 CP_OS_MAIN+4
|
||||
|
||||
////**************************PROCEDURE*************************
|
||||
CP_REBOOT::
|
||||
MOV EAX,ZERO_DS_SEL
|
||||
MOV ES,AX
|
||||
MOV U2 ES:[0x472],0
|
||||
|
||||
MOV AL,0x8F
|
||||
OUT 0x70,AL
|
||||
OUT 0xEB,AL
|
||||
MOV AL,0
|
||||
OUT 0x71,AL
|
||||
OUT 0xEB,AL
|
||||
MOV AL,0
|
||||
OUT 0x70,AL
|
||||
OUT 0xEB,AL
|
||||
|
||||
IN AL,0x92
|
||||
OR AL,1
|
||||
OUT 0x92,AL
|
||||
OUT 0xEB,AL
|
||||
@@100: JMP @@100
|
||||
|
||||
|
||||
////**************************PROCEDURE*************************
|
||||
FC_1:: DU8 0;
|
||||
FC_PI:: DU8 0;
|
||||
FC_PI2:: DU8 0;
|
||||
FC_E:: DU8 0;
|
||||
FC_LOG2_10:: DU8 0;
|
||||
FC_LOG2_E:: DU8 0;
|
||||
FC_LOG10_2:: DU8 0;
|
||||
FC_LOGE_2:: DU8 0;
|
||||
INIT_FLOATING_CONSTANTS::
|
||||
PUSH EBP
|
||||
MOV EBP,ESP
|
||||
SUB ESP,8
|
||||
FLD1
|
||||
FSTP U4[FC_1]
|
||||
FLDPI
|
||||
FSTP U4[FC_PI]
|
||||
FLDPI
|
||||
FLDPI
|
||||
FADDP
|
||||
FSTP U4[FC_PI2]
|
||||
FLDL2T
|
||||
FSTP U4[FC_LOG2_10]
|
||||
FLDL2E
|
||||
FSTP U4[FC_LOG2_E]
|
||||
FLDLG2
|
||||
FSTP U4[FC_LOG10_2]
|
||||
FLDLN2
|
||||
FSTP U4[FC_LOGE_2]
|
||||
|
||||
FLD1
|
||||
FSTP U4 -8[EBP]
|
||||
CALL CP_EXP
|
||||
MOV U4 [FC_E],EAX
|
||||
MOV U4 [FC_E+4],EDX
|
||||
|
||||
ADD ESP,8
|
||||
POP EBP
|
||||
RET
|
||||
@@ -0,0 +1,29 @@
|
||||
|
||||
void QSort(U1 *base,U8 num, U8 width, U1 *compare)
|
||||
{ //This uses a shell sort
|
||||
I8 my_compare(U1 *elem1,U1 *elem2 );
|
||||
I8 span=num>>1,i;
|
||||
U1 *b1,*b2,*temp=MAlloc(width);
|
||||
BoolU4 cont;
|
||||
|
||||
my_compare=compare;
|
||||
while (span) {
|
||||
cont=TRUE;
|
||||
while (cont) {
|
||||
cont=FALSE;
|
||||
for (i=0;i+span<num;i++) {
|
||||
b1=base+width*i;
|
||||
b2=base+width*(i+span);
|
||||
if (my_compare(b1,b2)>0) {
|
||||
MemCpy(temp,b1,width);
|
||||
MemCpy(b1,b2,width);
|
||||
MemCpy(b2,temp,width);
|
||||
cont=TRUE;
|
||||
}
|
||||
}
|
||||
}
|
||||
span>>=1;
|
||||
}
|
||||
Free(temp);
|
||||
}
|
||||
|
||||
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,78 @@
|
||||
/**************** EXTERNS *********************/
|
||||
extern void PutSysText(I1 *name);
|
||||
extern I1 *ReadTextFile(I1 *filename,U8 *attr=NULL);
|
||||
extern void throw(...);
|
||||
extern I1 *MSPrintF(I1 *src,...);
|
||||
extern BoolU4 Cd(I1 *name,BoolU4 make_dirs=FALSE);
|
||||
extern BoolU4 MkDir(I1 *filename);
|
||||
extern void Msg(U8 code,U8 p1,U8 p2,U8 flags=0);
|
||||
extern I1 PartitionToDrive(LTPartition *p=NULL);
|
||||
extern BoolU4 RBlks(LTPartition *p,U1 *buf, U8 blk, U8 cnt,BoolU4 unlock);
|
||||
extern BoolU4 WBlks(LTPartition *p,U1 *buf, U8 blk, U8 cnt,BoolU4 unlock);
|
||||
extern void InvalidateDiskCache(LTPartition *p,BoolU4 unlock);
|
||||
extern BoolU4 InitBlkDev(LTBlkDev *bd,BoolU4 unlock);
|
||||
extern U8 AllocClusters(LTPartition *p,U8 c,U8 cnt,BoolU4 contiguous,BoolU4 unlock);
|
||||
extern BoolU4 Drive(I1 drive_letter);
|
||||
extern LTFile *FOpen(I1 *filename,I1 *flags,U8 cnt=0);
|
||||
extern U8 FSize(LTFile *f);
|
||||
extern void FSync(LTFile *f);
|
||||
extern void FClose(LTFile *f);
|
||||
extern BoolU4 FRBlks(LTFile *f,U1 *buf,U8 blk=LTFB_NEXT_BLK,U8 cnt=1);
|
||||
extern BoolU4 FWBlks(LTFile *f,U1 *buf,U8 blk=LTFB_NEXT_BLK,U8 cnt=1);
|
||||
extern void ReleaseTaskPartitions();
|
||||
extern void AdamLog(I1 *src,...);
|
||||
extern void AdamErr(I1 *src,...);
|
||||
extern BoolU4 SysDbg(BoolU4 val);
|
||||
extern BoolU4 IsSysDbg();
|
||||
extern BoolU4 Raw(BoolU4 val);
|
||||
extern BoolU4 IsRaw();
|
||||
extern void D(U1 *buf,U8 cnt=0x80,BoolU4 show_offset=TRUE);
|
||||
extern void Dm(U1 *buf,U8 cnt=0x80);
|
||||
extern U1 *Caller();
|
||||
extern U1 *CallerCaller();
|
||||
extern void DbgStr(I1 *st,U8 mS=100);
|
||||
extern void DbgNum(U8 num,U8 mS=100);
|
||||
extern void DbgAdd(U4 *add,U8 mS=100);
|
||||
extern void DbgD(U4 *add,U8 cnt=0x80,U8 mS=100);
|
||||
extern void DbgDm(U4 *add,U8 cnt=0x80,U8 mS=100);
|
||||
extern void PrintF(I1 *fmt,...);
|
||||
|
||||
/*********** MOST GLBL VARS ***********/
|
||||
I1 sys_temp_filename[80];
|
||||
SysAccntStruct sys_accounts;
|
||||
TssCmdStruct sys_macro_queue;
|
||||
TssStruct *macro_util_tss;
|
||||
TssStruct *adam_tss;
|
||||
U4 num_spawned_users;
|
||||
TssStruct *monitor_floppy_tss;
|
||||
U1 *grfont;
|
||||
|
||||
U4 FDC_retries;
|
||||
U4 FDC_DRIVE_HEADS;
|
||||
U4 FDC_DISK_CYLINDERS;
|
||||
U4 FDC_DISK_SECTORS;
|
||||
U4 FDC_MAX_SECTOR;
|
||||
U4 FDC_DMA_BUF;
|
||||
|
||||
LTCacheBlk *LTDCBase;
|
||||
LTCacheBlk *LTDCNext_lru,*LTDCLast_lru;
|
||||
LTCacheBlk **LTDCHashTable;
|
||||
|
||||
|
||||
U8 dc_col;
|
||||
U8 sys_timer,jiffies;
|
||||
U8 rnd_SEED;
|
||||
Ltf *sys_clipboard_ltf;
|
||||
U8 disk_status_display,compiled_lines;
|
||||
LTBlkDev *local_blkdevs,*boot_blkdev;
|
||||
LTPartition *local_partitions,*default_partition;
|
||||
I1 default_drive;
|
||||
LTPartition *drive_to_partition[32];
|
||||
I8 num_blkdevs;
|
||||
I1 *sys_startup_account;
|
||||
I1 *wordstat_mask;
|
||||
BoolU4 ip_inhibit_win_operations;
|
||||
I1 *sys_compile_time;
|
||||
U4 *vga_image;
|
||||
|
||||
|
||||
@@ -0,0 +1,707 @@
|
||||
BoolU4 YorN()
|
||||
{
|
||||
I8 ch;
|
||||
cout "(y or n)? ";
|
||||
while (TRUE) {
|
||||
ch=ToUpper(GetKey);
|
||||
if (ch=='Y') {
|
||||
coutln "$$FU$$$$BU$$YES$$FG$$$$BG$$";
|
||||
return TRUE;
|
||||
} else if (ch=='N') {
|
||||
coutln "$$FU$$$$BU$$NO$$FG$$$$BG$$";
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
I1 *PointAtListEntry(I8 entry_number, I1 *lst)
|
||||
{
|
||||
while (*lst && entry_number) {
|
||||
while (*lst) /* Advance to end of cur entry. */
|
||||
lst++;
|
||||
lst++; /* Skip trailing zero */
|
||||
entry_number--;
|
||||
if (*lst=='@') { /* Check for '@' alias list entry*/
|
||||
entry_number++;
|
||||
lst++;
|
||||
}
|
||||
}
|
||||
return lst;
|
||||
}
|
||||
|
||||
I8 MatchListEntry(I1 *src, I1 *lst,I8 flags=0,I8 *ambiguity_overkill_ptr=NULL)
|
||||
/* RETURNS: -2 if Ambiguous, -1 if not found, else entry_number */
|
||||
{
|
||||
I8 l,entry_num=0,result=-1,unutilized_src;
|
||||
I1 *s;
|
||||
BoolU4 exact_match=FALSE;
|
||||
|
||||
l=StrLen(src);
|
||||
if (ambiguity_overkill_ptr)
|
||||
*ambiguity_overkill_ptr=l;
|
||||
while (*lst) {
|
||||
if (*lst=='@') { /* Check for '@' alias list entry*/
|
||||
entry_num--;
|
||||
lst++;
|
||||
}
|
||||
|
||||
s=src;
|
||||
if (flags & MLE_IGNORE_CASE)
|
||||
while (*s && ToUpper(*s) == ToUpper(*lst)) {
|
||||
s++;
|
||||
lst++;
|
||||
}
|
||||
else
|
||||
while (*s && *s==*lst) {
|
||||
s++;
|
||||
lst++;
|
||||
}
|
||||
unutilized_src=l-(s-src);
|
||||
if (!(*s)) { /* Did we reach end of sourcecout */
|
||||
if (!(*lst)) { /* Did we reach end of list entrycout */
|
||||
if (!ambiguity_overkill_ptr)
|
||||
return entry_num; /* Found Exact match */
|
||||
result=entry_num;
|
||||
exact_match=TRUE;
|
||||
} else {
|
||||
if (result!=-1) {
|
||||
if (ambiguity_overkill_ptr)
|
||||
*ambiguity_overkill_ptr=0;
|
||||
if (!exact_match)
|
||||
result=-2; /* AMBIGUOUS RESPONSE unless later exact match*/
|
||||
} else {
|
||||
if (!(flags & MLE_EXACT))
|
||||
result=entry_num;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (ambiguity_overkill_ptr && *ambiguity_overkill_ptr>(unutilized_src-1))
|
||||
*ambiguity_overkill_ptr=unutilized_src-1;
|
||||
}
|
||||
|
||||
while (*lst) /* Advance to end of cur entry. */
|
||||
lst++;
|
||||
lst++; /* Skip trailing zero */
|
||||
entry_num++;
|
||||
}
|
||||
if (ambiguity_overkill_ptr && result==-1)
|
||||
*ambiguity_overkill_ptr=0;
|
||||
return result;
|
||||
}
|
||||
|
||||
void UndefinedSysText(I1 *name)
|
||||
{
|
||||
PutSysText("ST_UNDEFINED_SYSTEXT");
|
||||
PutS(name);
|
||||
throw(EXCEPT_UNDEF_SYSTEXT,name);
|
||||
}
|
||||
|
||||
|
||||
I1 *SysText(I1 *name)
|
||||
{
|
||||
SysHashEntry *temph=FindLocalHash(name,HTT_SYSTEXT);
|
||||
if (temph)
|
||||
return temph->user0;
|
||||
else
|
||||
UndefinedSysText(name);
|
||||
}
|
||||
|
||||
I1 *SysTextSub(U8 sub,I1 *name)
|
||||
{
|
||||
SysHashEntry *temph=FindLocalHash(name,HTT_SYSTEXT);
|
||||
if (temph)
|
||||
return PointAtListEntry(sub,temph->user0);
|
||||
else
|
||||
UndefinedSysText(name);
|
||||
}
|
||||
|
||||
I8 SysTextSubCount(I1 *name)
|
||||
{
|
||||
SysHashEntry *temph=FindLocalHash(name,HTT_SYSTEXT);
|
||||
if (temph)
|
||||
return temph->user1;
|
||||
else
|
||||
UndefinedSysText(name);
|
||||
}
|
||||
|
||||
I8 MatchSysTextEntry(I1 *src, I1 *lst_name,
|
||||
I8 flags=0,I8 *ambiguity_overkill_ptr=NULL)
|
||||
{
|
||||
return MatchListEntry(src,SysText(lst_name),
|
||||
flags,ambiguity_overkill_ptr);
|
||||
}
|
||||
|
||||
asm {CP_PUT_SYSTEXT:}
|
||||
void PutSysText(I1 *name)
|
||||
{
|
||||
PutS(SysText(name));
|
||||
}
|
||||
|
||||
|
||||
SysHashEntry *LoadStr(I1 *name, I1 *st)
|
||||
{
|
||||
SysHashEntry *temph,
|
||||
*temph1=FindHashBucket(name,Fs->hash_table);
|
||||
temph=MAllocZ(sizeof(SysHashEntry));
|
||||
temph->next=*temph1;
|
||||
*temph1=temph;
|
||||
temph->type=HTT_SYSTEXT;
|
||||
temph->string=NewString(name);
|
||||
temph->user0=NewString(st);
|
||||
temph->user1=-1;
|
||||
return temph;
|
||||
}
|
||||
|
||||
SysHashEntry *LoadList(I1 *name, I1 *st)
|
||||
{
|
||||
U8 cnt=0;
|
||||
I1 *ptr;
|
||||
SysHashEntry *temph,
|
||||
*temph1=FindHashBucket(name,Fs->hash_table);
|
||||
temph=MAllocZ(sizeof(SysHashEntry));
|
||||
temph->next=*temph1;
|
||||
*temph1=temph;
|
||||
temph->type=HTT_SYSTEXT;
|
||||
temph->string=NewString(name);
|
||||
ptr=st;
|
||||
while (*ptr) {
|
||||
while (*ptr++);
|
||||
cnt++;
|
||||
}
|
||||
temph->user0=MAlloc(ptr+1-st);
|
||||
MemCpy(temph->user0,st,ptr+1-st);
|
||||
temph->user1=cnt;
|
||||
return temph;
|
||||
}
|
||||
|
||||
I8 Occurrences(I1 *src, I8 ch)
|
||||
{
|
||||
I8 i=0;
|
||||
while (*src)
|
||||
if (*src++ == ch) i++;
|
||||
return i;
|
||||
}
|
||||
|
||||
I8 SpacesToTabs(I1 *dst2,I1 *src)
|
||||
{
|
||||
I1 *src2,*dst=dst2;
|
||||
I8 i,changed=0,space_cnt,space_cnt2,col=0;
|
||||
while (*src) {
|
||||
src2=src;
|
||||
space_cnt=0;
|
||||
while (*src2==CH_SPACE) {
|
||||
space_cnt++;
|
||||
src2++;
|
||||
}
|
||||
if (space_cnt<2) {
|
||||
if (*src==CH_TAB)
|
||||
col=0;
|
||||
else {
|
||||
col++;
|
||||
if (col==8)
|
||||
col=0;
|
||||
}
|
||||
*(dst++)=*(src++);
|
||||
} else {
|
||||
while (col+space_cnt>=8) {
|
||||
space_cnt2=8-col;
|
||||
if (space_cnt2==1)
|
||||
*(dst++)=CH_SPACE;
|
||||
else {
|
||||
*(dst++)=CH_TAB;
|
||||
changed=changed+(space_cnt2-1);
|
||||
}
|
||||
space_cnt=space_cnt-space_cnt2;
|
||||
col=0;
|
||||
}
|
||||
for (i=0;i<space_cnt;i++) {
|
||||
*(dst++)=CH_SPACE;
|
||||
col++;
|
||||
}
|
||||
src=src2;
|
||||
}
|
||||
}
|
||||
*(dst--)=0;
|
||||
return changed;
|
||||
}
|
||||
|
||||
I1 *TabsToSpaces(I1 *src)
|
||||
{
|
||||
I8 i,j,l=StrLen(src)<<1+2,col=0;
|
||||
I1 ch,*dst=MAlloc(l),*temp;
|
||||
while (ch=*src++) {
|
||||
if (ch==CH_TAB) {
|
||||
j=(col+8) & -0x8;
|
||||
for (i=col;i<j;i++) {
|
||||
dst[i]=CH_SPACE;
|
||||
if (i>=l-2) {
|
||||
temp=MAlloc(l<<1);
|
||||
MemCpy(temp,dst,i+1);
|
||||
Free(dst);
|
||||
l<<=1;
|
||||
dst=temp;
|
||||
}
|
||||
}
|
||||
col=j;
|
||||
} else {
|
||||
dst[col]=ch;
|
||||
if (col>=l-2) {
|
||||
temp=MAlloc(l<<1);
|
||||
MemCpy(temp,dst,col+1);
|
||||
Free(dst);
|
||||
l*=2;
|
||||
dst=temp;
|
||||
}
|
||||
col++;
|
||||
}
|
||||
}
|
||||
dst[col]=0;
|
||||
return dst;
|
||||
}
|
||||
|
||||
I1 *StringUtil(I1 *u, I8 mask)
|
||||
{
|
||||
I1 *src,*dst;
|
||||
I8 ch;
|
||||
|
||||
src=u;
|
||||
if (mask & SU_REMOVE_LEADING)
|
||||
while (*src==CH_SPACE || *src==CH_SHIFT_SPACE || *src==CH_TAB)
|
||||
src++;
|
||||
|
||||
dst=u;
|
||||
while (ch=*src++) {
|
||||
if (ch==CH_SPACE || ch==CH_SHIFT_SPACE || ch==CH_TAB) {
|
||||
if (!(mask & SU_REMOVE_SPACES)) {
|
||||
if (mask & SU_SINGLE_SPACE) {
|
||||
(*dst++) = CH_SPACE;
|
||||
while (ch= *src++ && (ch==CH_SPACE || ch==CH_SHIFT_SPACE || ch==CH_TAB) );
|
||||
src--;
|
||||
} else
|
||||
(*dst++) = ch;
|
||||
}
|
||||
} else {
|
||||
if (!(mask & SU_REMOVE_CTRL_CHARS) || ch>=CH_SHIFT_SPACE)
|
||||
(*dst++)=ch;
|
||||
}
|
||||
}
|
||||
*dst=0;
|
||||
|
||||
if (mask & SU_CAP_UNDERSCORES) {
|
||||
src=u;
|
||||
dst=u;
|
||||
while (*src) {
|
||||
*dst++=ToUpper(*src++);
|
||||
while (*src && *src!='_')
|
||||
*dst++=*src++;
|
||||
if (*src=='_')
|
||||
src++;
|
||||
}
|
||||
*dst=0;
|
||||
}
|
||||
|
||||
if (mask & SU_REMOVE_TRAILING)
|
||||
while ( dst != u && (!*dst || *dst==CH_SPACE || *dst==CH_SHIFT_SPACE || *dst==CH_TAB))
|
||||
(*dst--)=0;
|
||||
if (mask & SU_DISCARD_PARITY)
|
||||
for (dst=u;*dst;dst++) {
|
||||
ch=*dst;
|
||||
*dst=ch & 127;
|
||||
}
|
||||
if (mask & SU_TO_UPPER)
|
||||
for (dst=u;*dst;dst++) {
|
||||
ch=*dst;
|
||||
if (ch>=0x61 && ch<=0x7A)
|
||||
*dst = ch-0x20;
|
||||
}
|
||||
if (mask & SU_TO_LOWER)
|
||||
for (dst=u;*dst;dst++) {
|
||||
ch=*dst;
|
||||
if (ch>=0x41 && ch<=0x5A)
|
||||
*dst = ch+0x20;
|
||||
}
|
||||
if (mask & SU_SAFE_DOLLAR)
|
||||
for (dst=u;*dst;dst++) {
|
||||
ch=*dst;
|
||||
if (!Bt(safe_dollar_chars_bitmap,*dst))
|
||||
*dst = '.';
|
||||
}
|
||||
if (mask & SU_S2T)
|
||||
SpacesToTabs(u,u);
|
||||
return u;
|
||||
}
|
||||
|
||||
I1 *MStringUtil(I1 *src,U8 flags)
|
||||
{
|
||||
I1 *dst=NewString(src),*dst2,*temp;
|
||||
StringUtil(dst,flags);
|
||||
if (flags & SU_T2S) {
|
||||
temp=TabsToSpaces(dst);
|
||||
Free(dst);
|
||||
dst=temp;
|
||||
}
|
||||
dst2=NewString(dst); //Shorten
|
||||
Free(dst);
|
||||
return dst2;
|
||||
}
|
||||
|
||||
I1 *RemoveFirstSeg(I1 *src, I1 *marker, I1 *dst)
|
||||
{
|
||||
I1 *temp,*temp1,ch;
|
||||
|
||||
temp = src;
|
||||
temp1= dst;
|
||||
while ( (ch= *src++) && !Occurrences(marker,ch) )
|
||||
*dst++=ch;
|
||||
|
||||
*dst = 0;
|
||||
if (ch)
|
||||
StrCpy(temp,src);
|
||||
else
|
||||
*temp=0;
|
||||
return temp1;
|
||||
}
|
||||
|
||||
|
||||
I1 *RemoveLastSeg(I1 *src, I1 *marker, I1 *dst)
|
||||
{
|
||||
I1 *temp;
|
||||
|
||||
temp=src+StrLen(src);
|
||||
while (temp>src && !Occurrences(marker,*temp))
|
||||
temp--;
|
||||
if (Occurrences(marker,*temp)) {
|
||||
StrCpy(dst,temp+1);
|
||||
*temp=0;
|
||||
} else {
|
||||
StrCpy(dst,src);
|
||||
*src=0;
|
||||
}
|
||||
return dst;
|
||||
}
|
||||
|
||||
I1 *SearchString(I1 *src,I1 *pattern,U8 flags=0)
|
||||
{
|
||||
BoolU4 cont;
|
||||
U1 *src2;
|
||||
I1 *saved_src=src;
|
||||
I8 plen=StrLen(pattern);
|
||||
do {
|
||||
cont=FALSE;
|
||||
if (flags & SS_IGNORE_CASE)
|
||||
src=StrIStr(src,pattern);
|
||||
else
|
||||
src=StrStr(src,pattern);
|
||||
if (src && flags & SS_WHOLE_LABELS) {
|
||||
src2=src+plen;
|
||||
if (Bt(alpha_numeric_bitmap,*src2)) {
|
||||
src++; //TODO: Numbers could be false negative
|
||||
if (*src)
|
||||
cont=TRUE;
|
||||
else
|
||||
src=NULL;
|
||||
} else {
|
||||
if (src!=saved_src) {
|
||||
src2=src-1;
|
||||
if (Bt(alpha_numeric_bitmap,*src2)) {
|
||||
src++;
|
||||
if (*src)
|
||||
cont=TRUE;
|
||||
else
|
||||
src=NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} while (cont);
|
||||
return src;
|
||||
}
|
||||
|
||||
BoolU4 WildCardMatch(I1 *wild_st,I1 *src_st)
|
||||
{
|
||||
U8 ch1,ch2;
|
||||
while (TRUE) {
|
||||
if ( !(ch1 = *src_st++)) {
|
||||
if (*wild_st)
|
||||
return FALSE;
|
||||
else
|
||||
return TRUE;
|
||||
} else {
|
||||
if ( !(ch2 = *wild_st++))
|
||||
return FALSE;
|
||||
else {
|
||||
if (ch2 == '*') {
|
||||
if (!(ch2 = *wild_st++))
|
||||
return TRUE;
|
||||
while (ch2 != ch1)
|
||||
if (!(ch1 = *src_st++))
|
||||
return FALSE;
|
||||
} else
|
||||
if (ch2!='?')
|
||||
if (ch1!=ch2)
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
BoolU4 WildFileNameList(I1 *wild_st,I1 *src_st)
|
||||
{
|
||||
BoolU4 result=FALSE;
|
||||
I1 *buf1=NewString(wild_st),
|
||||
*buf2=MAlloc(StrLen(wild_st)+1);
|
||||
while (TRUE) {
|
||||
RemoveFirstSeg(buf1,";",buf2);
|
||||
if (*buf2) {
|
||||
if (*buf2=='~') {
|
||||
if (WildCardMatch(buf2+1,src_st)) {
|
||||
result=FALSE;
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
if (WildCardMatch(buf2,src_st))
|
||||
result=TRUE;
|
||||
}
|
||||
} else
|
||||
break;
|
||||
}
|
||||
Free(buf1);
|
||||
Free(buf2);
|
||||
return result;
|
||||
}
|
||||
|
||||
I1 *Add2String(I1 *base,I1 *addition)
|
||||
{ //doubles length
|
||||
I1 *result;
|
||||
I8 blen=StrLen(base),alen=StrLen(addition);
|
||||
I8 bmem=MSize(base);
|
||||
if (blen+alen+1>bmem) {
|
||||
result=MAlloc(bmem<<1+alen+1);
|
||||
MemCpy(result,base,blen);
|
||||
StrCpy(result+blen,addition);
|
||||
Free(base);
|
||||
} else {
|
||||
result=base;
|
||||
StrCpy(result+blen,addition);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
void CheckLTPartition(LTPartition *p)
|
||||
{
|
||||
if (!p || p->ch_L!='L' || p->ch_P!='P' || p->ch_E!='E')
|
||||
throw(EXCEPT_PARTITION,9);
|
||||
}
|
||||
|
||||
I1 PartitionToDrive(LTPartition *p=NULL)
|
||||
{
|
||||
if (!p)
|
||||
p=Fs->cur_partition;
|
||||
CheckLTPartition(p);
|
||||
return p->drive;
|
||||
}
|
||||
|
||||
LTPartition *DriveToPartition(I1 drive=0)
|
||||
{
|
||||
LTPartition *p;
|
||||
if (!drive)
|
||||
p=Fs->cur_partition;
|
||||
else if (drive==':')
|
||||
p=default_partition;
|
||||
else
|
||||
p=drive_to_partition[ToUpper(drive)-'A'];
|
||||
CheckLTPartition(p);
|
||||
return p;
|
||||
}
|
||||
|
||||
void CheckLTBlkDev(LTBlkDev *bdev)
|
||||
{
|
||||
if (!bdev || bdev->ch_L!='L' ||
|
||||
bdev->ch_B!='B' || bdev->ch_D!='D')
|
||||
throw(EXCEPT_BLKDEV,1);
|
||||
if (!bdev->type || bdev->type>LTBDT_FILE)
|
||||
throw(EXCEPT_BLKDEV,2);
|
||||
}
|
||||
|
||||
LTBlkDev *DriveToBlkDev(I1 drive=0)
|
||||
{
|
||||
LTPartition *p=DriveToPartition(drive);
|
||||
LTBlkDev *bdev=p->bdev;
|
||||
CheckLTBlkDev(bdev);
|
||||
return bdev;
|
||||
}
|
||||
|
||||
BoolU4 DriveIsWritable(I1 drive=0)
|
||||
{
|
||||
LTBlkDev *bdev=DriveToBlkDev(drive);
|
||||
if (bdev->flags & LTBDF_READ_ONLY)
|
||||
return FALSE;
|
||||
else
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
I1 *CurDir()
|
||||
{
|
||||
I1 *st=MAlloc(StrLen(Fs->cur_dir)+3);
|
||||
st[0]=PartitionToDrive;
|
||||
st[1]=':';
|
||||
StrCpy(st+2,Fs->cur_dir);
|
||||
return st;
|
||||
}
|
||||
|
||||
I1 *AbsoluteDirName(I1 *name)
|
||||
{
|
||||
I8 maxlen;
|
||||
I1 drive[3],*hdir,*cur_dir,*buf2,*buf3,*buf,*my_name,*temp_name;
|
||||
if (!Fs->cur_dir)
|
||||
return NewString(name);
|
||||
if (!*Fs->cur_dir)
|
||||
return NewString(name);
|
||||
my_name=MStringUtil(name,
|
||||
SU_REMOVE_LEADING|SU_REMOVE_TRAILING|
|
||||
SU_DISCARD_PARITY|SU_REMOVE_CTRL_CHARS);
|
||||
temp_name=my_name;
|
||||
drive[0]=PartitionToDrive;
|
||||
drive[1]=':';
|
||||
drive[2]=0;
|
||||
if (*my_name && my_name[1]==':') {
|
||||
if (*my_name==':')
|
||||
drive[0]=default_drive;
|
||||
else
|
||||
drive[0]=*my_name;
|
||||
my_name=my_name+2;
|
||||
cur_dir=NewString("/");
|
||||
} else
|
||||
cur_dir=NewString(Fs->cur_dir);
|
||||
if (*my_name=='/') {
|
||||
Free(cur_dir);
|
||||
cur_dir=NewString("/");
|
||||
my_name++;
|
||||
}
|
||||
|
||||
buf2=NewString(my_name);
|
||||
maxlen=StrLen(cur_dir)+1+StrLen(buf2)+1;
|
||||
buf3=MAlloc(maxlen);
|
||||
buf =MAlloc(maxlen);
|
||||
StrCpy(buf3,cur_dir);
|
||||
while (*buf2) {
|
||||
RemoveFirstSeg(buf2,"/",buf);
|
||||
if (!*buf)
|
||||
StrCpy(buf3,"/");
|
||||
else if (!StrCmp(buf,"..")) {
|
||||
RemoveLastSeg(buf3,"/",buf);
|
||||
if (!*buf3)
|
||||
StrCpy(buf3,"/");
|
||||
} else if (!StrCmp(buf,".")) {
|
||||
;
|
||||
} else if (*buf) {
|
||||
if (!StrCmp(buf,"HOME")) {
|
||||
Free(buf3);
|
||||
hdir=HomeDirString;
|
||||
buf3=MAlloc(maxlen+StrLen(hdir));
|
||||
StrCpy(buf3,hdir+2);
|
||||
Free(hdir);
|
||||
drive[0]=default_drive;
|
||||
} else {
|
||||
if (StrCmp(buf3,"/"))
|
||||
StrCat(buf3,"/");
|
||||
StrCat(buf3,buf);
|
||||
}
|
||||
}
|
||||
}
|
||||
Free(cur_dir);
|
||||
cur_dir=MAlloc(StrLen(buf3)+3);
|
||||
StrCpy(cur_dir,drive);
|
||||
StrCpy(cur_dir+2,buf3);
|
||||
Free(buf);
|
||||
Free(buf2);
|
||||
Free(buf3);
|
||||
Free(temp_name);
|
||||
return cur_dir;
|
||||
}
|
||||
|
||||
I1 *AbsoluteFileName(I1 *name)
|
||||
{
|
||||
I1 *buf,*buf2,*buf3,*my_name,*temp_name,*temp_buf;
|
||||
my_name=MStringUtil(name,
|
||||
SU_REMOVE_LEADING|SU_REMOVE_TRAILING|
|
||||
SU_DISCARD_PARITY|SU_REMOVE_CTRL_CHARS);
|
||||
temp_name=my_name;
|
||||
buf=NewString(my_name);
|
||||
temp_buf=buf;
|
||||
if (*buf && buf[1]==':') {
|
||||
buf+=2;
|
||||
my_name+=2;
|
||||
}
|
||||
buf2=MAlloc(StrLen(temp_name)+1);
|
||||
RemoveLastSeg(buf,"/",buf2);
|
||||
if (*my_name=='/' && !*buf)
|
||||
StrCpy(buf,"/");
|
||||
buf3=AbsoluteDirName(temp_buf);
|
||||
Free(temp_buf);
|
||||
buf=MAlloc(StrLen(buf3)+1+StrLen(buf2)+1);
|
||||
StrCpy(buf,buf3);
|
||||
if (buf[StrLen(buf)-1]!='/')
|
||||
StrCat(buf,"/");
|
||||
StrCat(buf,buf2);
|
||||
Free(buf2);
|
||||
Free(buf3);
|
||||
Free(temp_name);
|
||||
return buf;
|
||||
}
|
||||
|
||||
I1 *ChangeExtension(I1 *name,I1 *extension)
|
||||
{
|
||||
I1 *buf=MAlloc(StrLen(name)+1),
|
||||
*result=MAlloc(StrLen(name)+1+StrLen(extension)+1);
|
||||
StrCpy(result,name);
|
||||
if (Occurrences(name,'.'))
|
||||
RemoveLastSeg(result,".",buf);
|
||||
StrCat(result,".");
|
||||
StrCat(result,extension);
|
||||
Free(buf);
|
||||
return result;
|
||||
}
|
||||
|
||||
I1 *DefaultExtension(I1 *name,I1 *extension)
|
||||
{
|
||||
I1 *result=MAlloc(StrLen(name)+1+StrLen(extension)+1);
|
||||
StrCpy(result,name);
|
||||
if (!Occurrences(name,'.')) {
|
||||
StrCat(result,".");
|
||||
StrCat(result,extension);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
U8 FileAttr(I1 *name,U8 attr=0)
|
||||
{
|
||||
I1 *ptr=name,ch=0;
|
||||
while (*ptr && *ptr!='.')
|
||||
ptr++;
|
||||
if (*ptr=='.')
|
||||
ch=ToUpper(ptr[StrLen(ptr)-1]);
|
||||
if (ch=='Z')
|
||||
attr|=LT_ATTR_COMPRESSED;
|
||||
else
|
||||
attr&=~LT_ATTR_COMPRESSED;
|
||||
//TODO: temporary
|
||||
attr|=LT_ATTR_CONTIGUOUS;
|
||||
return attr;
|
||||
}
|
||||
|
||||
BoolU4 CheckFileName(I1 *name)
|
||||
{
|
||||
I1 *ptr=name;
|
||||
if (!name) return FALSE;
|
||||
if (!*ptr) return FALSE;
|
||||
if (*ptr=='.') {
|
||||
if (!ptr[1]) return TRUE;
|
||||
if (ptr[1]=='.' && !ptr[2]) return TRUE;
|
||||
}
|
||||
if (StrLen(name)>LT_MAX_FILENAME_LEN) return FALSE;
|
||||
while (*ptr)
|
||||
if (!Bt(filename_chars_bitmap,*ptr++))
|
||||
return FALSE;
|
||||
return TRUE;
|
||||
}
|
||||
@@ -0,0 +1,93 @@
|
||||
void LoadSysStrings()
|
||||
{
|
||||
LoadStr("ST_USER_STARTUP","Welcome\r\n");
|
||||
LoadStr("ST_UNDEFINED_SYSTEXT","ERROR: Undefined SysText\r\n");
|
||||
LoadStr("ST_UNDEFINED_EXTERN","ERROR: Undefined Extern\r\n");
|
||||
LoadStr("ST_FILE_NOT_FOUND","ERROR: File not found.\r\n");
|
||||
LoadStr("ST_INVALID_FILENAME","ERROR: Invalid File Name.\r\n");
|
||||
LoadStr("ST_PRESS_A_KEY","PRESS A KEY\r\n");
|
||||
LoadStr("ST_VERIFY_ERROR","Verify Error:");
|
||||
LoadStr("ST_NOT_LT","ERROR: Not LT Partition\r\n");
|
||||
LoadStr("ST_NOT_ISO9660","ERROR: Not ISO9660 Partition\r\n");
|
||||
LoadStr("ST_DELETE","Del ");
|
||||
LoadStr("ST_INVALID_DRIVE","ERROR: Invalid Drive\r\n");
|
||||
LoadStr("ST_CUR_PARTITION","Current Partition: ");
|
||||
LoadStr("ST_FILE_SYSTEM_NOT_SUPPORTED","ERROR: File System Not supported\r\n");
|
||||
LoadStr("ST_NO_MATCHING_ENTRIES","No matching entries\r\n");
|
||||
LoadStr("ST_OUT_OF_ROOT_DIR_SPACE","ERROR: Out of Root Dir Space\r\n");
|
||||
LoadStr("ST_OUT_OF_DRIVE_SPACE","ERROR: Out of Drive Space\r\n");
|
||||
LoadStr("ST_INVALID_CLUSTER","ERROR: Invalid Cluster\r\n");
|
||||
LoadList("ST_LTF_CMDS","TX\0CR\0SR\0CU\0TB\0CL\0PB\0DA\0PL\0LM\0RM\0HD\0"
|
||||
"FO\0ID\0FG\0BG\0FD\0BD\0FL\0BL\0"
|
||||
"FM\0BM\0FA\0BA\0FH\0BH\0FE\0BE\0FU\0BU\0WW\0UL\0IV\0BK\0SX\0SY\0CM\0AN\0LK\0BT\0"
|
||||
"CB\0MA\0MU\0HX\0HS\0HE\0TR\0PI\0IB\0IT\0IS\0BP\0SO\0ER\0");
|
||||
LoadList("ST_LTF_FLAGS","A\0"
|
||||
"LC\0LE\0LM\0LA\0RC\0RE\0RM\0RA\0"
|
||||
"DC\0BI\0X\0Q\0LX\0CX\0RX\0TY\0CY\0BY\0SX\0SY\0SCX\0SCY\0"
|
||||
" \0 \0 \0 \0 \0 \0 \0 \0 \0"
|
||||
"B\0S\0BD\0C\0CK\0RD\0P\0T\0"
|
||||
"Z\0PW\0WW\0UL\0IV\0BK\0SEL\0H\0TR\0SK\0AL\0PU\0PRY\0MRX\0.\0");
|
||||
LoadList("ST_HTT_TYPES","StrConst\0SysSym\0KeyWord\0LocVar\0GlbVar\0Class\0"
|
||||
"IntType\0Funct\0Word\0OpCode\0R8\0R16\0R32\0"
|
||||
"SegReg\0SysText\0File\0Module\0.\0.\0.\0.\0.\0.\0.\0.\0Private\0"
|
||||
"Public\0Export\0Import\0Lit\0UnrLoc\0UnrGlb\0");
|
||||
LoadStr("ST_UNHANDLED_EXCEPTION","ERROR: Unhandled Exception\r\n");
|
||||
LoadList("ST_DAYS_OF_WEEK","Sunday\0Monday\0Tuesday\0Wednesday\0"
|
||||
"Thursday\0Friday\0Saturday\0");
|
||||
LoadList("ST_MONTHS","January\0February\0March\0April\0May\0"
|
||||
"June\0July\0August\0September\0October\0November\0December\0");
|
||||
LoadList("ST_EXCEPT_TYPES","Local\0Compiler\0Arithmetic\0Undefined Systext\0"
|
||||
"Undefined Extern\0File\0Break\0Arc Xsum\0"
|
||||
"FDC error\0Partition error\0Blk Dev error\0"
|
||||
"Floating\0Graphics\0");
|
||||
LoadList("ST_FILE_ATTRS","R\0H\0S\0V\0D\0A\0.\0.\0X\0Y\0T\0Z\0"
|
||||
"C\0F\0");
|
||||
LoadList("ST_FILE_UTIL_FLAGS","r\0d\0i\0l\0?\0a\0c\0R\0p\0m\0D\0");
|
||||
LoadList("ST_BLKDEV_TYPES","NULL \0RAM \0FDC \0ATA \0ATAPI\0FILE_\0");
|
||||
LoadList("ST_GRELEM_TYPES","End\0.\0Color (4-bit)\0.\0Point\0"
|
||||
"Line\0PolyLine\0PolyPoint\0Width\0Shift\0"
|
||||
"BSpline2\0BSpline3\0BSpline2 Closed\0BSpline3 Closed\0");
|
||||
LoadList("ST_LINK_TYPES","FI\0FA\0FF\0FL\0MN\0PI\0PF\0PL\0");
|
||||
LoadStr("ST_ERR_START","$$FG RED$$$$BK 1$$");
|
||||
LoadStr("ST_ERR_END","$$FG$$$$BK 0$$");
|
||||
|
||||
LoadStr("ST_ADDDRIVES0",
|
||||
"\r\n\r\n\r\n$$BK,1$$$$FG,PURPLE$$Add drives to this installation so they will "
|
||||
"be present when you boot.$$FG$$$$BK,0$$\r\n");
|
||||
LoadStr("ST_ADDDRIVES1",
|
||||
"\r\n****** Add Drives ******\r\n"
|
||||
"The base drive letter is the letter\r\n"
|
||||
"of the first partition. If adding\r\n"
|
||||
"a hard drive, you should pick 'C'.\r\n"
|
||||
"If more than one partition is present\r\n"
|
||||
"they will be lettered in sequence.\r\n"
|
||||
"\r\n"
|
||||
"Base Drive Letter(ENTER to exit):");
|
||||
LoadStr("ST_ADDDRIVES2",
|
||||
"\t1=RAM\r\n\t2=FDC(Floppy)\r\n\t3=ATA(Harddisk)\r\n"
|
||||
"\t4=ATAPI(CD-ROM)\r\n\t5=FILE\r\n"
|
||||
"Type:");
|
||||
LoadStr("ST_ADDDRIVES3",
|
||||
"Filename:");
|
||||
LoadStr("ST_ADDDRIVES4",
|
||||
"Reformat (with each boot) ");
|
||||
LoadStr("ST_ADDDRIVES5",
|
||||
"Blks(2880 for floppy):");
|
||||
LoadStr("ST_ADDDRIVES6",
|
||||
"\t2=3F0(Floppy)\r\n\t3=1F0(Primary IDE)\r\n"
|
||||
"\t4=170(Secondary IDE)\r\n"
|
||||
"\t5=Use values prompted for CD-ROM during boot\r\n"
|
||||
"Port:");
|
||||
LoadStr("ST_ADDDRIVES7",
|
||||
"\t0=Master\r\n\t1=Slave\r\nUnit:");
|
||||
LoadStr("ST_ADDDRIVES9",
|
||||
"Only works for ATAPI type\r\n");
|
||||
LoadStr("ST_ADDDRIVES10",
|
||||
"\t2=3F0(Floppy)\r\n\t3=1F0(Primary IDE)\r\n"
|
||||
"\t4=170(Secondary IDE)\r\n"
|
||||
"Port:");
|
||||
LoadStr("ST_FAILED","\r\n\r\n$$BK,1$$$$FG,RED$$Operation Failed$$BK,0$$$$FG$$\r\n\r\n");
|
||||
|
||||
$AN,"Anchor for inserting OS systext","OS_SYSTEXT"$
|
||||
|
||||
}
|
||||
File diff suppressed because it is too large.
Load diff
Reference in new issue
Block a user