Rijn/TempleOS-Rijn
1
1 Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

TempleOSCDV4.02.ISO

Browse Source
This commit is contained in:
Terry A. Davis authored and minexew committed 2018-09-08 21:46:54 +02:00
1 parent fedf66361e
commit 1541d7328d
171 files changed
+5326 -5237
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

Kernel/BlkDev/DskATAId.CPP
+1 -6
View File
@@ -207,12 +207,7 @@ CATARep *ATAIDDrvs(CATARep *root,I64 _sys_boot_drv,
CATARep *result=NULL,*tempha=root,*ata_drv=NULL,*atapi_drv=NULL;
CBlkDev *bd;
Bool was_silent=Silent;
try
bd=Let2BlkDev(_sys_boot_drv);
catch {
Fs->catch_except=TRUE;
bd=NULL;
}
bd=Let2BlkDev(_sys_boot_drv,FALSE);
Silent(was_silent);
while (tempha) {
if (!result && bd && bd->type==tempha->type) {
Kernel/BlkDev/DskAddDev.CPP
+12 -15
View File
@@ -37,7 +37,7 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
switch (bd->type) {
case BDT_RAM:
dv->dv_signature=DRV_SIGNATURE_VAL;
dv->type=DVT_REDSEA;
dv->fs_type=FSt_REDSEA;
//This is to force creation of a RAM
//drive during boot, so it is probably
//MAlloced to the same addr and can
@@ -59,7 +59,7 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
if (one_drv) {
dv->dv_signature=DRV_SIGNATURE_VAL;
result++;
dv->type=DVT_REDSEA;
dv->fs_type=FSt_REDSEA;
dv->size=bd->max_blk+1;
//The following read is a test read.
//if it hangs, the drive is not supported.
@@ -86,7 +86,7 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
case MBR_PT_REDSEA:
dv->dv_signature=DRV_SIGNATURE_VAL;
result++;
dv->type=DVT_REDSEA;
dv->fs_type=FSt_REDSEA;
RedSeaDrvInit(dv);
break;
case MBR_PT_FAT32a:
@@ -99,17 +99,17 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
dv->dv_signature=DRV_SIGNATURE_VAL;
result++;
if (br.signature==MBR_PT_REDSEA) {
dv->type=DVT_REDSEA;
dv->fs_type=FSt_REDSEA;
RedSeaDrvInit(dv);
} else {
dv->type=DVT_FAT32;
dv->fs_type=FSt_FAT32;
FAT32DrvInit(dv);
}
break;
case MBR_PT_NTFS:
dv->dv_signature=DRV_SIGNATURE_VAL;
result++;
dv->type=DVT_NTFS;
dv->fs_type=FSt_NTFS;
break;
case 5:
case 15:
@@ -118,7 +118,7 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
default:
dv->dv_signature=DRV_SIGNATURE_VAL;
result++;
dv->type=DVT_UNKNOWN;
dv->fs_type=FSt_UNKNOWN;
}
}
}
@@ -137,7 +137,7 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
case BDT_ATAPI:
dv->dv_signature=DRV_SIGNATURE_VAL;
result++;
dv->type=DVT_ISO9660; //Start with this
dv->fs_type=FSt_ISO9660; //Start with this
dv->size =0;
break;
}
@@ -151,13 +151,10 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
Bool DrvEnable(U8 drv_let,Bool val)
{//Can unmount or remount, but not mount the first time.
CDrv *dv;
Bool result=FALSE;
try {
dv=Let2Drv(drv_let);
result=!LBEqu(&dv->type,DVTf_DISABLE,!val);
} catch
Fs->catch_except=TRUE;
return result;
if (dv=Let2Drv(drv_let,FALSE))
return !LBEqu(&dv->fs_type,FStf_DISABLE,!val);
else
return FALSE;
}
I64 SysGetI64()
Kernel/BlkDev/DskBlkDev.CPP
+15 -9
View File
@@ -40,7 +40,7 @@ Bool BlkDevInit(CBlkDev *bd)
bd->RAM_dsk=AMAlloc((bd->max_blk+1)<<BLK_SIZE_BITS);
bd->max_blk=MSize(bd->RAM_dsk)>>BLK_SIZE_BITS-1;
}
dv->type=DVT_REDSEA;
dv->fs_type=FSt_REDSEA;
dv->size=bd->max_blk+1;
if (RedSeaDrvValidate(bd->first_drv_let))
RedSeaDrvInit(dv);
@@ -116,17 +116,23 @@ CBlkDev *BlkDevNextFree(U8 first_drv_let,I64 type)
return NULL; //never gets here
}
U0 BlkDevChk(CBlkDev *bd)
CBlkDev *BlkDevChk(CBlkDev *bd,Bool except=TRUE)
{//Check for valid BlkDev. Throw exception.
if (!bd || bd->bd_signature!=BD_SIGNATURE_VAL ||
!(BDT_NULL<bd->type<BDT_NUM_TYPES))
throw('BlkDev');
!(BDT_NULL<bd->type<BDT_NUM_TYPES)) {
if (except)
throw('BlkDev');
else
return NULL;
} else
return bd;
}
CBlkDev *Let2BlkDev(U8 drv_let=0)
CBlkDev *Let2BlkDev(U8 drv_let=0,Bool except=TRUE)
{//Drv letter to BlkDev ptr.
CDrv *dv=Let2Drv(drv_let);
CBlkDev *bd=dv->bd;
BlkDevChk(bd);
return bd;
CDrv *dv;
if (dv=Let2Drv(drv_let,except))
return BlkDevChk(dv->bd,except);
else
return NULL;
}
Kernel/BlkDev/DskCFile.CPP
+3 -2
View File
@@ -23,11 +23,12 @@ CFile *FOpen(U8 *filename,U8 *flags,I64 cnt=0)
f->file_cluster_num=INVALID_CLUSTER;
full_name=FileNameAbs(filename);
f->dv=Let2Drv(*full_name);
if (f->dv->type==DVT_REDSEA)
if (f->dv->fs_type==FSt_REDSEA)
contiguous=TRUE;
if (contiguous) {
f->flags|=FF_CONTIGUOUS;
if (f->dv->type!=DVT_REDSEA && !(FileAttr(filename) & RS_ATTR_CONTIGUOUS))
if (f->dv->fs_type!=FSt_REDSEA &&
!(FileAttr(filename) & RS_ATTR_CONTIGUOUS))
throw('File');
}
f->cluster_buf=CAlloc(f->dv->spc<<BLK_SIZE_BITS);
Kernel/BlkDev/DskCluster.CPP
+18 -18
View File
@@ -5,12 +5,12 @@ I64 ClusterNumNext(CDrv *dv,I64 c,I64 cnt=1)
if (cnt<=0) return c;
try {
unlock=DrvLock(dv);
switch (dv->type) {
case DVT_ISO9660:
case DVT_REDSEA:
switch (dv->fs_type) {
case FSt_ISO9660:
case FSt_REDSEA:
c+=cnt;
break;
case DVT_FAT32:
case FSt_FAT32:
while (cnt-->0 && 0<c<0x0FFFFFF8) {
DrvFATBlkSet(dv,c);
c=dv->cur_fat_blk[c & (BLK_SIZE/4-1)];
@@ -32,11 +32,11 @@ I64 ClusterNumNext(CDrv *dv,I64 c,I64 cnt=1)
I64 Cluster2Blk(CDrv *dv,I64 c)
{//Drv cluster num to blk num.
DrvChk(dv);
switch (dv->type) {
case DVT_REDSEA:
switch (dv->fs_type) {
case FSt_REDSEA:
return c;
case DVT_ISO9660:
case DVT_FAT32:
case FSt_ISO9660:
case FSt_FAT32:
return dv->data_area+c*dv->spc;
default:
throw('Drv');
@@ -51,16 +51,16 @@ I64 RClustersBlks(CDrv *dv,U8 *buf,I64 c,I64 blks)
if (blks<=0) return c;
try {
unlock=DrvLock(dv);
switch (dv->type) {
case DVT_ISO9660:
switch (dv->fs_type) {
case FSt_ISO9660:
RBlks(dv,buf,dv->data_area+c*dv->spc,blks);
c+=(blks+dv->spc-1)/dv->spc;
break;
case DVT_REDSEA:
case FSt_REDSEA:
RBlks(dv,buf,c,blks);
c+=blks;
break;
case DVT_FAT32:
case FSt_FAT32:
while (blks && 0<c<0x0FFFFFF8) {
i=blks;
if (i>dv->spc)
@@ -97,12 +97,12 @@ I64 WClustersBlks(CDrv *dv,U8 *buf,I64 c,I64 blks)
if (blks<=0) return c;
try {
unlock=DrvLock(dv);
switch (dv->type) {
case DVT_REDSEA:
switch (dv->fs_type) {
case FSt_REDSEA:
WBlks(dv,buf,c,blks);
c=0;
break;
case DVT_FAT32:
case FSt_FAT32:
while (blks) {
if (!(0<c<0x0FFFFFF8))
throw('Drv');
@@ -136,10 +136,10 @@ I64 ClustersAlloc(CDrv *dv,I64 c=0,I64 cnt=1,Bool contiguous=FALSE)
//c=0 means first cluster in chain
DrvChk(dv);
if (cnt<=0) return c;
switch (dv->type) {
case DVT_REDSEA:
switch (dv->fs_type) {
case FSt_REDSEA:
return RedSeaAllocClusters(dv,cnt);
case DVT_FAT32:
case FSt_FAT32:
if (contiguous) {
if (c) throw('File');
return FAT32AllocContiguousClusters(dv,cnt);
Kernel/BlkDev/DskCopy.CPP
+4 -4
View File
@@ -85,16 +85,16 @@ I64 Del(U8 *files_find_mask,Bool make_mask=FALSE,
I64 result=0;
CDirContext *dirc;
if (dirc=DirContextNew(files_find_mask,make_mask)) {
switch (dirc->dv->type) {
case DVT_REDSEA:
switch (dirc->dv->fs_type) {
case FSt_REDSEA:
result=RedSeaFilesDel(dirc->dv,Fs->cur_dir,dirc->mask,
0,del_dir,print_msg);
break;
case DVT_FAT32:
case FSt_FAT32:
result=FAT32FilesDel(dirc->dv,Fs->cur_dir,dirc->mask,
0,del_dir,print_msg);
break;
case DVT_ISO9660:
case FSt_ISO9660:
PrintErr("Not Writable\n");
break;
default:
Kernel/BlkDev/DskDirA.CPP
+4 -4
View File
@@ -1,11 +1,11 @@
Bool DirNew(CDrv *dv,U8 *cur_dir,CDirEntry *tempde,Bool free_old_chain=TRUE)
{//Makes a directory entry in the directory from a $LK,"CDirEntry",A="MN:CDirEntry"$ node.
switch (dv->type) {
case DVT_REDSEA:
switch (dv->fs_type) {
case FSt_REDSEA:
return RedSeaDirNew(dv,cur_dir,tempde,free_old_chain);
case DVT_FAT32:
case FSt_FAT32:
return FAT32DirNew(dv,cur_dir,tempde,free_old_chain);
case DVT_ISO9660:
case FSt_ISO9660:
PrintErr("Not Writable\n");
return FALSE;
default:
Kernel/BlkDev/DskDirB.CPP
+8 -8
View File
@@ -39,14 +39,14 @@ Bool Cd(U8 *dirname=NULL,Bool make_dirs=FALSE)
} else if (StrCmp(buf,".") && *buf) {
dv=Fs->cur_dv;
cur_dir_cluster=Name2DirCluster(dv,new_cur_dir);
switch (dv->type) {
case DVT_REDSEA:
switch (dv->fs_type) {
case FSt_REDSEA:
result=RedSeaCd(buf,cur_dir_cluster);
break;
case DVT_FAT32:
case FSt_FAT32:
result=FAT32Cd(buf,cur_dir_cluster);
break;
case DVT_ISO9660:
case FSt_ISO9660:
result=ISO1Cd(buf,cur_dir_cluster);
break;
default:
@@ -158,14 +158,14 @@ Bool MkDir(U8 *filename)
"Make Directory:%s\n",filename;
name=MStrUtil(dirc->mask,
SUF_REM_LEADING|SUF_REM_TRAILING|SUF_REM_CTRL_CHARS);
switch (dirc->dv->type) {
case DVT_REDSEA:
switch (dirc->dv->fs_type) {
case FSt_REDSEA:
result=RedSeaMkDir(dirc->dv,Fs->cur_dir,name);
break;
case DVT_FAT32:
case FSt_FAT32:
result=FAT32MkDir(dirc->dv,Fs->cur_dir,name);
break;
case DVT_ISO9660:
case FSt_ISO9660:
PrintErr("Not Writable\n");
break;
default:
Kernel/BlkDev/DskDirContext.CPP
+16 -6
View File
@@ -22,12 +22,13 @@ CDirContext *DirContextNew(U8 *_mask,Bool make_mask=FALSE,
Bool make_dirs=FALSE,Bool no_mask=FALSE)
{//Save cur_dir and drv. Change to new dir.
Bool valid=TRUE,old_silent;
U8 *buf,*mask,*temp_mask;
I64 mask_len=StrLen(_mask);
U8 *buf,*mask,*temp_mask,*semicolon_mask;
CDirContext *dirc=CAlloc(sizeof(CDirContext));
mask=MStrUtil(_mask,SUF_REM_LEADING|SUF_REM_TRAILING|SUF_REM_CTRL_CHARS);
temp_mask=mask;
dirc->old_dir=StrNew(Fs->cur_dir);
dirc->old_dv=Fs->cur_dv;
mask=MStrUtil(_mask,SUF_REM_LEADING|SUF_REM_TRAILING|SUF_REM_CTRL_CHARS);
temp_mask=mask;
if (*mask && mask[1]==':') {
if (Fs->cur_dv!=Let2Drv(*mask) && !Drv(*mask))
valid=FALSE;
@@ -35,13 +36,22 @@ CDirContext *DirContextNew(U8 *_mask,Bool make_mask=FALSE,
}
dirc->dv=Fs->cur_dv;
DrvChk(dirc->dv);
buf=MAlloc(StrLen(mask)+2);
buf=MAlloc(mask_len+2);
StrCpy(buf,mask);
dirc->mask=MAlloc(StrLen(mask)+2);
dirc->mask=MAlloc(mask_len+2);
if (no_mask)
*dirc->mask=0;
else
else if (StrOcc(buf,';')) {
semicolon_mask=MAlloc(mask_len+2);
StrCpy(semicolon_mask,mask);
StrFirstRem(semicolon_mask,";",buf);
StrLastRem(buf,"/",dirc->mask);
CatPrint(dirc->mask,";%s",semicolon_mask);
Free(semicolon_mask);
} else
StrLastRem(buf,"/",dirc->mask);
if (*mask=='/' && !*buf)
StrCpy(buf,"/");
//If began with Dir, change to Dir.
Kernel/BlkDev/DskDrv.CPP
+77 -35
View File
@@ -74,7 +74,8 @@ U0 DrvFATBlkAlloc(CDrv *dv)
U0 DrvFATBlkClean(CDrv *dv,I64 fat_select=3)
{
if ((dv->type==DVT_FAT32 || dv->type==DVT_REDSEA)&&Bt(&dv->fat_blk_dirty,0)) {
if ((dv->fs_type==FSt_FAT32 || dv->fs_type==FSt_REDSEA) &&
Bt(&dv->fat_blk_dirty,0)) {
if (dv->fat1==dv->fat2) {
WBlks(dv,dv->cur_fat_blk,dv->fat1+dv->cur_fat_blk_num,1);
LBtr(&dv->fat_blk_dirty,0);
@@ -94,11 +95,11 @@ U0 DrvFATBlkSet(CDrv *dv,I64 c,I64 fat_select=3)
I64 fat_blk_num;
if (c==INVALID_CLUSTER)
throw('Drv');
switch (dv->type) {
case DVT_FAT32:
switch (dv->fs_type) {
case FSt_FAT32:
fat_blk_num=c>>(BLK_SIZE_BITS-2);
break;
case DVT_REDSEA:
case FSt_REDSEA:
fat_blk_num=(c-dv->data_area)>>(BLK_SIZE_BITS+3);
break;
default:
@@ -114,10 +115,15 @@ U0 DrvFATBlkSet(CDrv *dv,I64 c,I64 fat_select=3)
}
}
U0 DrvChk(CDrv *dv)
CDrv *DrvChk(CDrv *dv,Bool except=TRUE)
{//Check for valid drv. Throw exception.
if (!dv || dv->dv_signature!=DRV_SIGNATURE_VAL)
throw('Drv');
if (!dv || dv->dv_signature!=DRV_SIGNATURE_VAL) {
if (except)
throw('Drv');
else
return NULL;
} else
return dv;
}
U8 Drv2Let(CDrv *dv=NULL)
@@ -128,7 +134,19 @@ U8 Drv2Let(CDrv *dv=NULL)
return dv->drv_let;
}
CDrv *Let2Drv(U8 drv_let=0)
I64 Let2BlkDevType(U8 drv_let)
{//Drv letter to BlkDev Type. drv_let=0 not allowed. See $LK,"BDT_NULL",A="MN:BDT_NULL"$.
drv_let=ToUpper(drv_let);
if ('A'<=drv_let<='B')
return BDT_RAM;
if ('C'<=drv_let<='S')
return BDT_ATA;
if ('T'<=drv_let<='Z')
return BDT_ATAPI;
return BDT_NULL;
}
CDrv *Let2Drv(U8 drv_let=0,Bool except=TRUE)
{//Drv letter to Drv ptr.
CDrv *dv;
if (!drv_let)
@@ -137,21 +155,27 @@ CDrv *Let2Drv(U8 drv_let=0)
if (drv_let==':')
drv_let=blkdev.boot_drv_let;
drv_let=ToUpper(drv_let);
if (!('A'<=drv_let<='Z'))
throw('Drv');
if (!('A'<=drv_let<='Z')) {
if (except)
throw('Drv');
else
return NULL;
}
dv=blkdev.let_to_drv[drv_let-'A'];
}
DrvChk(dv);
return dv;
return DrvChk(dv,except);
}
Bool DrvIsWritable(U8 drv_let=0)
CBlkDev *DrvIsWritable(U8 drv_let=0,Bool except=FALSE)
{//Is drive writable?
CBlkDev *bd=Let2BlkDev(drv_let);
if (bd->flags & BDF_READ_ONLY)
return FALSE;
else
return TRUE;
CBlkDev *bd;
if (!(bd=Let2BlkDev(drv_let,except)) || bd->flags & BDF_READ_ONLY) {
if (except)
throw('Drv');
else
return NULL;
} else
return bd;
}
U0 DskCacheInvalidate(CDrv *dv)
@@ -164,7 +188,7 @@ U0 DskCacheInvalidate(CDrv *dv)
BlkDevInit(bd);
if (bd->flags & BDF_READ_CACHE)
DskCacheInvalidate2(dv);
if (dv->type==DVT_ISO9660 && !(bd->flags & BDF_READ_ONLY_OVERRIDE))
if (dv->fs_type==FSt_ISO9660 && !(bd->flags & BDF_READ_ONLY_OVERRIDE))
ISODrvInit(dv,(32767/bd->blk_size+1)*bd->blk_size>>BLK_SIZE_BITS);
if (unlock)
DrvUnlock(dv);
@@ -199,8 +223,8 @@ Bool MapDrv(U8 drv_let,CDrv *dv)
Bool Drv(U8 drv_let)
{//Set drive. You can set drive with $LK,"Cd",A="MN:Cd"$() as well.
CDrv *dv=Let2Drv(drv_let);
CBlkDev *bd=dv->bd;
BlkDevChk(bd);
CBlkDev *bd;
bd=BlkDevChk(dv->bd);
if (dv!=Fs->cur_dv) {
if (bd->flags & BDF_REMOVABLE && !(bd->flags & BDF_INITIALIZED))
ChgDsk(Drv2Let(dv));
@@ -210,10 +234,10 @@ Bool Drv(U8 drv_let)
Fs->cur_dv=dv;
Free(Fs->cur_dir);
Fs->cur_dir=StrNew("/");
switch (dv->type) {
case DVT_REDSEA:
case DVT_FAT32:
case DVT_ISO9660:
switch (dv->fs_type) {
case FSt_REDSEA:
case FSt_FAT32:
case FSt_ISO9660:
return TRUE;
default:
PrintErr("File System Not Supported\n");
@@ -251,35 +275,53 @@ U8 *DrvModelNum(U8 drv_let=0)
return result;
}
U8 blkdev_text_attr[BDT_NUM_TYPES]={BLACK,LTCYAN,WHITE,LTBLUE};
U8 drv_text_attr[3]={BLACK,BLUE,RED};
U8 DrvTextAttrGet(U8 drv_let=0)
{//Get color of drive.
if (!drv_let)
drv_let=Drv2Let(Fs->cur_dv);
else if (drv_let==':')
drv_let=blkdev.boot_drv_let;
drv_let=ToUpper(drv_let);
if ('A'<=drv_let<='Z')
return blkdev_text_attr[Let2BlkDevType(drv_let)]<<4|
drv_text_attr[drv_let%sizeof(drv_text_attr)];
else
return BLACK<<4|WHITE;
}
U0 DrvRep()
{//Drive report.
CDrv *dv;
CBlkDev *bd;
I64 i,drv_let;
I64 ch,i,drv_let,attr;
U8 *st;
"\nDefined Drives:\n\n";
for (i=0,dv=blkdev.drvs;i<NUM_DRVS;i++,dv++) {
if (dv->dv_signature==DRV_SIGNATURE_VAL) {
bd=dv->bd;
drv_let=Drv2Let(dv);
if (Bt(&dv->type,DVTf_DISABLE))
"$$RED$$X";
if (Bt(&dv->fs_type,FStf_DISABLE))
ch='-';
else if (drv_let==blkdev.boot_drv_let)
"$$GREEN$$:";
ch=':';
else
'' CH_SPACE;
"$$PURPLE$$%C %-8Z %-9Z %04X %04X %02X$$FG$$\n",
drv_let,dv->type.u16[0],"ST_DRV_TYPES",
ch='+';
attr=DrvTextAttrGet(drv_let);
"$$FG,%d$$$$BG,%d$$%C %-8Z %-9Z %04X %04X %02X\n",
attr&15,attr>>4,drv_let,dv->fs_type&FSG_TYPE_MASK,"ST_DRV_TYPES",
bd->type,"ST_BLKDEV_TYPES",bd->base0,bd->base1,bd->unit;
if (st=DrvModelNum(drv_let)) {
" $$CYAN$$Model# :%s$$FG$$\n",st;
" Model# :%s\n",st;
Free(st);
}
if (st=DrvSerialNum(drv_let)) {
" $$CYAN$$Serial#:%s$$FG$$\n",st;
" Serial#:%s\n",st;
Free(st);
}
" %016X-%016X\n",
" %016X-%016X\n$$FG$$$$BG$$",
dv->base_offset,dv->base_offset+dv->size-1;
dv->base_offset,dv->base_offset+dv->size-1;
}
Kernel/BlkDev/DskFile.CPP
+12 -12
View File
@@ -21,16 +21,16 @@ U8 *FileRead(U8 *filename,I64 *_size=NULL,I64 *_attr=NULL)
else
curname=altname;
if (dirc=DirContextNew(curname)) {
switch (dirc->dv->type) {
case DVT_REDSEA:
switch (dirc->dv->fs_type) {
case FSt_REDSEA:
result=RedSeaFileRead(dirc->dv,Fs->cur_dir,dirc->mask,
&size,&attr);
break;
case DVT_FAT32:
case FSt_FAT32:
result=FAT32FileRead(dirc->dv,Fs->cur_dir,dirc->mask,
&size,&attr);
break;
case DVT_ISO9660:
case FSt_ISO9660:
result=ISO1FileRead(dirc->dv,Fs->cur_dir,dirc->mask,
&size,&attr);
break;
@@ -50,16 +50,16 @@ U8 *FileRead(U8 *filename,I64 *_size=NULL,I64 *_attr=NULL)
if (dirc=DirContextNew(curname)) {
while (!result && StrCmp(Fs->cur_dir,"/")) {
Cd("..");
switch (Fs->cur_dv->type) {
case DVT_REDSEA:
switch (Fs->cur_dv->fs_type) {
case FSt_REDSEA:
result=RedSeaFileRead(dirc->dv,Fs->cur_dir,dirc->mask,
&size,&attr);
break;
case DVT_FAT32:
case FSt_FAT32:
result=FAT32FileRead(dirc->dv,Fs->cur_dir,dirc->mask,
&size,&attr);
break;
case DVT_ISO9660:
case FSt_ISO9660:
result=ISO1FileRead(dirc->dv,Fs->cur_dir,dirc->mask,
&size,&attr);
break;
@@ -106,16 +106,16 @@ I64 FileWrite(U8 *filename,U8 *fbuf,I64 size,CDate cdt=0,I64 attr=0)
} else
fbuf2=NULL;
if (!cdt) cdt=Now;
switch (dirc->dv->type) {
case DVT_REDSEA:
switch (dirc->dv->fs_type) {
case FSt_REDSEA:
c=RedSeaFileWrite(dirc->dv,Fs->cur_dir,dirc->mask,fbuf,
size,cdt,attr);
break;
case DVT_FAT32:
case FSt_FAT32:
c=FAT32FileWrite(dirc->dv,Fs->cur_dir,dirc->mask,fbuf,
size,cdt,attr);
break;
case DVT_ISO9660:
case FSt_ISO9660:
PrintErr("Not Writable\n");
break;
default:
Kernel/BlkDev/DskFind.CPP
+14 -13
View File
@@ -3,14 +3,14 @@ CDirEntry *FilesFind2(U8 *files_find_mask,I64 fuf_flags)
CDrv *dv=Fs->cur_dv;
CDirEntry *result=NULL;
DrvChk(dv);
switch (dv->type) {
case DVT_REDSEA:
switch (dv->fs_type) {
case FSt_REDSEA:
result=RedSeaFilesFind(files_find_mask,fuf_flags);
break;
case DVT_FAT32:
case FSt_FAT32:
result=FAT32FilesFind(files_find_mask,fuf_flags);
break;
case DVT_ISO9660:
case FSt_ISO9660:
result=ISO1FilesFind(files_find_mask,fuf_flags);
break;
default:
@@ -64,7 +64,8 @@ Bool FileFind(U8 *filename,CDirEntry *_de=NULL,I64 fuf_flags=0)
Bool result=FALSE,old_silent;
if (fuf_flags&~FUG_FILE_FIND)
throw('FUF');
if (!filename) return FALSE;
if (!filename || *filename && filename[1]==':' && !Let2Drv(*filename,FALSE))
return FALSE;
altname=ToggleZorNotZ(filename);
if (fuf_flags&FUF_Z_OR_NOT_Z)
j=2;
@@ -81,16 +82,16 @@ Bool FileFind(U8 *filename,CDirEntry *_de=NULL,I64 fuf_flags=0)
else {
Silent(old_silent);
cur_dir_cluster=Name2DirCluster(dirc->dv,Fs->cur_dir);
switch (dirc->dv->type) {
case DVT_REDSEA:
switch (dirc->dv->fs_type) {
case FSt_REDSEA:
result=RedSeaFileFind(dirc->dv,cur_dir_cluster,dirc->mask,
&de,fuf_flags);
break;
case DVT_FAT32:
case FSt_FAT32:
result=FAT32FileFind(dirc->dv,cur_dir_cluster,dirc->mask,
&de,fuf_flags);
break;
case DVT_ISO9660:
case FSt_ISO9660:
result=ISO1FileFind(dirc->dv,cur_dir_cluster,dirc->mask,
&de,fuf_flags);
break;
@@ -121,16 +122,16 @@ Bool FileFind(U8 *filename,CDirEntry *_de=NULL,I64 fuf_flags=0)
while (!result && StrCmp(Fs->cur_dir,"/")) {
Cd("..");
cur_dir_cluster=Name2DirCluster(dirc->dv,Fs->cur_dir);
switch (dirc->dv->type) {
case DVT_REDSEA:
switch (dirc->dv->fs_type) {
case FSt_REDSEA:
result=RedSeaFileFind(dirc->dv,cur_dir_cluster,
dirc->mask,&de,fuf_flags);
break;
case DVT_FAT32:
case FSt_FAT32:
result=FAT32FileFind(dirc->dv,cur_dir_cluster,
dirc->mask,&de,fuf_flags);
break;
case DVT_ISO9660:
case FSt_ISO9660:
result=ISO1FileFind(dirc->dv,cur_dir_cluster,
dirc->mask,&de,fuf_flags);
break;
Kernel/BlkDev/DskFmt.CPP
+8 -8
View File
@@ -1,4 +1,4 @@
Bool DrvTypeSet(U8 drv_let,I64 type=DVT_REDSEA)
Bool DrvTypeSet(U8 drv_let,I64 type=FSt_REDSEA)
{//Very dangerous
I64 i,j,ext_base,drv_num,offset,cur_type;
CMasterBoot mbr;
@@ -19,10 +19,10 @@ Bool DrvTypeSet(U8 drv_let,I64 type=DVT_REDSEA)
else {
if (drv_num+'A'==ToUpper(drv_let)) {
switch (type) {
case DVT_REDSEA:
case FSt_REDSEA:
mbr.p[i].type=MBR_PT_REDSEA;
break;
case DVT_FAT32:
case FSt_FAT32:
mbr.p[i].type=MBR_PT_FAT32a;
break;
default:
@@ -50,11 +50,11 @@ Bool DrvTypeSet(U8 drv_let,I64 type=DVT_REDSEA)
}
}
U0 Fmt(I64 drv_let,Bool quick=TRUE,Bool confirm=TRUE,I64 type=DVT_FAT32)
U0 Fmt(I64 drv_let,Bool quick=TRUE,Bool confirm=TRUE,I64 type=FSt_FAT32)
{//Format hard drive or RAM drive.
//$BK,1$Warning:$BK,0$ Destroys all previous info.
//quick=FALSE means fill entire drive with zeros.
//Choose $LK,"DVT_FAT32",A="MN:DVT_FAT32"$ or $LK,"DVT_REDSEA",A="MN:DVT_REDSEA"$.
//Choose $LK,"FSt_FAT32",A="MN:FSt_FAT32"$ or $LK,"FSt_REDSEA",A="MN:FSt_REDSEA"$.
//You don't format a CD/DVD with this.
CDrv *dv=Let2Drv(drv_let);
Bool old_silent=IsSilent;
@@ -65,7 +65,7 @@ U0 Fmt(I64 drv_let,Bool quick=TRUE,Bool confirm=TRUE,I64 type=DVT_FAT32)
return;
}
switch (type) {
case DVT_REDSEA:
case FSt_REDSEA:
Silent;
Drv(drv_let);
Silent(old_silent);
@@ -73,7 +73,7 @@ U0 Fmt(I64 drv_let,Bool quick=TRUE,Bool confirm=TRUE,I64 type=DVT_FAT32)
DskCacheInvalidate(Let2Drv(drv_let));
Drv(drv_let);
break;
case DVT_FAT32:
case FSt_FAT32:
Silent;
Drv(drv_let);
Silent(old_silent);
@@ -81,7 +81,7 @@ U0 Fmt(I64 drv_let,Bool quick=TRUE,Bool confirm=TRUE,I64 type=DVT_FAT32)
DskCacheInvalidate(Let2Drv(drv_let));
Drv(drv_let);
break;
case DVT_ISO9660:
case FSt_ISO9660:
PrintErr("Not Writable\n");
break;
default:
Kernel/BlkDev/DskStrA.CPP
+32 -15
View File
@@ -37,39 +37,54 @@ Bool IsDotC(U8 *filename)
return FALSE;
}
Bool FilesFindMatch(U8 *test_filename,U8 *files_find_mask,I64 fuf_flags=0)
Bool FilesFindMatch(U8 *_test_name,U8 *files_find_mask,I64 fuf_flags=0)
{//Does filename meet $LK,"Files Find",A="FI:::/Doc/FileUtils.TXT"$ mask?
U8 *st1=StrNew(files_find_mask),
*st2=MAlloc(StrLen(files_find_mask)+1);
I64 tn_len=StrLen(_test_name),mask_len=StrLen(files_find_mask);
U8 *mask1=MAlloc(mask_len+1),*mask2=MAlloc(mask_len+1),
*ptr,*test_name1,*test_name2;
Bool result=FALSE;
StrCpy(mask1,files_find_mask);
if (StrOcc(_test_name,'/')) {
test_name1=MAlloc(tn_len+1);
test_name2=MAlloc(tn_len+1);
StrCpy(test_name1,_test_name);
StrLastRem(test_name1,"/",test_name2);
} else {
test_name1=NULL;
test_name2=NULL;
}
while (TRUE) {
StrFirstRem(st1,";",st2);
if (*st2) {
if (*st2=='~') {
if (WildMatch(test_filename,st2+1)) {
StrFirstRem(mask1,";",mask2);
if (!test_name2 || StrOcc(mask2,'/'))
ptr=_test_name;
else
ptr=test_name2;
if (*mask2) {
if (*mask2=='~') {
if (WildMatch(ptr,mask2+1)) {
result=FALSE;
break;
}
} else {
if (WildMatch(test_filename,st2)) {
if (WildMatch(ptr,mask2)) {
if (Bt(&fuf_flags,FUf_JUST_TXT) &&
!FilesFindMatch(test_filename,FILEMASK_TXT)) {
!FilesFindMatch(_test_name,FILEMASK_TXT)) {
result=FALSE;
break;
} else if (Bt(&fuf_flags,FUf_JUST_SRC) &&
!FilesFindMatch(test_filename,FILEMASK_SRC)) {
!FilesFindMatch(_test_name,FILEMASK_SRC)) {
result=FALSE;
break;
} else if (Bt(&fuf_flags,FUf_JUST_AOT) &&
!FilesFindMatch(test_filename,FILEMASK_AOT)) {
!FilesFindMatch(_test_name,FILEMASK_AOT)) {
result=FALSE;
break;
} else if (Bt(&fuf_flags,FUf_JUST_JIT) &&
!FilesFindMatch(test_filename,FILEMASK_JIT)) {
!FilesFindMatch(_test_name,FILEMASK_JIT)) {
result=FALSE;
break;
} else if (Bt(&fuf_flags,FUf_JUST_GRA) &&
!FilesFindMatch(test_filename,FILEMASK_GRA)) {
!FilesFindMatch(_test_name,FILEMASK_GRA)) {
result=FALSE;
break;
} else
@@ -79,8 +94,10 @@ Bool FilesFindMatch(U8 *test_filename,U8 *files_find_mask,I64 fuf_flags=0)
} else
break;
}
Free(st1);
Free(st2);
Free(test_name1);
Free(test_name2);
Free(mask1);
Free(mask2);
return result;
}
Kernel/BlkDev/DskStrB.CPP
+8 -8
View File
@@ -20,14 +20,14 @@ I64 Name2DirCluster(CDrv *dv,U8 *dirname)
while (*buf && cont) {
StrFirstRem(buf,"/",buf2);
if (*buf2) {
switch (dv->type) {
case DVT_REDSEA:
switch (dv->fs_type) {
case FSt_REDSEA:
cont=RedSeaFileFind(dv,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
break;
case DVT_FAT32:
case FSt_FAT32:
cont=FAT32FileFind(dv,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
break;
case DVT_ISO9660:
case FSt_ISO9660:
cont=ISO1FileFind(dv,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
break;
default:
@@ -65,14 +65,14 @@ I64 Name2ParentDirCluster(CDrv *dv,U8 *dirname)
cur_dir_cluster2=cur_dir_cluster;
StrFirstRem(buf,"/",buf2);
if (*buf2) {
switch (dv->type) {
case DVT_REDSEA:
switch (dv->fs_type) {
case FSt_REDSEA:
cont=RedSeaFileFind(dv,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
break;
case DVT_FAT32:
case FSt_FAT32:
cont=FAT32FileFind(dv,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
break;
case DVT_ISO9660:
case FSt_ISO9660:
cont=ISO1FileFind(dv,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
break;
default:
Kernel/BlkDev/FileSysFAT.CPP
+25 -27
View File
@@ -25,7 +25,7 @@ U0 FAT32DrvInit(CDrv *dv)
Bool unlock;
try {
unlock=DrvLock(dv);
dv->type=DVT_FAT32;
dv->fs_type=FSt_FAT32;
RBlks(dv,&br32,dv->base_offset,1);
dv->file_system_info_sect=dv->base_offset+br32.file_system_info_sect;
dv->fat1=dv->base_offset+br32.reserved_sects;
@@ -49,17 +49,12 @@ Bool FAT32DrvValidate(U8 drv_let)
{
CDrv *dv;
CFAT32Boot br;
Bool result=FALSE;
try {
dv=Let2Drv(drv_let);
if (dv->type==DVT_FAT32 &&
RBlks(dv,&br,dv->base_offset,1) &&
br.signature==0xAA55 &&
br.sects==dv->size)
result=TRUE;
} catch
Fs->catch_except=TRUE;
return result;
if ((dv=Let2Drv(drv_let,FALSE)) && dv->fs_type==FSt_FAT32 &&
RBlks(dv,&br,dv->base_offset,1) && br.signature==0xAA55 &&
br.sects==dv->size)
return TRUE;
else
return FALSE;
}
U0 FAT32Fmt(U8 drv_let,Bool quick=TRUE)
@@ -70,8 +65,8 @@ U0 FAT32Fmt(U8 drv_let,Bool quick=TRUE)
I64 i,l;
try {
DrvLock(dv);
DrvTypeSet(drv_let,DVT_FAT32);
dv->type=DVT_FAT32;
DrvTypeSet(drv_let,FSt_FAT32);
dv->fs_type=FSt_FAT32;
br->jump_and_nop[0]=OC_JMP_REL8;
br->jump_and_nop[1]=offset(CFAT32Boot.code)-2;
br->jump_and_nop[2]=OC_NOP;
@@ -313,7 +308,7 @@ Bool FAT32FileFind(CDrv *dv,I64 cur_dir_cluster,
MemSet(_result,0,sizeof(CDirEntry));
MemSet(&long_name,0,sizeof(CDirEntry));
DrvChk(dv);
if (dv->type!=DVT_FAT32)
if (dv->fs_type!=FSt_FAT32)
PrintErr("Not FAT32 Drv\n");
else if (!CFileNameTo(dname,name))
PrintErr("Invalid FileName.\n");
@@ -377,7 +372,7 @@ U8 *FAT32FileRead(CDrv *dv,U8 *cur_dir,U8 *filename,I64 *_size,I64 *_attr)
DrvChk(dv);
*_size=0;
*_attr=0;
if (dv->type!=DVT_FAT32)
if (dv->fs_type!=FSt_FAT32)
PrintErr("Not FAT32 Drv\n");
else
try {
@@ -404,7 +399,7 @@ U8 *FAT32FileRead(CDrv *dv,U8 *cur_dir,U8 *filename,I64 *_size,I64 *_attr)
Bool FAT32Cd(U8 *name,I64 cur_dir_cluster)
{
CDirEntry de;
if (Fs->cur_dv->type!=DVT_FAT32)
if (Fs->cur_dv->fs_type!=FSt_FAT32)
PrintErr("Not FAT32 Drv\n");
else if (FAT32FileFind(Fs->cur_dv,cur_dir_cluster,name,&de,FUF_JUST_DIRS))
return TRUE;
@@ -421,7 +416,7 @@ U0 FAT32FreeClusters(CDrv *dv,I64 c)
Bool unlock,unlock_break;
DrvChk(dv);
if (!(0<c<0x0FFFFFF8)) return;
if (dv->type!=DVT_FAT32)
if (dv->fs_type!=FSt_FAT32)
PrintErr("Not FAT32 Drv\n");
else
try {
@@ -823,7 +818,7 @@ I64 FAT32FileWrite(CDrv *dv,U8 *cur_dir,U8 *name,U8 *buf,I64 size,
Bool contiguous;
MemSet(&de,0,sizeof(CDirEntry));
if (size<0) size=0;
if (dv->type!=DVT_FAT32)
if (dv->fs_type!=FSt_FAT32)
PrintErr("Not FAT32 Drv\n");
else if (!CFileNameTo(de.name,name))
PrintErr("Invalid FileName.\n");
@@ -896,15 +891,18 @@ CDirEntry *FAT32FilesFind(U8 *files_find_mask,
Cd("..");
}
DrvLock(dv);
} else if ((attr&RS_ATTR_DIR || !Bt(&fuf_flags,FUf_JUST_DIRS)) &&
!(Bt(&fuf_flags,FUf_RECURSE) &&
*tempde->name=='.' && attr&RS_ATTR_DIR) &&
FilesFindMatch(tempde->name,files_find_mask,fuf_flags)) {
tempde->next=result;
result=tempde;
} else {
tempde->full_name=FileNameAbs(tempde->name);
} else
DirEntryDel(tempde);
if ((attr&RS_ATTR_DIR || !Bt(&fuf_flags,FUf_JUST_DIRS)) &&
!(Bt(&fuf_flags,FUf_RECURSE) &&
*tempde->name=='.' && attr&RS_ATTR_DIR) &&
FilesFindMatch(tempde->full_name,files_find_mask,
fuf_flags)) {
tempde->next=result;
result=tempde;
} else
DirEntryDel(tempde);
}
} else
DirEntryDel(tempde);
}
Kernel/BlkDev/FileSysISO.CPP
+17 -15
View File
@@ -13,7 +13,7 @@ Bool ISODrvInit(CDrv *dv,I64 blk)
try {
unlock=DrvLock(dv);
dv->type=DVT_ISO9660; //default
dv->fs_type=FSt_ISO9660; //default
dv->spc=spc;
dv->base_offset=dv->data_area=dv->root_cluster=dv->size=0;
while (TRUE) {
@@ -24,7 +24,7 @@ Bool ISODrvInit(CDrv *dv,I64 blk)
switch (LstMatch(buf,"CD001\0CDW02\0BEA01\0BOOT2\0NSR02\0NSR03\0TEA01\0",
LMF_EXACT)) {
case 0:
dv->type=DVT_ISO9660;
dv->fs_type=FSt_ISO9660;
switch (iso->type) {
case ISO1T_SUPPLEMENTARY_DESC:
dv->data_area=0;
@@ -48,7 +48,7 @@ ipi_done:
if (unlock)
DrvUnlock(dv);
} catch {
dv->type=DVT_ISO9660;
dv->fs_type=FSt_ISO9660;
dv->spc=spc;
dv->base_offset=dv->data_area=dv->root_cluster=0;
Free(iso);
@@ -137,7 +137,7 @@ Bool ISO1FileFind(CDrv *dv,I64 cur_dir_cluster,U8 *name,
if (fuf_flags&~FUG_FILE_FIND)
throw('FUF');
DrvChk(dv);
if (dv->type!=DVT_ISO9660)
if (dv->fs_type!=FSt_ISO9660)
PrintErr("Not ISO9660 Drv\n");
else
try {
@@ -195,7 +195,7 @@ U8 *ISO1FileRead(CDrv *dv,U8 *cur_dir,U8 *filename,I64 *_size,I64 *_attr)
DrvChk(dv);
*_size=0;
*_attr=0;
if (dv->type!=DVT_ISO9660)
if (dv->fs_type!=FSt_ISO9660)
PrintErr("Not ISO9660 Drv\n");
else
try {
@@ -219,7 +219,7 @@ U8 *ISO1FileRead(CDrv *dv,U8 *cur_dir,U8 *filename,I64 *_size,I64 *_attr)
Bool ISO1Cd(U8 *name,I64 cur_dir_cluster)
{
CDirEntry de;
if (Fs->cur_dv->type!=DVT_ISO9660)
if (Fs->cur_dv->fs_type!=FSt_ISO9660)
PrintErr("Not ISO9660 Drv\n");
else if (ISO1FileFind(Fs->cur_dv,cur_dir_cluster,name,&de,FUF_JUST_DIRS))
return TRUE;
@@ -269,16 +269,18 @@ CDirEntry *ISO1FilesFind(U8 *files_find_mask,
tempde->sub=ISO1FilesFind(files_find_mask,fuf_flags,tempde);
Cd("..");
}
} else if ((tempde->attr & RS_ATTR_DIR ||
!Bt(&fuf_flags,FUf_JUST_DIRS)) &&
!(Bt(&fuf_flags,FUf_RECURSE) &&
*tempde->name=='.' && tempde->attr&RS_ATTR_DIR) &&
FilesFindMatch(tempde->name,files_find_mask,fuf_flags)) {
tempde->next=result;
result=tempde;
} else {
tempde->full_name=FileNameAbs(tempde->name);
} else
DirEntryDel(tempde);
if ((tempde->attr & RS_ATTR_DIR ||
!Bt(&fuf_flags,FUf_JUST_DIRS)) &&
!(Bt(&fuf_flags,FUf_RECURSE) &&
*tempde->name=='.' && tempde->attr&RS_ATTR_DIR) &&
FilesFindMatch(tempde->full_name,files_find_mask,fuf_flags)) {
tempde->next=result;
result=tempde;
} else
DirEntryDel(tempde);
}
} else
DirEntryDel(tempde);
i-=buf->len;
Kernel/BlkDev/FileSysRedSea.CPP
+26 -28
View File
@@ -64,7 +64,7 @@ U0 RedSeaDrvInit(CDrv *dv)
RBlks(dv,&br,dv->base_offset,1);
if (br.signature!=MBR_PT_REDSEA || br.signature2!=0xAA55)
throw('Drv');
dv->type=DVT_REDSEA;
dv->fs_type=FSt_REDSEA;
RedSeaFreeFreeLst(dv);
dv->spc=1;
dv->size=br.sects;
@@ -83,16 +83,12 @@ Bool RedSeaDrvValidate(U8 drv_let)
{
CDrv *dv;
CRedSeaBoot br;
Bool result=FALSE;
try {
dv=Let2Drv(drv_let);
if (dv->type==DVT_REDSEA && RBlks(dv,&br,dv->base_offset,1) &&
br.signature==MBR_PT_REDSEA && br.signature2==0xAA55 &&
br.sects==dv->size)
result=TRUE;
} catch
Fs->catch_except=TRUE;
return result;
if ((dv=Let2Drv(drv_let,FALSE)) && dv->fs_type==FSt_REDSEA &&
RBlks(dv,&br,dv->base_offset,1) && br.signature==MBR_PT_REDSEA &&
br.signature2==0xAA55 && br.sects==dv->size)
return TRUE;
else
return FALSE;
}
U0 RedSeaFmt(U8 drv_let,Bool quick=TRUE)
@@ -104,9 +100,9 @@ U0 RedSeaFmt(U8 drv_let,Bool quick=TRUE)
I64 i,n;
try {
DrvLock(dv);
// DrvTypeSet(drv_let,DVT_REDSEA);
DrvTypeSet(drv_let,DVT_FAT32);
dv->type=DVT_REDSEA;
// DrvTypeSet(drv_let,FSt_REDSEA);
DrvTypeSet(drv_let,FSt_FAT32);
dv->fs_type=FSt_REDSEA;
br->signature=MBR_PT_REDSEA;
br->signature2=0xAA55;
br->base_offset=dv->base_offset; //For CD/DVD image copy.
@@ -165,7 +161,7 @@ Bool RedSeaFileFind(CDrv *dv,I64 cur_dir_cluster,U8 *name,
throw('FUF');
MemSet(_result,0,sizeof(CDirEntry));
DrvChk(dv);
if (dv->type!=DVT_REDSEA)
if (dv->fs_type!=FSt_REDSEA)
PrintErr("Not RedSea Drv\n");
else if (!CFileNameTo(dname,name))
PrintErr("Invalid FileName.\n");
@@ -214,7 +210,7 @@ U8 *RedSeaFileRead(CDrv *dv,U8 *cur_dir,U8 *filename,I64 *_size,I64 *_attr)
DrvChk(dv);
*_size=0;
*_attr=0;
if (dv->type!=DVT_REDSEA)
if (dv->fs_type!=FSt_REDSEA)
PrintErr("Not RedSea Drv\n");
else
try {
@@ -238,7 +234,7 @@ U8 *RedSeaFileRead(CDrv *dv,U8 *cur_dir,U8 *filename,I64 *_size,I64 *_attr)
Bool RedSeaCd(U8 *name,I64 cur_dir_cluster)
{
CDirEntry de;
if (Fs->cur_dv->type!=DVT_REDSEA)
if (Fs->cur_dv->fs_type!=FSt_REDSEA)
PrintErr("Not RedSea Drv\n");
else if (RedSeaFileFind(Fs->cur_dv,cur_dir_cluster,name,&de,FUF_JUST_DIRS))
return TRUE;
@@ -255,7 +251,7 @@ U0 RedSeaFreeClusters(CDrv *dv,I64 c,I64 cnt)
Bool found=FALSE,unlock,unlock_break;
DrvChk(dv);
if (!c) return;
if (dv->type!=DVT_REDSEA)
if (dv->fs_type!=FSt_REDSEA)
PrintErr("Not RedSea Drv\n");
else
try {
@@ -517,7 +513,7 @@ I64 RedSeaFileWrite(CDrv *dv,U8 *cur_dir,U8 *name,U8 *buf,I64 size,
I64 c=0,blk_cnt;
MemSet(&de,0,sizeof(CDirEntry));
if (size<0) size=0;
if (dv->type!=DVT_REDSEA)
if (dv->fs_type!=FSt_REDSEA)
PrintErr("Not RedSea Drv\n");
else if (!CFileNameTo(de.name,name))
PrintErr("Invalid FileName.\n");
@@ -581,16 +577,18 @@ CDirEntry *RedSeaFilesFind(U8 *files_find_mask,I64 fuf_flags,
Cd("..");
}
DrvLock(dv);
} else if ((tempde->attr&RS_ATTR_DIR ||
!Bt(&fuf_flags,FUf_JUST_DIRS)) &&
!(Bt(&fuf_flags,FUf_RECURSE) && *tempde->name=='.' &&
tempde->attr&RS_ATTR_DIR) &&
FilesFindMatch(tempde->name,files_find_mask,fuf_flags)) {
tempde->next=result;
result=tempde;
} else {
tempde->full_name=FileNameAbs(tempde->name);
} else
DirEntryDel(tempde);
if ((tempde->attr&RS_ATTR_DIR ||
!Bt(&fuf_flags,FUf_JUST_DIRS)) &&
!(Bt(&fuf_flags,FUf_RECURSE) && *tempde->name=='.' &&
tempde->attr&RS_ATTR_DIR) &&
FilesFindMatch(tempde->full_name,files_find_mask,fuf_flags)) {
tempde->next=result;
result=tempde;
} else
DirEntryDel(tempde);
}
}
ptr(U8 *)+=CDIR_SIZE;
}
Kernel/PSect.CPP → Kernel/FunSeg.CPP
+28 -28
View File
@@ -7,7 +7,7 @@ I64 HasLower(U8 *src)
return FALSE;
}
CHash *PSectFind(U8 *addr,I64 *_offset)
CHash *FunSegFind(U8 *addr,I64 *_offset)
{//See $LK,"Hash",A="HI:Hash"$.
CHash *result=NULL;
CHashExport *tempex;
@@ -57,63 +57,63 @@ CHash *PSectFind(U8 *addr,I64 *_offset)
return result;
}
U0 PSectCacheAdd(CHash *temps,U8 *addr)
U0 FunSegCacheAdd(CHash *temps,U8 *addr)
{
I64 i;
CDbgInfo *dbg_info;
CPSectCache *temppc;
CFunSegCache *tempfsc;
if (temps && temps->type&HTT_FUN &&
(dbg_info=temps(CHashFun *)->dbg_info)) {
lock i=dbg.psect_cache_index++;
temppc=&dbg.psect_cache[i&(PSECT_CACHE_SIZE-1)];
temppc->base=dbg_info->body[0];
if (addr<temppc->base)
temppc->base=addr;
temppc->limit=dbg_info->body[dbg_info->max_line+1-dbg_info->min_line];
if (addr>=temppc->limit)
temppc->limit=addr+1;
i=MinI64(StrLen(temps->str),PSECT_CACHE_STR_LEN-1);
MemCpy(temppc->str,temps->str,i);
temppc->str[i]=0;
temppc->time_stamp=tS;
lock i=dbg.fun_seg_cache_index++;
tempfsc=&dbg.fun_seg_cache[i&(FUN_SEG_CACHE_SIZE-1)];
tempfsc->base=dbg_info->body[0];
if (addr<tempfsc->base)
tempfsc->base=addr;
tempfsc->limit=dbg_info->body[dbg_info->max_line+1-dbg_info->min_line];
if (addr>=tempfsc->limit)
tempfsc->limit=addr+1;
i=MinI64(StrLen(temps->str),FUN_SEG_CACHE_STR_LEN-1);
MemCpy(tempfsc->str,temps->str,i);
tempfsc->str[i]=0;
tempfsc->time_stamp=tS;
}
}
U8 *PSectCacheFind(U8 *addr,I64 *_offset)
U8 *FunSegCacheFind(U8 *addr,I64 *_offset)
{
I64 i;
F64 timeout;
CPSectCache *temppc=dbg.psect_cache;
CFunSegCache *tempfsc=dbg.fun_seg_cache;
if (addr==SYS_IDLE_PT) {
*_offset=0;
return "SYS_IDLE_PT";
} else {
timeout=tS+8.0;
for (i=0;i<PSECT_CACHE_SIZE;i++,temppc++)
if (temppc->base<=addr<temppc->limit &&
temppc->time_stamp>timeout) {
*_offset=addr-temppc->base;
return temppc->str;
for (i=0;i<FUN_SEG_CACHE_SIZE;i++,tempfsc++)
if (tempfsc->base<=addr<tempfsc->limit &&
tempfsc->time_stamp>timeout) {
*_offset=addr-tempfsc->base;
return tempfsc->str;
}
return NULL;
}
}
U0 StrPrintPSect(U8 *buf,I64 addr,I64 field_len)
U0 StrPrintFunSeg(U8 *buf,I64 addr,I64 field_len)
{
I64 offset;
CHashExport *tempex;
U8 *str,*str2;
Bool is_fun=FALSE;
if (addr) {
if (str=PSectCacheFind(addr,&offset)) {
if (str=FunSegCacheFind(addr,&offset)) {
if (addr!=SYS_IDLE_PT)
is_fun=TRUE;
} else {
if (tempex=PSectFind(addr,&offset)) {
if (tempex=FunSegFind(addr,&offset)) {
if (tempex->type&HTT_FUN)
is_fun=TRUE;
PSectCacheAdd(tempex,addr);
FunSegCacheAdd(tempex,addr);
str=tempex->str;
}
}
@@ -148,7 +148,7 @@ I64 SrcLineNum(U8 *addr,I64 cnt=1)
CDbgInfo *dbg_info;
U32 *body;
U8 *src,*src2;
if (temph=PSectFind(addr,&offset)) {
if (temph=FunSegFind(addr,&offset)) {
if (temph->type&(HTT_FUN|HTT_EXPORT_SYS_SYM)) {
if (dbg_info=temph->dbg_info) {
num_lines=dbg_info->max_line-dbg_info->min_line+1;
@@ -203,7 +203,7 @@ U8 *SrcFileName(U8 *addr,I64 cnt=1,CTask *mem_task=NULL)
U32 *body;
CDbgInfo *dbg_info;
U8 *src;
if ((temph=PSectFind(addr,&offset)) &&
if ((temph=FunSegFind(addr,&offset)) &&
temph->type&(HTT_FUN|HTT_EXPORT_SYS_SYM)) {
if (dbg_info=temph->dbg_info) {
j=dbg_info->max_line-dbg_info->min_line+1;
Kernel/KCfg.CPP
+3 -9
View File
@@ -27,8 +27,8 @@ class CKernelCfg
CDoc *KernelCfgAddDev(CKernelCfg *c)
{
I64 ch,cnt=0;
CDoc *doc=DocNew,*doc2;
I64 ch;
CDoc *doc=DocNew;
"\n\nIn anticipation of the drives you will\n"
"define shortly, enter the drive letter\n"
"of the drive with the account directory.\n"
@@ -40,13 +40,7 @@ CDoc *KernelCfgAddDev(CKernelCfg *c)
c->boot_drv_let=Drv2Let(Fs->cur_dv);
"\n\n$$BK,1$$$$PURPLE$$Mount drives so they will be present when "
"you boot.$$FG$$$$BK,0$$\n";
do {
if (doc2=BlkDevPmt(c->boot_drv_let)) {
DocInsDoc(doc,doc2);
DocDel(doc2);
cnt++;
}
} while (!cnt || doc2);
Mount2(c->boot_drv_let,doc,FALSE);
return doc;
}
Kernel/KEnd.CPP
+3 -1
View File
@@ -60,7 +60,7 @@ U0 SysGlblsInit()
QueInit(&dev.pci_root);
dev.mem64_ptr=MEM_MAPPED_SPACE;
dbg.psect_cache=CAlloc(PSECT_CACHE_SIZE*sizeof(CPSectCache));
dbg.fun_seg_cache=CAlloc(FUN_SEG_CACHE_SIZE*sizeof(CFunSegCache));
dbg.int_fault_code=IntFaultHandlersNew;
}
@@ -203,6 +203,8 @@ U0 KernelMain()
try ExeFile("StartOS"); //Continues $LK,"/StartOS.CPP",A="FL:/StartOS.CPP,1"$
catch {
Raw(ON);
Silent(OFF);
GetOutOfDollar;
PutExcept;
Dbg;
}
Kernel/KExcept.CPP
+2 -1
View File
@@ -44,7 +44,8 @@ _extern _SAVE_EXCEPT_REGS U0 SaveExceptRegs(CExcept *t);
U0 PutExcept(Bool catch_it=TRUE)
{//Print exception msg and catch exception.
"Except:%c:%P:%P\n",Fs->except_ch,Fs->except_caller1,Fs->except_caller2;
"Except:%c:",Fs->except_ch;
"%P:%P\n",Fs->except_caller1,Fs->except_caller2;
Fs->catch_except=catch_it;
}
Kernel/KExts.CPP
+8 -6
View File
@@ -4,13 +4,14 @@ before import is resolved, you can use
"import". Otherwise, use a fun pointer
var and check it before calling.
*/
import U8 *DocSave(CDoc *doc,I64 *_size=NULL);
import Bool DocUnlock(CDoc *doc);
import Bool Ed(U8 *link_st,I64 edf_dof_flags=0);
extern U0 AdamErr(U8 *fmt,...);
extern U0 AdamLog(U8 *fmt,...);
extern I64 BIOSTotalMem();
extern I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free);
extern U0 BlkDevChk(CBlkDev *bd);
extern CBlkDev *BlkDevChk(CBlkDev *bd,Bool except=TRUE);
extern Bool BlkDevLock(CBlkDev *bd);
extern CBlkDev *BlkDevNextFree(U8 first_drv_let,I64 type);
extern Bool BlkDevUnlock(CBlkDev *bd,Bool rst=FALSE);
@@ -28,8 +29,9 @@ extern I64 Del(U8 *files_find_mask,Bool make_mask=FALSE,
extern U8 *DftExt(U8 *name,U8 *extension);
extern Bool Drv(U8 drv_let);
extern U8 Drv2Let(CDrv *dv=NULL);
extern U0 DrvChk(CDrv *dv);
extern Bool DrvTypeSet(U8 drv_let,I64 type=DVT_REDSEA);
extern CDrv *DrvChk(CDrv *dv,Bool except=TRUE);
extern U8 DrvTextAttrGet(U8 drv_let=0);
extern Bool DrvTypeSet(U8 drv_let,I64 type=FSt_REDSEA);
extern U0 DrvsRelease();
extern U0 DskCacheInvalidate(CDrv *dv);
extern U0 Exit();
@@ -56,8 +58,8 @@ extern Bool ISODrvInit(CDrv *dv,I64 blk);
extern Bool IsDbg();
extern Bool IsDir(U8 *dir_name);
extern Bool IsRaw();
extern CBlkDev *Let2BlkDev(U8 drv_let=0);
extern CDrv *Let2Drv(U8 drv_let=0);
extern CBlkDev *Let2BlkDev(U8 drv_let=0,Bool except=TRUE);
extern CDrv *Let2Drv(U8 drv_let=0,Bool except=TRUE);
extern U0 MPInt(I64 num,I64 cpu_num=1);
extern U8 *MStrPrint(U8 *fmt,...);
extern Bool MkDir(U8 *filename);
@@ -85,7 +87,7 @@ extern U0 SrvCmdQueDel(CSrvCmd *root);
extern I64 SrvCmdsHandler(I64 run_flags,CTask *task=NULL);
extern U0 SrvCtrlInit(CSrvCtrl *ctrl);
extern U8 *StrPrint(U8 *dst,U8 *fmt,...);
extern U0 StrPrintPSect(U8 *buf,I64 addr,I64 field_len);
extern U0 StrPrintFunSeg(U8 *buf,I64 addr,I64 field_len);
extern Bool Suspend(CTask *task=NULL,Bool state=TRUE);
extern CSrvCmd *TaskMsg(CTask *_srv,CTask *master,
I64 code,I64 a1,I64 a2,I64 flags);
Kernel/KGlbls.CPP
+1 -1
View File
@@ -2,7 +2,7 @@
//$LK,"Globals Set to Zero Here",A="FF:::/Compiler/PrsStmt.CPP,sys_var_init_flag"$.
CSrvCmd sys_macro_root;
CTask *sys_macro_util_task;
CTask *sys_macro_task;
CDoc *sys_clipboard_doc;
CTask *adam_task;
Kernel/KStart.CPP
+5 -5
View File
@@ -46,9 +46,9 @@ GDT_TR: DU8 MP_MAX_PROCESSORS*16 DUP(0);
GDT_TR_RING3: DU8 MP_MAX_PROCESSORS*16 DUP(0);
#assert $$-SYS_GDT==sizeof(CGDT)
SYS_GDT_PTR:: DU16 sizeof(CGDT)-1;
DU64 0;
SYS_PCI_BUSSES:: DU16 0;
SYS_GDT_PTR:: DU16 sizeof(CGDT)-1;
DU64 0;
SYS_PCI_BUSES:: DU16 0;
#assert $$-SYS_KERNEL==sizeof(CKernel)-sizeof(CBinFile)
//************************************
@@ -117,7 +117,7 @@ GET_IP: POP BX
@@20: ADD SP,2
//Get PCI Bus Info
@@25: MOV U16 [SYS_PCI_BUSSES],256
@@25: MOV U16 [SYS_PCI_BUSES],256
XOR DX,DX
MOV AX,0xB101
INT 0x1A
@@ -125,7 +125,7 @@ GET_IP: POP BX
JNE @@30
MOV CH,0
INC CX
MOV U16 [SYS_PCI_BUSSES],CX
MOV U16 [SYS_PCI_BUSES],CX
@@30:
CLI
Kernel/KTask.CPP
+3 -3
View File
@@ -184,9 +184,9 @@ I64 TaskInit(CTask *task,I64 stk_size)
task->stk=temps=TaskStkNew(stk_size,task);
task->rsp=(&temps->stk_base)(U8 *)+temps->stk_size;
task->text_attr =TERM_ATTR_TEXT;
task->border_attr =TERM_ATTR_BORDER;
task->text_attr =WHITE<<4+BLUE;
task->border_src =BDS_CONST;
task->border_attr =DrvTextAttrGet(':');
task->title_src =TTS_CONST;
task->win_left =1;
task->win_right =text.cols-2;
@@ -299,7 +299,7 @@ I64 ExeCmdLine(CCmpCtrl *cc)
MemCpy(ptr2,ptr,TASK_TITLE_LEN);
}
cc->flags&=~CCF_HAS_MISC_DATA;
machine_code=LexStatement2Bin(cc,&type);
machine_code=LexStmt2Bin(cc,&type);
if (machine_code!=INVALID_PTR) {
if (!(cc->flags&CCF_JUST_LOAD)) {
t0=tS;
Kernel/Kernel.MAP
+1797 -1807
View File
File diff suppressed because it is too large. Load diff
Kernel/Kernel.PRJ
+1 -1
View File
@@ -52,7 +52,7 @@
#include "MultiProc"
#include "EdLite"
#include "BlkDev/MakeBlkDev"
#include "PSect"
#include "FunSeg"
#include "KEnd"
#exe {KernelCfgDel(kernel_cfg);};
Kernel/KernelA.HPP
+79 -82
View File
@@ -926,8 +926,8 @@ public class CHashGlblVar:CHashSrcSym
#define DOCT_HEX_ED 33
#define DOCT_TREE 34
#define DOCT_SPRITE 35
#define DOCT_INS_BINARY 36
#define DOCT_INS_BINARY_SIZE 37
#define DOCT_INS_BIN 36
#define DOCT_INS_BIN_SIZE 37
#define DOCT_SONG 38
#define DOCT_HIGHLIGHT 39
#define DOCT_HTML_CODE 40
@@ -948,7 +948,7 @@ public class CHashGlblVar:CHashSrcSym
#define DOCEt_UNDERLINE ATTRf_UNDERLINE
#define DOCG_DBL_BUF_FLAGS (DOCF_OVERSTRIKE|DOCF_PLAIN_TEXT|\
DOCF_PLAIN_TEXT_WITH_TABS|DOCF_MIN_SIZE|DOCF_NO_CURSOR|\
DOCF_PLAIN_TEXT_TABS|DOCF_MIN_SIZE|DOCF_NO_CURSOR|\
DOCF_FORM|DOCF_DBL_DOLLARS|DOCF_DONT_SWAP_OUT|\
DOCF_DO_FULL_REFRESH|DOCF_BORDER_DOC|DOCF_HIDE_CURSOR|\
DOCF_CARRIAGE_RETURN)
@@ -1110,10 +1110,7 @@ public class CDocBin
#define DOCSS_COMMENT 3
#define DOCSS_CPP_Z_COMMENT 4
#define TERM_ATTR_TEXT WHITE<<4+BLUE
#define TERM_ATTR_BORDER WHITE<<4+LTBLUE
#define DOC_ATTR_DFT_TEXT WHITE<<4+BLACK
#define DOC_COLOR_ALT_TEXT LTGRAY
#define DOC_COLOR_LINK RED
#define DOC_COLOR_MACRO LTBLUE
@@ -1234,7 +1231,7 @@ class CEdFileName
// DOC header flags
#define DOCF_PLAIN_TEXT 0x1
#define DOCF_PLAIN_TEXT_WITH_TABS 0x2 //has '\t', not DOCT_TAB
#define DOCF_PLAIN_TEXT_TABS 0x2 //has '\t', not DOCT_TAB
#define DOCF_NO_CURSOR 0x4
#define DOCF_CARRIAGE_RETURN 0x8
#define DOCF_DBL_DOLLARS 0x10
@@ -1269,7 +1266,7 @@ class CEdFileName
#define DOCF_UNDO_DIRTY 0x1000000000
#define DOCf_PLAIN_TEXT 0
#define DOCf_PLAIN_TEXT_WITH_TABS 1 //has '\t', not DOCT_TAB
#define DOCf_PLAIN_TEXT_TABS 1 //has '\t', not DOCT_TAB
#define DOCf_NO_CURSOR 2
#define DOCf_CARRIAGE_RETURN 3
#define DOCf_DBL_DOLLARS 4
@@ -1322,7 +1319,6 @@ class CDocUndo
#define DOC_RECALC_FIND_CURSOR 1
#define DOC_RECALC_TO_SCREEN 2
public class CDoc //Linked Text File header
{//See $LK,"Doc",A="HI:Doc"$ for documentation.
CDocEntryBase root;
@@ -1503,19 +1499,19 @@ public class CAutoCompleteDictGlbls
#help_index "Compiler/Directive"
//Compiler $LK,"Option",A="MN:Option"$()s
//You might need to do #exe {Option();}
//Note: The #exe statement is lexed-ahead,
//Note: The #exe stmt is lexed-ahead,
//so it takes effect earlier than you might expect.
#define OPTf_ECHO 0x00
#define OPTf_TRACE 0x01
#define OPTf_WARN_UNUSED_VAR 0x10 //Applied to funs, not statements
#define OPTf_WARN_UNUSED_VAR 0x10 //Applied to funs, not stmts
#define OPTf_WARN_PAREN 0x11 //Warn unnecessary parens
#define OPTf_WARN_DUP_TYPES 0x12 //Warn dup local var type statements
#define OPTf_WARN_DUP_TYPES 0x12 //Warn dup local var type stmts
#define OPTf_EXTERNS_TO_IMPORTS 0x20
#define OPTf_KEEP_PRIVATE 0x21
#define OPTf_NO_REG_VAR 0x22 //Applied to funs, not statements
#define OPTf_NO_REG_VAR 0x22 //Applied to funs, not stmts
#define OPTf_GLBLS_ON_DATA_HEAP 0x23
//Disable 10-byte float consts for ã,log2_10,log10_2,loge_2
#define OPTf_NO_BUILTIN_CONST 0x24 //Applied to funs, not statements
#define OPTf_NO_BUILTIN_CONST 0x24 //Applied to funs, not stmts
#define OPTf_USE_IMM64 0x25 //Not completely implemented
#define OPTF_ECHO (1<<OPTf_ECHO)
@@ -2024,50 +2020,50 @@ class CAOTCtrl
};
//Tokens
#define TK_EOF 0
#define TK_SUPERSCRIPT 0x001
#define TK_SUBSCRIPT 0x002
#define TK_NORMALSCRIPT 0x003
#define TK_IDENT 0x100
#define TK_STR 0x101
#define TK_INTEGER 0x102
#define TK_CHAR_CONST 0x103
#define TK_F64 0x104
#define TK_PLUS_PLUS 0x105
#define TK_MINUS_MINUS 0x106
#define TK_DEREFERENCE 0x107
#define TK_DBL_COLON 0x108
#define TK_SHL 0x109
#define TK_SHR 0x10A
#define TK_EQUAL_EQUAL 0x10B
#define TK_NOT_EQUAL 0x10C
#define TK_LESS_EQUAL 0x10D
#define TK_GREATER_EQUAL 0x10E
#define TK_AND_AND 0x10F
#define TK_OR_OR 0x110
#define TK_XOR_XOR 0x111
#define TK_SHL_EQUAL 0x112
#define TK_SHR_EQUAL 0x113
#define TK_MUL_EQUAL 0x114
#define TK_DIV_EQUAL 0x115
#define TK_AND_EQUAL 0x116
#define TK_OR_EQUAL 0x117
#define TK_XOR_EQUAL 0x118
#define TK_ADD_EQUAL 0x119
#define TK_SUB_EQUAL 0x11A
#define TK_IF 0x11B
#define TK_IFDEF 0x11C
#define TK_IFNDEF 0x11D
#define TK_IFAOT 0x11E
#define TK_IFJIT 0x11F
#define TK_ENDIF 0x120
#define TK_ELSE 0x121
#define TK_MOD_EQUAL 0x122
#define TK_DOT_DOT 0x123
#define TK_DOT_DOT_DOT 0x124
#define TK_INS_BINARY 0x125
#define TK_INS_BINARY_SIZE 0x126
#define TK_NUM_TK 0x127
#define TK_EOF 0
#define TK_SUPERSCRIPT 0x001
#define TK_SUBSCRIPT 0x002
#define TK_NORMALSCRIPT 0x003
#define TK_IDENT 0x100
#define TK_STR 0x101
#define TK_INTEGER 0x102
#define TK_CHAR_CONST 0x103
#define TK_F64 0x104
#define TK_PLUS_PLUS 0x105
#define TK_MINUS_MINUS 0x106
#define TK_DEREFERENCE 0x107
#define TK_DBL_COLON 0x108
#define TK_SHL 0x109
#define TK_SHR 0x10A
#define TK_EQU_EQU 0x10B
#define TK_NOT_EQU 0x10C
#define TK_LESS_EQU 0x10D
#define TK_GREATER_EQU 0x10E
#define TK_AND_AND 0x10F
#define TK_OR_OR 0x110
#define TK_XOR_XOR 0x111
#define TK_SHL_EQU 0x112
#define TK_SHR_EQU 0x113
#define TK_MUL_EQU 0x114
#define TK_DIV_EQU 0x115
#define TK_AND_EQU 0x116
#define TK_OR_EQU 0x117
#define TK_XOR_EQU 0x118
#define TK_ADD_EQU 0x119
#define TK_SUB_EQU 0x11A
#define TK_IF 0x11B
#define TK_IFDEF 0x11C
#define TK_IFNDEF 0x11D
#define TK_IFAOT 0x11E
#define TK_IFJIT 0x11F
#define TK_ENDIF 0x120
#define TK_ELSE 0x121
#define TK_MOD_EQU 0x122
#define TK_DOT_DOT 0x123
#define TK_DOT_DOT_DOT 0x124
#define TK_INS_BIN 0x125
#define TK_INS_BIN_SIZE 0x126
#define TK_NUM_TK 0x127
class CLexHashTableContext
{
@@ -2620,8 +2616,8 @@ public class CBlkDev
{
CBlkDev *lock_fwding; //If two blkdevs on same controller, use just one lock
I64 locked_flags;
U32 type,flags,
bd_signature;
U32 bd_signature,
type,flags;
U8 first_drv_let,unit,pad[2];
U32 base0,base1,
blk_size;
@@ -2633,21 +2629,22 @@ public class CBlkDev
U32 max_reads,max_writes;
};
//Drive locked flags
//Drive locked_flags
#define DVlf_LOCKED 0
//See $LK,"ST_DRV_TYPES",A="MN:ST_DRV_TYPES"$
#define DVT_NULL 0
#define DVT_REDSEA 1 //Supported
#define DVT_FAT32 2 //Supported except for short names, to some degree
#define DVT_ISO9660 3 //Supported (CD/DVD)
#define DVT_ISO13490 4 //Not Supported (CD/DVD)
#define DVT_ISO13346 5 //Not Supported (CD/DVD)
#define DVT_NTFS 6 //Not Supported
#define DVT_UNKNOWN 7
#define DVT_NUM_TYPES 8
#define DVTf_DISABLE 31 //High bit of type is disable
#define FSt_NULL 0
#define FSt_REDSEA 1 //Supported
#define FSt_FAT32 2 //Supported except for short names, to some degree
#define FSt_ISO9660 3 //Supported (CD/DVD)
#define FSt_ISO13490 4 //Not Supported (CD/DVD)
#define FSt_ISO13346 5 //Not Supported (CD/DVD)
#define FSt_NTFS 6 //Not Supported
#define FSt_UNKNOWN 7
#define FSt_NUM_TYPES 8
#define FSG_TYPE_MASK 0x7FFF
//File system type flags
#define FStf_DISABLE 15
#define MBR_PT_FAT12 0x01
#define MBR_PT_FAT32a 0x0B
@@ -2673,9 +2670,9 @@ public class CDrv
//Don't access ->drv_let directly in case a drive has been remapped.
//Use $LK,"Drv2Let",A="MN:Drv2Let"$().
I64 locked_flags;
U32 type, //Bit31 is used as a disable, since it will be unknown
dv_signature;
U8 drv_let,text_attr,pad[6];
U32 dv_signature;
U8 drv_let,pad;
U16 fs_type;
I64 base_offset,
size,
file_system_info_sect,
@@ -3793,16 +3790,16 @@ public class CSndGlbls
Bool record;
};
#help_index "Debugging/PSect"
#define PSECT_CACHE_SIZE 256
class CPSectCache
#help_index "Debugging/FunSeg"
#define FUN_SEG_CACHE_SIZE 256
class CFunSegCache
{
I64 base,limit;
F64 time_stamp;
U8 str[1]; //PSECT_CACHE_STR_LEN
U8 str[1]; //FUN_SEG_CACHE_STR_LEN
$$=64;
};
#define PSECT_CACHE_STR_LEN (sizeof(CPSectCache)-offset(CPSectCache.str))
#define FUN_SEG_CACHE_STR_LEN (sizeof(CFunSegCache)-offset(CFunSegCache.str))
#help_index "Debugging"
class CMPCrash
@@ -3822,8 +3819,8 @@ public class CDbgGlbls
CMPCrash *mp_crash;
U8 *int_fault_code,
*fix_file_line;
CPSectCache *psect_cache;
I64 psect_cache_index;
CFunSegCache *fun_seg_cache;
I64 fun_seg_cache_index;
};
#help_index "Boot"
Kernel/KernelB.HPP
+3 -3
View File
@@ -25,13 +25,13 @@ public _intern IC_LBTR Bool LBtr(
public _intern IC_LBTS Bool LBts(
U8 *bit_field,I64 bit); //Locked bit test and set to one.
public _extern _BEQU Bool BEqu(
U8 *bit_field,I64 bit,Bool val);//Set bit equal to val.
U8 *bit_field,I64 bit,Bool val);//Set bit equ to val.
public _extern _BIT_FIELD_EXTRACT_U32 U32 BFieldExtU32(
U8 *bit_field,I64 bit,I64 size); //Extract U32 from bit field.
public _extern _BIT_FIELD_OR_U32 U0 BFieldOrU32(
U8 *bit_field,I64 bit,U32 pattern); //Or U32 into bit field.
public _extern _LBEQU Bool LBEqu(
U8 *bit_field,I64 bit,Bool val); //Locked Set bit equal to val.
U8 *bit_field,I64 bit,Bool val); //Locked Set bit equ to val.
#help_index "Boot"
_extern SYS_BOOT_BASE U32 sys_boot_base;
@@ -240,7 +240,7 @@ _extern SYS_SEMAS CSema sys_semas[NUM_SYS_SEMAS];
public _intern IC_GS CCPU *Gs(); //GS points to current $LK,"CCPU",A="MN:CCPU"$.
#help_index "PCI"
public _extern SYS_PCI_BUSSES U16 sys_pci_busses; //Number of PCI busses.
public _extern SYS_PCI_BUSES U16 sys_pci_busses; //Number of PCI buses.
#help_index "Processor"
public _intern IC_CARRY I64 Carry(); //See $LK,"::/Demo/Carry.CPP"$
Kernel/KernelC.HPP
+14 -12
View File
@@ -203,15 +203,15 @@ public extern U0 Dr(CTask *task=NULL);
public extern U0 StkRep(CTask *task=NULL);
extern I64 *TaskRegAddr(CTask *task,I64 reg_num);
#help_index "Debugging/PSect"
#help_file "::/Doc/DbgPSect"
#help_index "Debugging/FunSeg"
#help_file "::/Doc/DbgFunSeg"
public extern Bool PutSrcLink(U8 *addr,I64 cnt=1,U8 *buf=NULL);
public extern U8 *SrcEdLink(U8 *addr,I64 cnt=1,CTask *mem_task=NULL);
public extern U8 *SrcFileName(U8 *addr,I64 cnt=1,CTask *mem_task=NULL);
public extern I64 SrcLineNum(U8 *addr,I64 cnt=1);
#help_index "Debugging/PSect;Hash/System"
public extern CHash *PSectFind(U8 *addr,I64 *_offset);
#help_index "Debugging/FunSeg;Hash/System"
public extern CHash *FunSegFind(U8 *addr,I64 *_offset);
#help_index "Debugging/Raw Output"
public extern Bool IsRaw();
@@ -292,12 +292,12 @@ public extern U8 *CurDir(CTask *task=NULL,CTask *mem_task=NULL);
public extern U8 *DftExt(U8 *filename,U8 *extension);
public extern U8 *DirFile(U8 *dirname,U8 *name=NULL,U8 *_extension=NULL);
public extern U8 *DirNameAbs(U8 *dirname);
public extern Bool DrvIsWritable(U8 drv_let=0);
public extern CBlkDev *DrvIsWritable(U8 drv_let=0,Bool except=FALSE);
public extern U8 *FileExtDot(U8 *src);
public extern U8 *FileExtRem(U8 *src,U8 *dst=NULL);
public extern U8 *FileNameAbs(U8 *filename,I64 fuf_flags=0);
public extern Bool FileNameChk(U8 *filename);
public extern Bool FilesFindMatch(U8 *test_filename,
public extern Bool FilesFindMatch(U8 *_test_name,
U8 *files_find_mask,I64 fuf_flags=0);
public extern Bool IsDir(U8 *dir_name);
public extern Bool IsDotC(U8 *filename);
@@ -320,7 +320,7 @@ extern I64 FileAttr(U8 *name,I64 old_attr=0);
#help_index "File/Low Level"
#help_file "::/Doc/FileLowLevel"
public extern U0 BlkDevChk(CBlkDev *bd);
public extern CBlkDev *BlkDevChk(CBlkDev *bd,Bool except=TRUE);
public extern Bool BlkDevLock(CBlkDev *bd);
public extern CBlkDev *BlkDevNextFree(U8 first_drv_let,I64 type);
public extern Bool BlkDevUnlock(CBlkDev *bd,Bool rst=FALSE);
@@ -331,17 +331,19 @@ public extern I64 ClustersAlloc(CDrv *dv,I64 c=0,
I64 cnt=1,Bool contiguous=FALSE);
extern Bool CopySingle(U8 *f1,U8 *f2); //Just one file
public extern U8 Drv2Let(CDrv *dv=NULL);
public extern U0 DrvChk(CDrv *dv);
public extern CDrv *DrvChk(CDrv *dv,Bool except=TRUE);
public extern Bool DrvLock(CDrv *dv);
public extern CDrv *DrvMakeFree(U8 drv_let);
public extern U8 *DrvModelNum(U8 drv_let=0);
public extern CDrv *DrvNextFree(U8 first_drv_let='C');
public extern U8 *DrvSerialNum(U8 drv_let=0);
public extern U8 DrvTextAttrGet(U8 drv_let=0);
public extern Bool DrvUnlock(CDrv *dv,Bool rst=FALSE);
public extern U0 DrvsRelease();
extern U0 FAT32FreeClusters(CDrv *dv,I64 c);
public extern CBlkDev *Let2BlkDev(U8 drv_let=0);
public extern CDrv *Let2Drv(U8 drv_let=0);
public extern CBlkDev *Let2BlkDev(U8 drv_let=0,Bool except=TRUE);
public extern I64 Let2BlkDevType(U8 drv_let=0);
public extern CDrv *Let2Drv(U8 drv_let=0,Bool except=TRUE);
extern I64 Name2DirCluster(CDrv *dv,U8 *dirname);
extern I64 Name2ParentDirCluster(CDrv *dv,U8 *dirname);
public extern Bool RBlks(CDrv *dv,U8 *buf, I64 blk, I64 cnt);
@@ -457,7 +459,7 @@ public extern Bool DrvEnable(U8 drv_let,Bool val);
#help_index "Install;File/Cmd Line (Typically);Cmd Line (Typically);"
public extern U0 Fmt(U8 drv_let,Bool quick=TRUE,
Bool confirm=TRUE,I64 type=DVT_FAT32);
Bool confirm=TRUE,I64 type=FSt_FAT32);
#help_index "Install;Memory/BlkPool"
public extern I64 Scale2Mem(I64 min,I64 max,I64 limit=2*1024*1024*1024);
@@ -472,7 +474,7 @@ public extern CKeyDevEntry *KeyDevAdd(Bool (*fp_put_key)(I64 ch,I64 sc),
public extern U0 KeyDevRem(CKeyDevEntry *tempp);
extern CKeyDevGlbls keydev;
extern CSrvCmd sys_macro_root;
extern CTask *sys_macro_util_task;
extern CTask *sys_macro_task;
#help_index "Keyboard Devices;Char/Input;StdIn"
extern U8 *(*fp_getstr2)(I64 flags=0); //GetStr $LK,"Flags",A="MN:GSF_SHIFT_ESC_EXIT"$
Kernel/SerialDev/Keyboard.CPP
+3 -3
View File
@@ -49,7 +49,7 @@ U0 KbdCmdFlush()
InU8(KBD_PORT);
}
U0 KbdSetLEDs(I64 sc)
U0 KbdLEDsSet(I64 sc)
{
U8 v=0;
BEqu(&v,0,Bt(&sc,SCf_SCROLL));
@@ -378,7 +378,7 @@ U0 KbdBuildSC(U8 raw_byte,Bool in_irq,U8 *_last_raw_byte,I64 *_last_sc)
}
}
if (set_LEDs && !in_irq)
KbdSetLEDs(sc);
KbdLEDsSet(sc);
*_last_sc=sc;
}
@@ -426,7 +426,7 @@ U0 KbdInit()
KbdCmdSend(KBD_CTRL,0xAE); //Enable Keyboard
KbdCmdSend(KBD_PORT,0xF0);
KbdCmdSend(KBD_PORT,0x02);
KbdSetLEDs(kbd.scan_code);
KbdLEDsSet(kbd.scan_code);
} catch {
KbdCmdFlush;
Fs->catch_except=TRUE;
Kernel/SrvCmd.CPP
+1 -1
View File
@@ -133,7 +133,7 @@ CSrvCmd *TaskMsg(CTask *_srv,CTask *master,I64 msg_code,I64 a1,I64 a2,I64 flags)
tempc->flags=flags;
PUSHFD
if (Bt(&sys_semas[SYS_SEMA_RECORD_MACRO],0) &&
srv!=sys_macro_util_task && msg_code==MSG_KEY_DOWN) {
srv!=sys_macro_task && msg_code==MSG_KEY_DOWN) {
tempc1=AMAllocIdentical(tempc);
CLI
QueIns(tempc1,sys_macro_root.last);
Kernel/StrA.CPP
+1 -1
View File
@@ -522,7 +522,7 @@ I64 Spaces2Tabs(U8 *dst,U8 *src)
}
U8 *StrUtil(U8 *_src,I64 flags)
{//See $LK,"flags",A="MN:SUF_REM_SPACES"$ for all the options.
{//Modifies in place. See $LK,"flags",A="MN:SUF_REM_SPACES"$ for all the options.
U8 *src=_src,*dst=_src;
I64 ch;
Kernel/StrPrint.CPP
+14 -6
View File
@@ -224,10 +224,11 @@ the decimal point are stored
in 64-bits. Use exponentiated forms
to avoid this.
*/
I64 i,j,l,ch,k,k0,n,n0,len,dec_len,flags,
I64 i,j,l,ch,k,k0,n,n0,len,dec_len,flags,old_flags,
aux_fmt_num,comma_cnt,comma_fmt_cnt,cur_arg=0;
U64 m;
F64 d,d1;
CDoc *doc;
U8 *ptr,**_buf,*buf,**_dst,temp_buf[TEMP_BUF_LEN],temp_buf2[TEMP_BUF_LEN*2];
if (!fmt)
@@ -334,7 +335,14 @@ to avoid this.
case 'F':
if (cur_arg>=argc)
throw('StrPrint');
ptr=FileRead(argv[cur_arg++]);
if (flags&SPF_DOLLAR) {
doc=argv[cur_arg++];
old_flags=doc->flags;
doc->flags|=DOCF_NO_CURSOR;
ptr=DocSave(doc);
doc->flags=old_flags;
} else
ptr=FileRead(argv[cur_arg++]);
break;
case 'Q':
if (cur_arg>=argc)
@@ -417,18 +425,18 @@ to avoid this.
if (cur_arg>=argc)
throw('StrPrint');
if (flags&SPF_TRUNCATE)
StrPrintPSect(temp_buf,argv[cur_arg++],len);
StrPrintFunSeg(temp_buf,argv[cur_arg++],len);
else
StrPrintPSect(temp_buf,argv[cur_arg++],0);
StrPrintFunSeg(temp_buf,argv[cur_arg++],0);
OutStr(temp_buf,_buf,_dst,len,flags);
break;
case 'P':
if (cur_arg>=argc)
throw('StrPrint');
if (flags&SPF_TRUNCATE)
StrPrintPSect(temp_buf,argv[cur_arg],len);
StrPrintFunSeg(temp_buf,argv[cur_arg],len);
else
StrPrintPSect(temp_buf,argv[cur_arg],0);
StrPrintFunSeg(temp_buf,argv[cur_arg],0);
if (!IsRaw || !_buf) {
StrPrint(temp_buf2,"$$LK,\"%s\",A=\"AD:0x%X\"$$",
temp_buf,argv[cur_arg]);