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

TempleOSCD_150720.ISO

Browse Source
This commit is contained in:
Terry A. Davis authored and minexew committed 2018-09-08 21:46:22 +02:00
1 parent 401601816c
commit f8c05f98f4
554 files changed
+26046 -24853
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

Kernel/Compress.CPP
+36 -33
View File
@@ -2,9 +2,8 @@
//See $LK,"CArcCompress",A="MN:CArcCompress"$, $LK,"CArcEntry",A="MN:CArcEntry"$, and $LK,"CArcCtrl",A="MN:CArcCtrl"$
asm {
USE64
/****
U0 ArcGetEntry(CArcCtrl *c)
U0 ArcEntryGet(CArcCtrl *c)
{
I64 i;
CArcEntry *temp,*temp1;
@@ -23,7 +22,7 @@ U0 ArcGetEntry(CArcCtrl *c)
}
} else {
do if (++i==c->free_limit)
i=c->min_table_entry;
i=c->min_table_entry;
while (c->hash[i]);
temp=&c->compress[i];
c->next_entry=temp;
@@ -40,7 +39,7 @@ U0 ArcGetEntry(CArcCtrl *c)
}
}
****/
_ARC_GET_ENTRY::
_ARC_ENTRY_GET::
PUSH RBP
MOV RBP,RSP
PUSH RSI
@@ -98,7 +97,7 @@ _ARC_GET_ENTRY::
RET1 8
}
_extern _ARC_GET_ENTRY U0 ArcGetEntry(CArcCtrl *c);
_extern _ARC_ENTRY_GET U0 ArcEntryGet(CArcCtrl *c);
I64 ArcDetermineCompressionType(U8 *src,I64 size)
{
@@ -123,7 +122,7 @@ U0 ArcCompressBuf(CArcCtrl *c)
basecode=c->saved_basecode;
while (src_ptr<src_limit && c->dst_pos+c->cur_bits_in_use<=c->dst_size) {
ArcGetEntry(c);
ArcEntryGet(c);
ac_start:
if (src_ptr>=src_limit) goto ac_done;
ch=*src_ptr++;
@@ -178,16 +177,16 @@ U0 ArcExpandBuf(CArcCtrl *c)
if (c->stk_ptr==c->stk_base && dst_ptr<dst_limit) {
if (c->saved_basecode==MAX_U32) {
lastcode=BFieldExtU32(c->src_buf,c->src_pos,
c->next_bits_in_use);
c->next_bits_in_use);
c->src_pos+=c->next_bits_in_use;
*dst_ptr++=lastcode;
ArcGetEntry(c);
ArcEntryGet(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=BFieldExtU32(c->src_buf,c->src_pos,
c->next_bits_in_use);
c->next_bits_in_use);
c->src_pos+=c->next_bits_in_use;
if (c->cur_entry==&c->compress[basecode]) {
*c->stk_ptr++=c->last_ch;
@@ -209,7 +208,7 @@ U0 ArcExpandBuf(CArcCtrl *c)
temp->next=temp1->next;
temp1->next=temp;
ArcGetEntry(c);
ArcEntryGet(c);
while (dst_ptr<dst_limit && c->stk_ptr!=c->stk_base)
*dst_ptr++ = * -- c->stk_ptr;
lastcode=basecode;
@@ -237,7 +236,7 @@ CArcCtrl *ArcCtrlNew(Bool expand,I64 compression_type=CT_8_BIT)
c->free_limit=1<<c->next_bits_in_use;
c->saved_basecode=MAX_U32;
c->entry_used=TRUE;
ArcGetEntry(c);
ArcEntryGet(c);
c->entry_used=TRUE;
return c;
}
@@ -248,36 +247,40 @@ U0 ArcCtrlDel(CArcCtrl *c)
Free(c);
}
U8 *ExpandBuf(CArcCompress *r,CTask *mem_task=NULL)
U8 *ExpandBuf(CArcCompress *arc,CTask *mem_task=NULL)
{//See $LK,"::/Demo/Dsk/SerializeTree.CPP"$.
CArcCtrl *c;
U8 *result=MAlloc(r->expanded_size+1,mem_task);
result[r->expanded_size]=0; //terminate
switch (r->compression_type) {
U8 *result;
if (!(CT_NONE<=arc->compression_type<=CT_8_BIT) ||
arc->expanded_size>MEM_MAPPED_SPACE)
throw('Compress');
result=MAlloc(arc->expanded_size+1,mem_task);
result[arc->expanded_size]=0; //terminate
nobound_switch (arc->compression_type) {
case CT_NONE:
MemCpy(result,&r->body,r->expanded_size);
MemCpy(result,&arc->body,arc->expanded_size);
break;
case CT_7_BIT:
case CT_8_BIT:
c=ArcCtrlNew(TRUE,r->compression_type);
c->src_size=r->compressed_size<<3;
c=ArcCtrlNew(TRUE,arc->compression_type);
c->src_size=arc->compressed_size<<3;
c->src_pos=sizeof(CArcCompress)<<3;
c->src_buf=r;
c->dst_size=r->expanded_size;
c->src_buf=arc;
c->dst_size=arc->expanded_size;
c->dst_buf=result;
c->dst_pos=0;
ArcExpandBuf(c);
ArcCtrlDel(c);
break;
default:
throw('Compress');
}
return result;
}
CArcCompress *CompressBuf(U8 *src,I64 size,CTask *mem_task=NULL)
{//See $LK,"::/Demo/Dsk/SerializeTree.CPP"$.
CArcCompress *result;
CArcCompress *arc;
I64 size_out,compression_type=ArcDetermineCompressionType(src,size);
CArcCtrl *c=ArcCtrlNew(FALSE,compression_type);
c->src_size=size;
@@ -288,18 +291,18 @@ CArcCompress *CompressBuf(U8 *src,I64 size,CTask *mem_task=NULL)
ArcCompressBuf(c);
if (ArcFinishCompression(c) && c->src_pos==c->src_size) {
size_out=(c->dst_pos+7)>>3;
result=MAlloc(size_out,mem_task);
MemCpy(result,c->dst_buf,size_out);
result->compression_type=compression_type;
result->compressed_size=size_out;
arc=MAlloc(size_out,mem_task);
MemCpy(arc,c->dst_buf,size_out);
arc->compression_type=compression_type;
arc->compressed_size=size_out;
} else {
result=MAlloc(size+sizeof(CArcCompress),mem_task);
MemCpy(&result->body,src,size);
result->compression_type=CT_NONE;
result->compressed_size=size+sizeof(CArcCompress);
arc=MAlloc(size+sizeof(CArcCompress),mem_task);
MemCpy(&arc->body,src,size);
arc->compression_type=CT_NONE;
arc->compressed_size=size+sizeof(CArcCompress);
}
result->expanded_size=size;
arc->expanded_size=size;
Free(c->dst_buf);
ArcCtrlDel(c);
return result;
return arc;
}
Kernel/Date.CPP
+5 -4
View File
@@ -18,11 +18,12 @@ CDate Struct2Date(CDateStruct *_ds)
i1=YearStartDate(_ds->year);
i2=YearStartDate(_ds->year+1);
if (i2-i1==365)
i1+=mon_start_days1[_ds->mon-1];
else
i1+=mon_start_days2[_ds->mon-1];
i1+=mon_start_days1[_ds->mon-1];
else
i1+=mon_start_days2[_ds->mon-1];
cdt.date=i1+_ds->day_of_mon-1;
cdt.time=(_ds->sec10000+100*(_ds->sec100+100*(_ds->sec+60*(_ds->min+60*_ds->hour))))<<21/(15*15*3*625);
cdt.time=(_ds->sec10000+100*(_ds->sec100+100*(_ds->sec
+60*(_ds->min+60*_ds->hour))))<<21/(15*15*3*625);
return cdt;
}
Kernel/Display.CPP
+12 -10
View File
@@ -6,7 +6,7 @@ the normal screen text output routine.
See also $LK,"GrUpdateScreen",A="MN:GrUpdateScreen"$().
*/
Bool old_preempt=Preempt(OFF);
Bool old_preempt=Preempt;
I64 i,row,col;
U8 *ptr,*ptr1,*ptr2;
@@ -44,13 +44,13 @@ See also $LK,"GrUpdateScreen",A="MN:GrUpdateScreen"$().
while (text.raw_col % text.cols)
RawPutChar(CH_SPACE);
} else if (Bt(chars_bitmap_displayable,ch)) {
} else if (Bt(chars_bmp_displayable,ch)) {
row=text.raw_col/text.cols%text.rows;
col=text.raw_col%text.cols;
if (!Bt(&sys_run_level,RLf_VGA)) { //if text mode
if (text.raw_flags&RWF_SCROLL && text.raw_col && !row && !col) {
MemCpy(VGAM_TEXT,VGAM_TEXT+text.cols,
text.cols*(text.rows-1)*2);
text.cols*(text.rows-1)*2);
MemSet(VGAM_TEXT+text.cols*(text.rows-1)*2,0,text.cols*2);
text.raw_col-=text.cols;
row=text.rows-1;
@@ -62,10 +62,12 @@ See also $LK,"GrUpdateScreen",A="MN:GrUpdateScreen"$().
OutU8(VGAP_INDEX,VGAR_MAP_MASK);
OutU8(VGAP_DATA,0x0F); //All planes -- WHITE
if (text.raw_flags&RWF_SCROLL && text.raw_col && !row && !col) {
//Scroll cached image
MemCpy(text.raw_screen_image,text.raw_screen_image+GR_WIDTH*FONT_HEIGHT>>3,
GR_WIDTH*(GR_HEIGHT-FONT_HEIGHT)>>3);
MemSet(text.raw_screen_image+GR_WIDTH*(GR_HEIGHT-FONT_HEIGHT)>>3,0,GR_WIDTH*FONT_HEIGHT>>3);
//Scroll cached image
MemCpy(text.raw_screen_image,
text.raw_screen_image+GR_WIDTH*FONT_HEIGHT>>3,
GR_WIDTH*(GR_HEIGHT-FONT_HEIGHT)>>3);
MemSet(text.raw_screen_image+GR_WIDTH*(GR_HEIGHT-FONT_HEIGHT)>>3,0,
GR_WIDTH*FONT_HEIGHT>>3);
MemCpy(VGAM_GRAPHICS,text.raw_screen_image,GR_WIDTH*GR_HEIGHT>>3);
text.raw_col-=text.cols;
@@ -98,13 +100,13 @@ U0 WinDerivedValsUpdate(CTask *task=NULL)
{//Those things calculated from other variables.
if (!task) task=Fs;
//Assert: This is called with TASKLf_TASK_LOCK set
//Assert: This is called with TASKLf_TASK_LOCK set
PUSHFD
CLI
task->win_width =task->win_right-task->win_left+1;
task->win_height=task->win_bottom-task->win_top+1;
//Inside the Border
//Inside the Border
task->pix_left =FONT_WIDTH*task->win_left;
task->pix_right =FONT_WIDTH*(task->win_right+1)-1;
task->pix_width =task->pix_right-task->pix_left+1;
@@ -112,7 +114,7 @@ U0 WinDerivedValsUpdate(CTask *task=NULL)
task->pix_bottom =FONT_HEIGHT*(task->win_bottom+1)-1;
task->pix_height =task->pix_bottom-task->pix_top+1;
//Outside the border
//Outside the border
if (Bt(&task->display_flags,DISPLAYf_NO_BORDER)) {
task->border_pix_left =task->pix_left;
task->border_pix_right =task->pix_right;
Kernel/Dsk/Dsk.CPP
+22
View File
@@ -0,0 +1,22 @@
#include "DskStrA"
#include "DskCache"
#include "DskATA"
#include "DskATAId"
#include "DskBlkDev"
#include "DskDrv"
#include "DskBlk"
#include "DskCluster"
#include "DskStrB"
#include "DskAddDev"
#include "DskDirA"
#include "FileSysISO"
#include "FileSysRedSea"
#include "FileSysFAT"
#include "DskDirContext"
#include "DskFind"
#include "DskDirB"
#include "DskFile"
#include "DskCFile"
#include "DskCopy"
#include "DskCDDVD"
#include "DskFmt"
Kernel/Dsk/DskA.CPP
-731
View File
@@ -1,731 +0,0 @@
Bool BlkDevLock(CBlkDev *bd)
{//Make this task have exclusive access to BlkDev.
BlkDevChk(bd);
while (bd->lock_fwding)
bd=bd->lock_fwding; //If two blkdevs on same controller, use just one lock
if (!Bt(&bd->locked_flags,BDlf_LOCKED) || bd->owning_task!=Fs) {
while (LBts(&bd->locked_flags,BDlf_LOCKED))
Yield;
bd->owning_task=Fs;
return TRUE;
} else
return FALSE;
}
Bool DrvLock(CDrv *dv)
{//Make this task have exclusive access to drv & BlkDev.
DrvChk(dv);
BlkDevLock(dv->bd);
if (!Bt(&dv->locked_flags,DVlf_LOCKED) || dv->owning_task!=Fs) {
while (LBts(&dv->locked_flags,DVlf_LOCKED))
Yield;
dv->owning_task=Fs;
return TRUE;
} else
return FALSE;
}
Bool BlkDevUnlock(CBlkDev *bd,Bool rst=FALSE)
{//Release exclusive lock on access to BlkDev.
BlkDevChk(bd);
while (bd->lock_fwding)
bd=bd->lock_fwding; //If two blkdevs on same controller, use just one lock
if (Bt(&bd->locked_flags,BDlf_LOCKED) && bd->owning_task==Fs) {
if (rst)
bd->flags&=~(BDF_INITIALIZED|BDF_INIT_IN_PROGRESS);
bd->owning_task=NULL;
LBtr(&bd->locked_flags,BDlf_LOCKED);
Yield; //Prevent deadlock
return TRUE;
} else
return FALSE;
}
Bool DrvUnlock(CDrv *dv,Bool rst=FALSE)
{//Release exclusive lock on access to drv & BlkDev.
DrvChk(dv);
if (Bt(&dv->locked_flags,DVlf_LOCKED) && dv->owning_task==Fs) {
BlkDevUnlock(dv->bd,rst);
dv->owning_task=NULL;
LBtr(&dv->locked_flags,DVlf_LOCKED);
Yield; //Prevent deadlock
return TRUE;
} else
return FALSE;
}
Bool BlkDevInit(CBlkDev *bd)
{
CDrv *dv=Let2Drv(bd->first_drv_let);
Bool old_preempt=Preempt(OFF),result=FALSE;
if (!LBts(&bd->flags,BDf_INITIALIZED)) {
bd->flags|=BDF_INIT_IN_PROGRESS;
switch(bd->type) {
case BDT_RAM:
if (!bd->RAM_dsk) {
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->size=bd->max_blk+1;
if (RedSeaDrvValidate(bd->first_drv_let))
RedSeaDrvInit(dv);
else
RedSeaFmt(bd->first_drv_let);
result=TRUE;
break;
case BDT_ATA:
bd->max_reads=128;
bd->max_writes=1;
result=ATAInit(bd);
break;
case BDT_ATAPI:
//0xFFFF*4 is too big for my taste
bd->max_reads=0x800*4;
//max of maybe a quarter of disk cache
if (bd->max_reads>dsk.cache_size/BLK_SIZE/4)
bd->max_reads=dsk.cache_size/BLK_SIZE/4 & ~3;
if (bd->max_reads<128)
bd->max_reads=128;
bd->max_writes=0xFFFF*4;
if (result=ATAInit(bd))
dv->size=bd->max_blk+1;
break;
}
if (result && bd->flags & BDF_READ_CACHE)
DskCacheInvalidate(dv);
bd->flags&=~BDF_INIT_IN_PROGRESS;
} else
result=TRUE;
Preempt(old_preempt);
return result;
}
U0 BlkDevsRelease()
{//When task dies, release all owned BlkDevs.
I64 i;
CBlkDev *bd;
for (i=0;i<NUM_BLKDEVS;i++) {
bd=&dsk.blkdevs[i];
if (bd->owning_task==Fs && bd->bd_signature==BD_SIGNATURE_VAL)
BlkDevUnlock(bd,TRUE);
}
}
U0 DrvsRelease()
{//When task dies, release all owned drvs.
I64 i;
CDrv *dv;
for (i=0;i<NUM_DRVS;i++) {
dv=&dsk.drvs[i];
if (dv->owning_task==Fs && dv->dv_signature==DRV_SIGNATURE_VAL)
DrvUnlock(dv,TRUE);
}
}
CDrv *DrvMakeFree(U8 drv_let)
{//Make a slot free for a new drv, like during $LK,"Mount",A="MN:Mount"$().
//!!! drv_let is not a $LK,"remapped",A="MN:MapDrv"$ drv.
I64 i=ToUpper(drv_let)-'A';
CDrv *result;
if (!(0<=i<NUM_DRVS))
throw('Drv');
result=&dsk.drvs[i];
MemSet(result,0,sizeof(CDrv));
result->drv_let='A'+i;
return result;
}
CDrv *DrvNextFree(U8 first_drv_let='C')
{//Locate free slot for new drv, like during $LK,"Mount",A="MN:Mount"$().
//!!! first_drv_let is not a $LK,"remapped",A="MN:MapDrv"$ drv.
I64 i=ToUpper(first_drv_let)-'A';
if (!(0<=i<NUM_DRVS))
throw('Drv');
do
if (dsk.drvs[i].dv_signature!=DRV_SIGNATURE_VAL)
return DrvMakeFree(i+'A');
while (++i<NUM_DRVS);
throw('Drv');
return NULL; //never gets here
}
CBlkDev *BlkDevNextFree(U8 first_drv_let,I64 type)
{//Locate free slot for new BlkDev, like during $LK,"Mount",A="MN:Mount"$().
I64 i=0;
CBlkDev *result;
do {
result=&dsk.blkdevs[i];
if (result->bd_signature!=BD_SIGNATURE_VAL) {
MemSet(result,0,sizeof(CBlkDev));
result->first_drv_let=first_drv_let;
result->type=type;
if (type==BDT_ATAPI)
result->flags=BDF_REMOVABLE;
else
result->flags=0;
if (type!=BDT_RAM)
result->flags|=BDF_READ_CACHE;
if (type==BDT_ATAPI) {
result->blk_size=CD_BLK_SIZE;
result->flags|=BDF_READ_ONLY;
} else
result->blk_size=BLK_SIZE;
result->max_blk=0xEFFFFFFF;
return result;
}
} while (++i<NUM_BLKDEVS);
throw('BlkDev');
return NULL; //never gets here
}
U0 DrvMapBlkAlloc(CDrv *dv)
{
DrvChk(dv);
Free(dv->cur_map_blk);
dv->cur_map_blk=AMAlloc(BLK_SIZE);
dv->cur_map_blk_num=0;
dv->map_blk_dirty=0;
RBlks(dv,dv->cur_map_blk,dv->map1,1);
}
U0 DrvMapBlkClean(CDrv *dv,I64 map_select=3)
{
if (dv->type==DVT_FAT32 || dv->type==DVT_REDSEA) {
if ((map_select==3 || !map_select) && dv->map1!=dv->map2 &&
Bt(&dv->map_blk_dirty,0))
WBlks(dv,dv->cur_map_blk(I64),dv->map1+dv->cur_map_blk_num,1);
if (map_select==3 || map_select==1 || dv->map1==dv->map2 &&
LBtr(&dv->map_blk_dirty,0))
WBlks(dv,dv->cur_map_blk(I64),dv->map2+dv->cur_map_blk_num,1);
}
}
U0 DrvMapBlkSet(CDrv *dv,I64 c,I64 map_select=3)
{
I64 map_blk_num;
if (c==INVALID_CLUSTER)
throw('Drv');
switch (dv->type) {
case DVT_FAT32:
map_blk_num=c>>(BLK_SIZE_BITS-2);
break;
case DVT_REDSEA:
map_blk_num=(c-dv->data_area)>>(BLK_SIZE_BITS+3);
break;
default:
throw('Drv');
}
if (map_blk_num!=dv->cur_map_blk_num) {
DrvMapBlkClean(dv,map_select);
dv->cur_map_blk_num=map_blk_num;
if (map_select==3 || !map_select)
RBlks(dv,dv->cur_map_blk,dv->map1+dv->cur_map_blk_num,1);
else
RBlks(dv,dv->cur_map_blk,dv->map2+dv->cur_map_blk_num,1);
}
}
#define ZERO_BUF_SIZE 2048
U0 WZeroBlks(CDrv *dv,I64 blk,I64 cnt)
{//Fill blk cnt with zeros in Drv.
I64 n;
U8 *z=CAlloc(ZERO_BUF_SIZE<<BLK_SIZE_BITS);
Bool show_progress;
if (cnt>ZERO_BUF_SIZE && dv->bd->type!=BDT_RAM) {
progress1=0; progress1_max=cnt;
StrCpy(progress1_desc,"Zeroing");
show_progress=TRUE;
} else
show_progress=FALSE;
while (cnt>0) {
n=cnt;
if (n>ZERO_BUF_SIZE)
n=ZERO_BUF_SIZE;
WBlks(dv,z,blk,n);
blk+=n;
cnt-=n;
if (show_progress)
progress1+=n;
Yield; //Prevent locking
}
Free(z);
if (show_progress) {
*progress1_desc=0;
progress1=progress1_max=0;
}
}
Bool DrvTypeSet(U8 drv_let,I64 type=DVT_REDSEA)
{//Very dangerous
I64 i,j,ext_base,drv_num,offset,cur_type;
CMasterBoot mbr;
CBlkDev *bd=Let2BlkDev(drv_let);
drv_num=bd->first_drv_let-'A';
switch (bd->type) {
case BDT_ATA:
offset=0;
ext_base=INVALID_CLUSTER;
while (TRUE) {
ATAReadBlks(bd,&mbr,offset,1);
j=-1;
for (i=0;i<4;i++) {
cur_type=mbr.p[i].type;
if (cur_type) {
if (cur_type==5 || cur_type==15)
j=i;
else {
if (drv_num+'A'==ToUpper(drv_let)) {
switch (type) {
case DVT_REDSEA:
mbr.p[i].type=MBR_PT_REDSEA;
break;
case DVT_FAT32:
mbr.p[i].type=MBR_PT_FAT32a;
break;
default:
throw('Drv');
}
mbr.p[i].active=0x80;
ATAWriteBlks(bd,&mbr,offset,1);
return TRUE;
}
drv_num++;
}
}
}
if (j<0)
break;
if (!mbr.p[j].offset)
break;
if (ext_base==INVALID_CLUSTER) {
offset=mbr.p[j].offset;
ext_base=offset;
} else
offset=mbr.p[j].offset+ext_base;
}
break;
}
}
Bool RBlks(CDrv *dv,U8 *buf, I64 blk, I64 cnt)
{//Read blk cnt from Drv to buf.
Bool result=TRUE,unlock;
CBlkDev *bd=dv->bd;
if (cnt<=0) return TRUE;
DrvChk(dv);
try {
unlock=DrvLock(dv);
BlkDevInit(bd);
if (dv->base_offset && blk<dv->base_offset || blk+cnt>dv->base_offset+dv->size)
throw('Drv');
if (bd->flags & BDF_READ_CACHE)
RCache(dv,&buf,&blk,&cnt);
if (cnt>0) {
switch (bd->type) {
case BDT_RAM:
MemCpy(buf,bd->RAM_dsk+blk<<BLK_SIZE_BITS,cnt<<BLK_SIZE_BITS);
break;
case BDT_ATA:
case BDT_ATAPI:
result=ATARBlks(dv,buf,blk,cnt);
break;
}
bd->last_time=tS;
if (bd->flags & BDF_READ_CACHE)
DskCacheAdd(dv,buf,blk,cnt);
}
if (unlock)
DrvUnlock(dv);
} catch
if (unlock)
DrvUnlock(dv);
return result;
}
Bool WBlks(CDrv *dv,U8 *buf, I64 blk, I64 cnt)
{//Write blk cnt from buf to Drv.
Bool result=TRUE,unlock;
CBlkDev *bd=dv->bd;
if (cnt<=0) return TRUE;
DrvChk(dv);
try {
unlock=DrvLock(dv);
BlkDevInit(bd);
if (bd->flags&BDF_READ_ONLY && !(bd->flags & BDF_READ_ONLY_OVERRIDE))
throw('BlkDev');
if (dv->base_offset && blk<dv->base_offset || blk+cnt>dv->base_offset+dv->size)
throw('Drv');
if (cnt>0) {
switch (bd->type) {
case BDT_RAM:
MemCpy(bd->RAM_dsk+blk<<BLK_SIZE_BITS,buf,cnt<<BLK_SIZE_BITS);
break;
case BDT_ATA:
case BDT_ATAPI:
result=ATAWBlks(dv,buf,blk,cnt);
break;
}
bd->last_time=tS;
if (bd->flags & BDF_READ_CACHE)
DskCacheAdd(dv,buf,blk,cnt);
}
if (unlock)
DrvUnlock(dv);
} catch
if (unlock)
DrvUnlock(dv);
return result;
}
U0 DskCacheInvalidate(CDrv *dv)
{//Needed for removable media. Called by $LK,"ChgDsk",A="MN:ChgDsk"$().
Bool unlock;
CBlkDev *bd=dv->bd;
DrvChk(dv);
try {
unlock=DrvLock(dv);
BlkDevInit(bd);
if (bd->flags & BDF_READ_CACHE)
DskCacheInvalidate2(dv);
if (dv->type==DVT_ISO9660 && !(bd->flags & BDF_READ_ONLY_OVERRIDE))
ISODrvInit(dv,(32767/bd->blk_size+1)*bd->blk_size>>BLK_SIZE_BITS);
if (unlock)
DrvUnlock(dv);
} catch
if (unlock)
DrvUnlock(dv);
}
U0 ChgDsk(U8 drv_let=0)
{//Change disk. (Needed for removable media.)
CDrv *dv=Let2Drv(drv_let);
CBlkDev *bd=dv->bd;
Bool old_preempt=Preempt(OFF);
if (!(bd->flags&BDF_INITIALIZED))
BlkDevInit(bd);
else if (bd->flags&BDF_REMOVABLE)
DskCacheInvalidate(dv);
Drv(drv_let);
RedSeaFreeFreeLst(dv);
Preempt(old_preempt);
}
U8 *DrvSerialNum(U8 drv_let=0)
{//20 bytes max.
CBlkDev *bd=Let2BlkDev(drv_let);
U16 *st,*result=NULL;
I64 i;
if (bd->dev_id_record) {
st=CAlloc(20+1);
for (i=0;i<10;i++)
st[i]=EndianU16(bd->dev_id_record[10+i]);
result=MStrUtil(st,SUF_REM_LEADING|SUF_REM_TRAILING);
Free(st);
}
return result;
}
U8 *DrvModelNum(U8 drv_let=0)
{//40 bytes max.
CBlkDev *bd=Let2BlkDev(drv_let);
U16 *st,*result=NULL;
I64 i;
if (bd->dev_id_record) {
st=CAlloc(40+1);
for (i=0;i<20;i++)
st[i]=EndianU16(bd->dev_id_record[27+i]);
result=MStrUtil(st,SUF_REM_LEADING|SUF_REM_TRAILING);
Free(st);
}
return result;
}
U0 DrvRep()
{//Drive report.
CDrv *dv;
CBlkDev *bd;
I64 i,drv_let;
U8 *st;
"\nDefined Drives:\n\n";
for (i=0,dv=dsk.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";
else if (drv_let==dsk.boot_drv_let)
"$$GREEN$$:";
else
'' CH_SPACE;
"$$PURPLE$$%C %-8Z %-9Z %04X %04X %02X$$FG$$\n",
drv_let,dv->type.u16[0],"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;
Free(st);
}
if (st=DrvSerialNum(drv_let)) {
" $$CYAN$$Serial#:%s$$FG$$\n",st;
Free(st);
}
" %016X-%016X\n",
dv->base_offset,dv->base_offset+dv->size-1;
dv->base_offset,dv->base_offset+dv->size-1;
}
}
}
I64 ClusterNumNext(CDrv *dv,I64 c,I64 cnt=1)
{//Return next cnt'th cluster in chain.
Bool unlock;
DrvChk(dv);
if (cnt<=0) return c;
try {
unlock=DrvLock(dv);
switch (dv->type) {
case DVT_ISO9660:
case DVT_REDSEA:
c+=cnt;
break;
case DVT_FAT32:
while (cnt-->0 && 0<c<0x0FFFFFF8) {
DrvMapBlkSet(dv,c);
c=dv->cur_map_blk[c & (BLK_SIZE/4-1)];
}
if (!(0<c<0x0FFFFFF8))
c=INVALID_CLUSTER;
break;
default:
throw('Drv');
}
if (unlock)
DrvUnlock(dv);
} catch
if (unlock)
DrvUnlock(dv);
return c;
}
I64 Cluster2Blk(CDrv *dv,I64 c)
{//Drv cluster num to blk num.
DrvChk(dv);
switch (dv->type) {
case DVT_REDSEA:
return c;
case DVT_ISO9660:
case DVT_FAT32:
return dv->data_area+c*dv->spc;
default:
throw('Drv');
}
}
I64 RClustersBlks(CDrv *dv,U8 *buf,I64 c,I64 blks)
{//Accepts blk count, so padding on last cluster is not read.
I64 i;
Bool unlock;
DrvChk(dv);
if (blks<=0) return c;
try {
unlock=DrvLock(dv);
switch (dv->type) {
case DVT_ISO9660:
RBlks(dv,buf,dv->data_area+c*dv->spc,blks);
c+=(blks+dv->spc-1)/dv->spc;
break;
case DVT_REDSEA:
RBlks(dv,buf,c,blks);
c+=blks;
break;
case DVT_FAT32:
while (blks && 0<c<0x0FFFFFF8) {
i=blks;
if (i>dv->spc)
i=dv->spc;
RBlks(dv,buf,dv->data_area+c*dv->spc,i);
buf+=i<<BLK_SIZE_BITS;
c=ClusterNumNext(dv,c,1);
blks-=i;
}
if (blks)
throw('Drv');
break;
default:
throw('Drv');
}
if (unlock)
DrvUnlock(dv);
} catch
if (unlock)
DrvUnlock(dv);
return c;
}
I64 RClusters(CDrv *dv,U8 *buf,I64 c,I64 cnt)
{//Read cluster cnt from drv to buf.
return RClustersBlks(dv,buf,c,cnt*dv->spc);
}
Bool CFileNameTo(U8 *dst,U8 *src)
{
MemSet(dst,0,CDIR_FILENAME_LEN);
if (!FileNameChk(src))
return FALSE;
StrCpy(dst,src);
return TRUE;
}
I64 Name2DirCluster(CDrv *dv,U8 *dirname)
{
Bool cont=TRUE,unlock;
I64 cur_dir_cluster;
CDirEntry de;
U8 *buf=StrNew(dirname),*buf2=StrNew(dirname);
DrvChk(dv);
try {
unlock=DrvLock(dv);
cur_dir_cluster=dv->root_cluster;
while (*buf && cont) {
StrFirstRem(buf,"/",buf2);
if (*buf2) {
switch (dv->type) {
case DVT_REDSEA:
cont=RedSeaFileFind(dv,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
break;
case DVT_FAT32:
cont=FAT32FileFind(dv,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
break;
case DVT_ISO9660:
cont=ISO1FileFind(dv,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
break;
default:
throw('Drv');
}
cur_dir_cluster=de.cluster;
}
}
if (!cont) {
"%s ",dirname;
PrintErr("File not found.\n");
cur_dir_cluster=0;
}
if (unlock)
DrvUnlock(dv);
} catch
if (unlock)
DrvUnlock(dv);
Free(buf);
Free(buf2);
return cur_dir_cluster;
}
I64 Name2ParentDirCluster(CDrv *dv,U8 *dirname)
{
Bool cont=TRUE,unlock;
I64 cur_dir_cluster,cur_dir_cluster2;
CDirEntry de;
U8 *buf=StrNew(dirname),*buf2=StrNew(dirname);
DrvChk(dv);
try {
unlock=DrvLock(dv);
cur_dir_cluster=cur_dir_cluster2=dv->root_cluster;
while (*buf && cont) {
cur_dir_cluster2=cur_dir_cluster;
StrFirstRem(buf,"/",buf2);
if (*buf2) {
switch (dv->type) {
case DVT_REDSEA:
cont=RedSeaFileFind(dv,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
break;
case DVT_FAT32:
cont=FAT32FileFind(dv,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
break;
case DVT_ISO9660:
cont=ISO1FileFind(dv,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
break;
default:
throw('Drv');
}
cur_dir_cluster=de.cluster;
}
}
if (!cont) {
"%s ",dirname;
PrintErr("File not found.\n");
cur_dir_cluster2=0;
}
if (unlock)
DrvUnlock(dv);
} catch
if (unlock)
DrvUnlock(dv);
Free(buf);
Free(buf2);
return cur_dir_cluster2;
}
I64 WClustersBlks(CDrv *dv,U8 *buf,I64 c,I64 blks)
{//Accepts blk count, so padding on last cluster is not written.
I64 i;
Bool unlock;
DrvChk(dv);
if (blks<=0) return c;
try {
unlock=DrvLock(dv);
switch (dv->type) {
case DVT_REDSEA:
WBlks(dv,buf,c,blks);
c=0;
break;
case DVT_FAT32:
while (blks) {
if (!(0<c<0x0FFFFFF8))
throw('Drv');
i=blks;
if (i>dv->spc)
i=dv->spc;
WBlks(dv,buf,dv->data_area+c*dv->spc,i);
buf+=i<<BLK_SIZE_BITS;
c=ClusterNumNext(dv,c);
blks-=i;
}
break;
default:
throw('Drv');
}
if (unlock)
DrvUnlock(dv);
} catch
if (unlock)
DrvUnlock(dv);
return c;
}
I64 WClusters(CDrv *dv,U8 *buf,I64 c,I64 cnt)
{//Write cluster cnt from buf to drv.
return WClustersBlks(dv,buf,c,cnt*dv->spc);
}
I64 ClustersAlloc(CDrv *dv,I64 c=0,I64 cnt=1,Bool contiguous=FALSE)
{//Alloc cluster cnt into chain.
//c=0 means first cluster in chain
DrvChk(dv);
if (cnt<=0) return c;
switch (dv->type) {
case DVT_REDSEA:
return RedSeaAllocClusters(dv,cnt);
case DVT_FAT32:
if (contiguous) {
if (c) throw('File');
return FAT32AllocContiguousClusters(dv,cnt);
} else
return FAT32AllocClusters(dv,c,cnt);
default:
throw('Drv');
}
}
Kernel/Dsk/DskATA.CPP
+14 -12
View File
@@ -64,7 +64,8 @@ U0 ATACmd(CBlkDev *bd,U8 cmd)
PortNop;
}
Bool ATAGetResult(CBlkDev *bd,F64 timeout,U8 *buf,I64 cnt,I64 _avail,Bool one_read)
Bool ATAGetResult(CBlkDev *bd,F64 timeout,U8 *buf,I64 cnt,
I64 _avail,Bool one_read)
{
I64 avail,overflow;
bd->flags&=~BDF_LAST_WAS_WRITE;
@@ -152,7 +153,7 @@ Bool ATAPIStartStop(CBlkDev *bd,F64 timeout,Bool start)
else
OutU8(bd->base0+ATAR0_SELECT,0xE0|bd->unit<<4);
ATACmd(bd,ATA_PACKET);
//Start/Stop
//Start/Stop
if (ATAPIWritePktWord(bd,timeout,0x1B00,0,i,0,0,0))
return ATAWaitNotBUSY(bd,timeout);
else
@@ -227,7 +228,7 @@ I64 ATAReadNativeMax(CBlkDev *bd,F64 timeout)
result.u8[3]=InU8(bd->base0+ATAR0_SECT);
result.u8[4]=InU8(bd->base0+ATAR0_LCYL);
result.u8[5]=InU8(bd->base0+ATAR0_HCYL);
if (result>>24==result&0xFFFFFF) {//Kludge to make qemu-kvm work
bd->flags&=~BDF_EXT_SIZE;
result&=0xFFFFFF;
@@ -286,7 +287,7 @@ CATAPITrack *ATAPIReadTrackInfo(CBlkDev *bd,I64 blk)
OutU8(bd->base0+ATAR0_HCYL,sizeof(CATAPITrack)>>8);
ATACmd(bd,ATA_PACKET);
ATAPIWritePktWord(bd,0,0x5200,blk.u16[1],blk.u16[0],
(sizeof(CATAPITrack)&0xFF00)>>8,(sizeof(CATAPITrack)&0x00FF)<<8,0);
(sizeof(CATAPITrack)&0xFF00)>>8,(sizeof(CATAPITrack)&0x00FF)<<8,0);
if (!ATAGetResult(bd,0,result,sizeof(CATAPITrack),0,TRUE)) {
Free(result);
result=NULL;
@@ -334,12 +335,12 @@ Bool ATAPIWaitReady(CBlkDev *bd,F64 timeout)
{
do {
if (!ATAWaitNotBUSY(bd,timeout) ||
!ATANop(bd,timeout) ||
!ATAPIStartStop(bd,timeout,TRUE))
!ATANop(bd,timeout) ||
!ATAPIStartStop(bd,timeout,TRUE))
return FALSE;
if (InU8(bd->base0+ATAR0_STAT) & ATAS_DRDY &&
!InU8(bd->base0+ATAR0_FEAT));
return TRUE;
!InU8(bd->base0+ATAR0_FEAT));
return TRUE;
ATAInit(bd);
Yield;
} while (!(0<timeout<tS));
@@ -351,7 +352,7 @@ U0 ATAReadBlks(CBlkDev *bd,U8 *buf, I64 blk, I64 cnt)
I64 retries=3;
Bool unlock=BlkDevLock(bd);
retry:
retry:
ATABlkSelect(bd,blk,cnt);
if (bd->flags & BDF_EXT_SIZE)
ATACmd(bd,ATA_READ_MULTI_EXT);
@@ -381,7 +382,8 @@ I64 ATAProbe(I64 base0,I64 base1,I64 unit)
return ATAGetDevId(&bd,tS+0.1,NULL);
}
Bool ATAPIReadBlks2(CBlkDev *bd,F64 timeout,U8 *buf, I64 native_blk, I64 cnt,Bool lock)
Bool ATAPIReadBlks2(CBlkDev *bd,F64 timeout,U8 *buf,
I64 native_blk, I64 cnt,Bool lock)
{
Bool result=FALSE,unlock;
if (cnt<=0)
@@ -412,7 +414,7 @@ U0 ATAPIReadBlks(CBlkDev *bd,U8 *buf, I64 blk, I64 cnt)
{
CDrv *dv=Let2Drv(bd->first_drv_let);
I64 retry,spc=bd->blk_size>>BLK_SIZE_BITS,n,blk2,
l2=bd->max_reads<<1+spc<<1;
l2=bd->max_reads<<1+spc<<1;
U8 *cd_buf=MAlloc(l2<<BLK_SIZE_BITS);
if (cnt>0) {
if (blk<=bd->max_reads)
@@ -426,7 +428,7 @@ U0 ATAPIReadBlks(CBlkDev *bd,U8 *buf, I64 blk, I64 cnt)
retry=4;
while (--retry)
if (ATAPIReadBlks2(bd,tS+7.0+0.004*n,cd_buf,blk2/spc,n,TRUE))
//n is 0x800 if max_reads. Up to 8 additional seconds
//n is 0x800 if max_reads. Up to 8 additional seconds
break;
if (!retry)
ATAPIReadBlks2(bd,0,cd_buf,blk2/spc,n,TRUE);
Kernel/Dsk/DskATAId.CPP
+20 -16
View File
@@ -87,7 +87,8 @@ Bool BootCdProbeAll(CBlkDev *bd)
}
}
U0 ATARepEntry(I64 base0,I64 base1,I64 unit,I64 irq,U8 *msg,CATARep **_root,I64 *num_hints)
U0 ATARepEntry(I64 base0,I64 base1,I64 unit,I64 irq,U8 *msg,
CATARep **_root,I64 *num_hints)
{
I64 type;
base0&=-8;
@@ -100,7 +101,8 @@ U0 ATARepEntry(I64 base0,I64 base1,I64 unit,I64 irq,U8 *msg,CATARep **_root,I64
"$$RED$$ATA ";
else
"$$RED$$ATAPI ";
"$$LTBLUE$$%s$$FG$$\nBase0:0x%04X Base1:0x%04X\nIrq:0x%02X Unit:%d$$LM,0$$\n",msg,base0,base1,irq,unit;
"$$LTBLUE$$%s$$FG$$\nBase0:0x%04X Base1:0x%04X\nIrq:0x%02X Unit:%d$$LM,0$$\n",
msg,base0,base1,irq,unit;
if (_root) {
tempha=CAlloc(sizeof(CATARep));
tempha->next=*_root;
@@ -116,7 +118,7 @@ U0 ATARepEntry(I64 base0,I64 base1,I64 unit,I64 irq,U8 *msg,CATARep **_root,I64
Bool ATARepExitAllApplications()
{
"\nWe're going to probe hardware.\n"
"\nWe're going to probe hardware.\n"
"$$RED$$Exit all other applications.$$FG$$\n"
"Press '$$PURPLE$$p$$FG$$' to probe or '$$PURPLE$$s$$FG$$' to skip.\n";
if (ToUpper(GetChar(,FALSE))=='S')
@@ -136,7 +138,7 @@ public I64 ATARep(Bool pmt=TRUE,Bool just_ide=FALSE,CATARep **_root=NULL)
if (pmt && ATARepExitAllApplications)
return 0;
old_preempt=Preempt(OFF);
old_preempt=Preempt;
for (i=0;i<NUM_BLKDEVS;i++)
if (dsk.blkdevs[i].bd_signature==BD_SIGNATURE_VAL)
BEqu(&unlock_flags,i,
@@ -193,13 +195,14 @@ public I64 ATARep(Bool pmt=TRUE,Bool just_ide=FALSE,CATARep **_root=NULL)
return num_hints;
}
CATARep *ATAIDDrvs(CATARep *root,I64 _sys_boot_drv,CATARep **_ata_drv,CATARep **_atapi_drv)
CATARep *ATAIDDrvs(CATARep *root,I64 _sys_boot_drv,
CATARep **_ata_drv,CATARep **_atapi_drv)
{//This is for when trying to sort-out main hard drives and CD-ROM drives.
CATARep *result=NULL,*tempha=root,*ata_drv=NULL,*atapi_drv=NULL;
CBlkDev *bd;
Bool was_silent=Silent;
try
bd=Let2BlkDev(_sys_boot_drv);
bd=Let2BlkDev(_sys_boot_drv);
catch {
Fs->catch_except=TRUE;
bd=NULL;
@@ -208,20 +211,20 @@ CATARep *ATAIDDrvs(CATARep *root,I64 _sys_boot_drv,CATARep **_ata_drv,CATARep **
while (tempha) {
if (!result && bd && bd->type==tempha->type) {
if (bd->type==BDT_ATAPI &&
bd->base0==tempha->base0 && bd->unit==tempha->unit)
bd->base0==tempha->base0 && bd->unit==tempha->unit)
result=atapi_drv=tempha;
else if (bd->type==BDT_ATA && bd->base0==tempha->base0 &&
bd->base1==tempha->base1 && bd->unit==tempha->unit)
bd->base1==tempha->base1 && bd->unit==tempha->unit)
result=ata_drv=tempha;
}
if (!result || result->type!=tempha->type) {
if (tempha->type==BDT_ATA) {
if (!ata_drv || tempha->unit<ata_drv->unit ||
tempha->unit==ata_drv->unit && tempha->num<ata_drv->num)
tempha->unit==ata_drv->unit && tempha->num<ata_drv->num)
ata_drv=tempha;
} else if (tempha->type==BDT_ATAPI) {
if (!atapi_drv || tempha->unit<atapi_drv->unit ||
tempha->unit==atapi_drv->unit && tempha->num<atapi_drv->num)
tempha->unit==atapi_drv->unit && tempha->num<atapi_drv->num)
atapi_drv=tempha;
}
}
@@ -236,7 +239,7 @@ CBlkDev *ATAMount(U8 first_drv_let,I64 type,I64 base0,I64 base1,I64 unit)
{
CBlkDev *result;
if (0<=first_drv_let-'A'<NUM_DRVS && (type==BDT_ATA || type==BDT_ATAPI) &&
0<=unit<=1) {
0<=unit<=1) {
result=BlkDevNextFree(first_drv_let,type);
result->unit=unit;
result->base0=base0;
@@ -250,7 +253,7 @@ CBlkDev *ATAMount(U8 first_drv_let,I64 type,I64 base0,I64 base1,I64 unit)
I64 AutoMountIDE()
{//Try to mount hard drive and CD/DVD, automatically. (Kernel.Cfg option).
//It uses 'C' and 'T' as first drive letters or whatever you set
//in config when compiling Kernel.BIN.
//in config when compiling Kernel.BIN.
I64 result=0;
CATARep *root=NULL,*ata_drv=NULL,*atapi_drv=NULL,*tempha;
ATARep(FALSE,TRUE,&root);
@@ -259,16 +262,17 @@ I64 AutoMountIDE()
ata_drv->base0,ata_drv->base1,ata_drv->unit))
result++;
if (atapi_drv && ATAMount(dsk.first_cd_drv_let,BDT_ATAPI,
atapi_drv->base0,atapi_drv->base1,atapi_drv->unit))
atapi_drv->base0,atapi_drv->base1,atapi_drv->unit))
result++;
tempha=root;
while (tempha) {
if (tempha!=ata_drv && tempha!=atapi_drv) {
if (tempha->type==BDT_ATA && ATAMount(dsk.first_hd_drv_let,BDT_ATA,
tempha->base0,tempha->base1,tempha->unit))
tempha->base0,tempha->base1,tempha->unit))
result++;
else if (tempha->type==BDT_ATAPI && ATAMount(dsk.first_cd_drv_let,BDT_ATAPI,
tempha->base0,tempha->base1,tempha->unit))
else if (tempha->type==BDT_ATAPI &&
ATAMount(dsk.first_cd_drv_let,BDT_ATAPI,
tempha->base0,tempha->base1,tempha->unit))
result++;
}
tempha=tempha->next;
Kernel/Dsk/DskAddDev.CPP
+53 -53
View File
@@ -10,8 +10,8 @@ U0 BlkDevLockFwdingSet(CBlkDev *bd)
for (i=0;i<NUM_BLKDEVS;i++) {
bd1=&dsk.blkdevs[i];
if (bd1->bd_signature==BD_SIGNATURE_VAL && bd!=bd1 &&
(bd1->type==BDT_ATAPI || bd1->type==BDT_ATA) &&
bd1->base0==bd->base0) {
(bd1->type==BDT_ATAPI || bd1->type==BDT_ATA) &&
bd1->base0==bd->base0) {
bd->lock_fwding=bd1;
break;
}
@@ -39,12 +39,12 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
dv->dv_signature=DRV_SIGNATURE_VAL;
dv->type=DVT_REDSEA;
//This is to force creation of a RAM
//drive during boot, so it is probably
//MAlloced to the same addr and can
//be assumed to be already formatted.
//If this line is removed, RAM Drives
//will be alloced on a just-in-time
//basis.
//drive during boot, so it is probably
//MAlloced to the same addr and can
//be assumed to be already formatted.
//If this line is removed, RAM Drives
//will be alloced on a just-in-time
//basis.
if (BlkDevInit(bd))
result++;
else
@@ -61,7 +61,7 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
result++;
dv->type=DVT_REDSEA;
dv->size=bd->max_blk+1;
//The following read is a test read.
//The following read is a test read.
//if it hangs, the drive is not supported.
ATAReadBlks(bd,&mbr,0,1);
break;
@@ -174,24 +174,24 @@ U0 Mount(Bool repartition=FALSE)
{//Mount a drive.
CBlkDev *bd;
I64 first_drv_num,type,unit,num_hints;
U8 blks_buf[128],addr_buf[128],base0_buf[128],base1_buf[128];
U8 blks_buf[STR_LEN],addr_buf[STR_LEN],base0_buf[STR_LEN],base1_buf[STR_LEN];
Bool add;
CATARep *root,*tempha;
do {
DrvRep;
"\n****** Mount Drives ******\n"
"The first drive letter is the letter\n"
"of the first partition. If adding\n"
"a hard drive, you should pick 'C'.\n"
"If more than one partition is present\n"
"they will be lettered in sequence.\n"
"\nFirst Drive Letter ($$PURPLE$$<ENTER>$$FG$$ to exit):";
"\n****** Mount Drives ******\n"
"The first drive letter is the letter\n"
"of the first partition. If adding\n"
"a hard drive, you should pick 'C'.\n"
"If more than one partition is present\n"
"they will be lettered in sequence.\n"
"\nFirst Drive Letter ($$PURPLE$$<ENTER>$$FG$$ to exit):";
first_drv_num=ToUpper(GetChar)-'A';
'\n';
if (0<=first_drv_num<NUM_DRVS) {
"\t$$PURPLE$$1$$FG$$=RAM\n\t$$PURPLE$$2$$FG$$=ATA(Harddisk)\n"
"\t$$PURPLE$$3$$FG$$=ATAPI(CD-ROM)\nType:";
"\t$$PURPLE$$1$$FG$$=RAM\n\t$$PURPLE$$2$$FG$$=ATA(Harddisk)\n"
"\t$$PURPLE$$3$$FG$$=ATAPI(CD-ROM)\nType:";
type=GetChar-'0';
'\n';
@@ -200,11 +200,11 @@ U0 Mount(Bool repartition=FALSE)
num_hints=ATARep(,,&root);
do {
if (num_hints)
"Enter dev number or\nport with $$PURPLE$$0x$$FG$$ prefix.\n"
"I/O Port Base0:\n";
"Enter dev number or\nport with $$PURPLE$$0x$$FG$$ prefix.\n"
"I/O Port Base0:\n";
else
"Include $$PURPLE$$0x$$FG$$ prefix.\nI/O Port Base0:\n";
GetS(base0_buf,128);
"Include $$PURPLE$$0x$$FG$$ prefix.\nI/O Port Base0:\n";
GetS(base0_buf,STR_LEN);
} while (!Str2I64(base0_buf));
if (1<=Str2I64(base0_buf)<=num_hints) {
tempha=ATARepFind(root,Str2I64(base0_buf));
@@ -216,11 +216,11 @@ U0 Mount(Bool repartition=FALSE)
StrCpy(base1_buf,"0");
else
do {
"I/O Port Base1:\n";
GetS(base1_buf,128);
"I/O Port Base1:\n";
GetS(base1_buf,STR_LEN);
} while (!Str2I64(base1_buf));
do {
"\t$$PURPLE$$0$$FG$$=Master\n\t$$PURPLE$$1$$FG$$=Slave\nUnit:";
"\t$$PURPLE$$0$$FG$$=Master\n\t$$PURPLE$$1$$FG$$=Slave\nUnit:";
unit=GetChar-'0';
} while (!(0<=unit<=1));
'\n';
@@ -229,9 +229,9 @@ U0 Mount(Bool repartition=FALSE)
}
if (type==BDT_RAM) {
"Addr of RAM disk ($$PURPLE$$<ENTER>$$FG$$ to MAlloc):";
GetS(addr_buf,128);
GetS(addr_buf,STR_LEN);
"Blks of 512 bytes:";
GetS(blks_buf,128);
GetS(blks_buf,STR_LEN);
}
if (BDT_NULL<type<BDT_NUM_TYPES && 0<=unit<=1) {
@@ -243,7 +243,7 @@ U0 Mount(Bool repartition=FALSE)
bd->max_blk=Str2I64(blks_buf)-1;
}
if (type==BDT_ATA ||
type==BDT_ATAPI) {
type==BDT_ATAPI) {
bd->base0=Str2I64(base0_buf);
bd->base1=Str2I64(base1_buf);
}
@@ -268,8 +268,8 @@ U0 Mount(Bool repartition=FALSE)
I64 SysGetI64()
{
U8 st[136];
GetS(st,136,FALSE);
U8 st[STR_LEN];
GetS(st,STR_LEN,FALSE);
return Str2I64(st,16);
}
@@ -278,22 +278,22 @@ Bool GetBaseUnit(CBlkDev *bd)
I64 ch;
Bool probe;
" TempleOS\n\n\n";
#exe {
if (kernel_cfg->opts[CFG_DONT_PROBE])
StreamPrint("probe=FALSE;");
else
StreamPrint("probe=TRUE;");
};
#exe {
if (kernel_cfg->opts[CFG_DONT_PROBE])
StreamPrint("probe=FALSE;");
else
StreamPrint("probe=TRUE;");
};
if (!probe || !BootCdProbeAll(bd)) {
"\nDon't worry. This is not a product\n"
"registration. TempleOS just needs the\n"
"I/O port numbers for the CD-ROM.\n"
"\nRetry the ports above or check Windows\n"
"system information under I/O ports for\n"
"'IDE', 'ATA' or 'SATA'.\n"
"In Linux, use 'lspci -v' for ports.\n"
"\n\nEnter 4-digit hex I/O Port number.\n"
"CD-ROM I/O Port Base0: 0x";
"\nDon't worry. This is not a product\n"
"registration. TempleOS just needs the\n"
"I/O port numbers for the CD-ROM.\n"
"\nRetry the ports above or check Windows\n"
"system information under I/O ports for\n"
"'IDE', 'ATA' or 'SATA'.\n"
"In Linux, use 'lspci -v' for ports.\n"
"\n\nEnter 4-digit hex I/O Port number.\n"
"CD-ROM I/O Port Base0: 0x";
bd->base0=SysGetI64;
bd->base1=0;
bd->unit =0;
@@ -322,12 +322,12 @@ U0 BlkDevsInitAll()
for (i=0;i<NUM_DRVS;i++)
dsk.let_to_drv[i]=&dsk.drvs[i];
text.raw_col=0;
#exe {
if (kernel_cfg->opts[CFG_AUTO_MOUNT_IDE])
StreamPrint("AutoMountIDE;");
StreamPrint("#exe {OptOff(OPTf_WARN_PAREN);}");
StreamDoc(kernel_cfg->add_dev);
StreamPrint("#exe {OptOn(OPTf_WARN_PAREN);}");
};
#exe {
if (kernel_cfg->opts[CFG_AUTO_MOUNT_IDE])
StreamPrint("AutoMountIDE;");
StreamPrint("#exe {OptOff(OPTf_WARN_PAREN);}");
StreamDoc(kernel_cfg->add_dev);
StreamPrint("#exe {OptOn(OPTf_WARN_PAREN);}");
};
DrvRep;
}
Kernel/Dsk/DskB.CPP
-487
View File
@@ -1,487 +0,0 @@
Bool MapDrv(U8 drv_let,CDrv *dv)
{//Make drive letter map to another.
drv_let=ToUpper(drv_let);
if ('A'<=drv_let<='Z') {
dsk.let_to_drv[drv_let-'A']=dv;
dv->drv_let=drv_let;
return TRUE;
} else
return FALSE;
}
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);
if (dv!=Fs->cur_dv) {
if (bd->flags & BDF_REMOVABLE && !(bd->flags & BDF_INITIALIZED))
ChgDsk(Drv2Let(dv));
if (bd->type==BDT_RAM)
BlkDevInit(bd);
}
Fs->cur_dv=dv;
Free(Fs->cur_dir);
Fs->cur_dir=StrNew("/");
switch (dv->type) {
case DVT_REDSEA:
case DVT_FAT32:
case DVT_ISO9660:
return TRUE;
default:
PrintErr("File System Not Supported\n");
return FALSE;
}
}
Bool Cd(U8 *dirname=NULL,Bool make_dirs=FALSE)
{//Change directory. Optionally, make directories, too.
I64 maxlen,cur_dir_cluster=0;
U8 *chg_to_buf,*new_cur_dir,*buf;
CDrv *dv;
Bool result=TRUE;
if (!dirname)
dirname="::/Home";
else if (!*dirname)
return TRUE;
if (dirname[1]==':') {
if (*dirname==':') {
if (Fs->cur_dv!=Let2Drv(':') && !Drv(*dirname))
return FALSE;
} else if (Fs->cur_dv!=Let2Drv(*dirname) && !Drv(*dirname))
return FALSE;
dirname+=2;
}
if (*dirname=='/' || !*dirname || !Fs->cur_dir) {
Free(Fs->cur_dir);
Fs->cur_dir=StrNew("/");
if (*dirname=='/')
dirname++;
}
chg_to_buf=MStrUtil(dirname,SUF_REM_LEADING|SUF_REM_TRAILING|SUF_REM_CTRL_CHARS);
maxlen=StrLen(Fs->cur_dir)+1+StrLen(chg_to_buf)+1;
new_cur_dir=MAlloc(maxlen);
buf=MAlloc(maxlen);
StrCpy(new_cur_dir,Fs->cur_dir);
while (*chg_to_buf && result) {
StrFirstRem(chg_to_buf,"/",buf);
if (!*buf)
StrCpy(new_cur_dir,"/");
else if (!StrCmp(buf,"..")) {
StrLastRem(new_cur_dir,"/");
if (!*new_cur_dir)
StrCpy(new_cur_dir,"/");
} else if (StrCmp(buf,".") && *buf) {
dv=Fs->cur_dv;
cur_dir_cluster=Name2DirCluster(dv,new_cur_dir);
switch (dv->type) {
case DVT_REDSEA:
result=RedSeaCd(buf,cur_dir_cluster);
break;
case DVT_FAT32:
result=FAT32Cd(buf,cur_dir_cluster);
break;
case DVT_ISO9660:
result=ISO1Cd(buf,cur_dir_cluster);
break;
default:
PrintErr("File System Not Supported\n");
result=FALSE;
}
if (!result && make_dirs) {
Free(Fs->cur_dir);
Fs->cur_dir=StrNew(new_cur_dir);
result=MkDir(buf);
}
if (result) {
if (StrCmp(new_cur_dir,"/"))
CatPrint(new_cur_dir,"/");
CatPrint(new_cur_dir,buf);
}
}
}
Free(Fs->cur_dir);
Fs->cur_dir=StrNew(new_cur_dir);
Free(buf);
Free(chg_to_buf);
Free(new_cur_dir);
return result;
}
U0 FileAccessDel(CFileAccess *fa)
{//Change back to old cur_dir and drv.
CBlkDev *bd;
if (!fa) return;
bd=fa->old_dv->bd;
if (!(bd->flags & BDF_INIT_IN_PROGRESS)) {
if (fa->old_dir) {
Drv(Drv2Let(fa->old_dv));
Cd(fa->old_dir);
}
} else {
Fs->cur_dv=fa->old_dv;
Free(Fs->cur_dir);
Fs->cur_dir=StrNew("/");
}
Free(fa->old_dir);
Free(fa->mask);
Free(fa);
}
CFileAccess *FileAccessNew(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;
CFileAccess *fa=CAlloc(sizeof(CFileAccess));
mask=MStrUtil(_mask,SUF_REM_LEADING|SUF_REM_TRAILING|SUF_REM_CTRL_CHARS);
temp_mask=mask;
fa->old_dir=StrNew(Fs->cur_dir);
fa->old_dv=Fs->cur_dv;
if (*mask && mask[1]==':') {
if (Fs->cur_dv!=Let2Drv(*mask) && !Drv(*mask))
valid=FALSE;
mask+=2;
}
fa->dv=Fs->cur_dv;
DrvChk(fa->dv);
buf=MAlloc(StrLen(mask)+2);
StrCpy(buf,mask);
fa->mask=MAlloc(StrLen(mask)+2);
if (no_mask)
*fa->mask=0;
else
StrLastRem(buf,"/",fa->mask);
if (*mask=='/' && !*buf)
StrCpy(buf,"/");
//If began with Dir, change to Dir.
if (*buf && !Cd(buf,make_dirs))
valid=FALSE;
if (valid && make_mask) {
if (!*fa->mask) {
Free(fa->mask);
fa->mask=StrNew("*");
} else {
if (!make_dirs || FileNameChk(fa->mask)) {
old_silent=Silent;
//Try mask to see if Dir. If Dir, change to dir and set to "*".
if (Cd(fa->mask,make_dirs)) {
Free(fa->mask);
fa->mask=StrNew("*");
}
Silent(old_silent);
}
}
}
Free(buf);
Free(temp_mask);
if (!valid) {
FileAccessDel(fa);
fa=NULL;
}
return fa;
}
CDirEntry *FilesFind(U8 *files_find_mask,I64 fuf_flags=0)
{/* See $LK,"::/Doc/FileUtils.TXT"$.
Find files and make a directory tree in memory.
When done, you free with $LK,"DirEntryDel",A="MN:DirEntryDel"$(),$LK,"DirEntryDel2",A="MN:DirEntryDel2"$(),
$LK,"DirTreeDel",A="MN:DirTreeDel"$() or $LK,"DirTreeDel2",A="MN:DirTreeDel2"$().
*/
CDirEntry *result;
CFileAccess *fa;
if (fuf_flags&~FUG_FILES_FIND)
throw('FUF');
if (fuf_flags&FUF_SINGLE) {
result=MAlloc(sizeof(CDirEntry));
if (!FileFind(files_find_mask,result)) {
Free(result);
return NULL;
}
} else if (fa=FileAccessNew(files_find_mask,TRUE)) {
result=SysFilesFind(fa->mask,fuf_flags);
FileAccessDel(fa);
} else
return NULL;
return result;
}
Bool IsDir(U8 *dir_name)
{//Is a str a valid, existing Dir?
U8 *mask=MStrPrint("%s/*",dir_name);
Bool result,old_silent=Silent;
CFileAccess *fa;
if (fa=FileAccessNew(mask)) {
FileAccessDel(fa);
result=TRUE;
} else
result=FALSE;
Free(mask);
Silent(old_silent);
return result;
}
I64 Dir(U8 *files_find_mask="*",Bool full=FALSE)
{//List directory.
I64 result;
CFileAccess *fa;
if (fa=FileAccessNew(files_find_mask,TRUE)) {
result=Dir2(fa->mask,0,full);
FileAccessDel(fa);
return result;
} else
return 0;
}
I64 Del(U8 *files_find_mask,Bool print_msg=TRUE)
{//Delete files.
I64 result=0;
CFileAccess *fa;
if (fa=FileAccessNew(files_find_mask)) {
switch (fa->dv->type) {
case DVT_REDSEA:
result=RedSeaFilesDel(fa->dv,Fs->cur_dir,fa->mask,0,FALSE,print_msg);
break;
case DVT_FAT32:
result=FAT32FilesDel(fa->dv,Fs->cur_dir,fa->mask,0,FALSE,print_msg);
break;
case DVT_ISO9660:
PrintErr("Not Writable\n");
break;
default:
PrintErr("File System Not Supported\n");
}
FileAccessDel(fa);
}
return result;
}
U8 *FileRead(U8 *filename,I64 *_size=NULL,I64 *_attr=NULL)
{//Read whole file from disk.
CHashGeneric *temph;
U8 *absname,*altname,*curname,*result=NULL;
I64 i,size=0,attr=0;
CFileAccess *fa;
CArcCompress *ac;
absname=FileNameAbs(filename);
altname=ToggleZorNotZ(absname);
if ((temph=HashFind(absname,adam_task->hash_table,HTT_FILE))||
(temph=HashFind(altname,adam_task->hash_table,HTT_FILE))) {
size=temph->user_data1;
result=MAlloc(size+1);
MemCpy(result,temph->user_data0,size);
result[size]=0; //Terminate
attr=FileAttr(temph->str,attr);
} else {
for (i=0;i<2 && !result;i++) {//Try name, then altname
if (!i)
curname=absname;
else
curname=altname;
if (fa=FileAccessNew(curname)) {
switch (fa->dv->type) {
case DVT_REDSEA:
result=RedSeaFileRead(fa->dv,Fs->cur_dir,fa->mask,&size,&attr);
break;
case DVT_FAT32:
result=FAT32FileRead(fa->dv,Fs->cur_dir,fa->mask,&size,&attr);
break;
case DVT_ISO9660:
result=ISO1FileRead(fa->dv,Fs->cur_dir,fa->mask,&size,&attr);
break;
default:
PrintErr("File System Not Supported\n");
}
FileAccessDel(fa);
}
}
//Search parent directories.
for (i=0;i<2 && !result;i++) {//Try name, then altname
if (!i)
curname=absname;
else
curname=altname;
if (fa=FileAccessNew(curname)) {
while (!result && StrCmp(Fs->cur_dir,"/")) {
Cd("..");
switch (Fs->cur_dv->type) {
case DVT_REDSEA:
result=RedSeaFileRead(fa->dv,Fs->cur_dir,fa->mask,&size,&attr);
break;
case DVT_FAT32:
result=FAT32FileRead(fa->dv,Fs->cur_dir,fa->mask,&size,&attr);
break;
case DVT_ISO9660:
result=ISO1FileRead(fa->dv,Fs->cur_dir,fa->mask,&size,&attr);
break;
default:
PrintErr("File System Not Supported\n");
}
}
FileAccessDel(fa);
}
}
if (!result) {
"%s ",filename;
PrintErr("File not found.\n");
}
if (result && attr & RS_ATTR_RESIDENT)
HashGenericAdd(curname,HTT_FILE,AMAllocIdentical(result),size,0,adam_task);
}
if (result && attr & RS_ATTR_COMPRESSED) {
ac=result;
size=ac->expanded_size;
result=ExpandBuf(ac);
Free(ac);
}
if (_attr) *_attr=attr;
if (_size) *_size=size;
Free(absname);
Free(altname);
return result;
}
Bool FileFind(U8 *filename,CDirEntry *_de=NULL,I64 fuf_flags=0)
{//$LK,"FUF_JUST_DIRS",A="MN:FUF_JUST_DIRS"$, $LK,"FUF_JUST_FILES",A="MN:FUF_JUST_FILES"$, $LK,"FUF_Z_OR_NOT_Z",A="MN:FUF_Z_OR_NOT_Z"$, $LK,"FUF_SCAN_PARENTS",A="MN:FUF_SCAN_PARENTS"$
//If you pass _de, you must Free(_de->full_name);
I64 i,j,cur_dir_cluster;
U8 *altname,*curname,*full_name=NULL;
CDirEntry de;
CFileAccess *fa;
Bool result=FALSE,old_silent;
if (fuf_flags&~FUG_FILE_FIND)
throw('FUF');
if (!filename) return FALSE;
altname=ToggleZorNotZ(filename);
if (fuf_flags&FUF_Z_OR_NOT_Z)
j=2;
else
j=1;
for (i=0;i<j && !result;i++) {
if (!i)
curname=filename;
else
curname=altname;
old_silent=Silent;
if (!(fa=FileAccessNew(curname)))
Silent(old_silent);
else {
Silent(old_silent);
cur_dir_cluster=Name2DirCluster(fa->dv,Fs->cur_dir);
switch (fa->dv->type) {
case DVT_REDSEA:
result=RedSeaFileFind(fa->dv,cur_dir_cluster,fa->mask,&de,fuf_flags);
break;
case DVT_FAT32:
result=FAT32FileFind(fa->dv,cur_dir_cluster,fa->mask,&de,fuf_flags);
break;
case DVT_ISO9660:
result=ISO1FileFind(fa->dv,cur_dir_cluster,fa->mask,&de,fuf_flags);
break;
default:
PrintErr("File System Not Supported\n");
}
if (result && _de) {
if (StrCmp(Fs->cur_dir,"/"))
full_name=MStrPrint("%C:%s/%s",Drv2Let(Fs->cur_dv),Fs->cur_dir,de.name);
else
full_name=MStrPrint("%C:/%s",Drv2Let(Fs->cur_dv),de.name);
}
FileAccessDel(fa);
}
}
for (i=0;i<j && !result && fuf_flags&FUF_SCAN_PARENTS;i++) {
if (!i)
curname=filename;
else
curname=altname;
old_silent=Silent;
if (!(fa=FileAccessNew(curname)))
Silent(old_silent);
else {
Silent(old_silent);
cur_dir_cluster=Name2DirCluster(fa->dv,Fs->cur_dir);
while (!result && StrCmp(Fs->cur_dir,"/")) {
Cd("..");
cur_dir_cluster=Name2DirCluster(fa->dv,Fs->cur_dir);
switch (fa->dv->type) {
case DVT_REDSEA:
result=RedSeaFileFind(fa->dv,cur_dir_cluster,fa->mask,&de,fuf_flags);
break;
case DVT_FAT32:
result=FAT32FileFind(fa->dv,cur_dir_cluster,fa->mask,&de,fuf_flags);
break;
case DVT_ISO9660:
result=ISO1FileFind(fa->dv,cur_dir_cluster,fa->mask,&de,fuf_flags);
break;
default:
PrintErr("File System Not Supported\n");
}
}
if (result && _de) {
if (StrCmp(Fs->cur_dir,"/"))
full_name=MStrPrint("%C:%s/%s",Drv2Let(Fs->cur_dv),Fs->cur_dir,de.name);
else
full_name=MStrPrint("%C:/%s",Drv2Let(Fs->cur_dv),de.name);
}
FileAccessDel(fa);
}
}
if (_de) {
if (result) {
MemCpy(_de,&de,sizeof(CDirEntry));
_de->full_name=full_name;
} else
MemSet(_de,0,sizeof(CDirEntry));
}
Free(altname);
return result;
}
I64 FileWrite(U8 *filename,U8 *fbuf,
I64 size,CDate cdt=0,I64 attr=0)
{//Write whole file to disk.
I64 c=0;
CHashGeneric *temph;
CFileAccess *fa;
U8 *fbuf2,*absname=FileNameAbs(filename);
if (fa=FileAccessNew(filename,FALSE,TRUE)) {
attr=FileAttr(fa->mask,attr);
if (attr&RS_ATTR_COMPRESSED) {
fbuf=CompressBuf(fbuf,size);
size=fbuf(CArcCompress *)->compressed_size;
fbuf2=fbuf;
} else
fbuf2=NULL;
if (!cdt) cdt=Now;
switch (fa->dv->type) {
case DVT_REDSEA:
c=RedSeaFileWrite(fa->dv,Fs->cur_dir,fa->mask,fbuf,size,cdt,attr);
break;
case DVT_FAT32:
c=FAT32FileWrite(fa->dv,Fs->cur_dir,fa->mask,fbuf,size,cdt,attr);
break;
case DVT_ISO9660:
PrintErr("Not Writable\n");
break;
default:
PrintErr("File System Not Supported\n");
}
if (temph=HashFind(absname,adam_task->hash_table,HTT_FILE)) {
if (attr & RS_ATTR_RESIDENT) {
Free(temph->user_data0);
temph->user_data0=AMAllocIdentical(fbuf);
temph->user_data1=size;
} else
HashRemDel(temph,adam_task->hash_table);
} else if (attr & RS_ATTR_RESIDENT)
HashGenericAdd(absname,HTT_FILE,AMAllocIdentical(fbuf),size,0,adam_task);
Free(fbuf2);
FileAccessDel(fa);
}
Free(absname);
return c;
}
Kernel/Dsk/DskBlk.CPP
+102
View File
@@ -0,0 +1,102 @@
#define ZERO_BUF_SIZE 2048
U0 WZeroBlks(CDrv *dv,I64 blk,I64 cnt)
{//Fill blk cnt with zeros in Drv.
I64 n;
U8 *z=CAlloc(ZERO_BUF_SIZE<<BLK_SIZE_BITS);
Bool show_progress;
if (cnt>ZERO_BUF_SIZE && dv->bd->type!=BDT_RAM) {
progress1=0; progress1_max=cnt;
StrCpy(progress1_desc,"Zeroing");
show_progress=TRUE;
} else
show_progress=FALSE;
while (cnt>0) {
n=cnt;
if (n>ZERO_BUF_SIZE)
n=ZERO_BUF_SIZE;
WBlks(dv,z,blk,n);
blk+=n;
cnt-=n;
if (show_progress)
progress1+=n;
Yield; //Prevent locking
}
Free(z);
if (show_progress) {
*progress1_desc=0;
progress1=progress1_max=0;
}
}
Bool RBlks(CDrv *dv,U8 *buf, I64 blk, I64 cnt)
{//Read blk cnt from Drv to buf.
Bool result=TRUE,unlock;
CBlkDev *bd=dv->bd;
if (cnt<=0) return TRUE;
DrvChk(dv);
try {
unlock=DrvLock(dv);
BlkDevInit(bd);
if (dv->base_offset && blk<dv->base_offset ||
blk+cnt>dv->base_offset+dv->size)
throw('Drv');
if (bd->flags & BDF_READ_CACHE)
RCache(dv,&buf,&blk,&cnt);
if (cnt>0) {
switch (bd->type) {
case BDT_RAM:
MemCpy(buf,bd->RAM_dsk+blk<<BLK_SIZE_BITS,cnt<<BLK_SIZE_BITS);
break;
case BDT_ATA:
case BDT_ATAPI:
result=ATARBlks(dv,buf,blk,cnt);
break;
}
bd->last_time=tS;
if (bd->flags & BDF_READ_CACHE)
DskCacheAdd(dv,buf,blk,cnt);
}
if (unlock)
DrvUnlock(dv);
} catch
if (unlock)
DrvUnlock(dv);
return result;
}
Bool WBlks(CDrv *dv,U8 *buf, I64 blk, I64 cnt)
{//Write blk cnt from buf to Drv.
Bool result=TRUE,unlock;
CBlkDev *bd=dv->bd;
if (cnt<=0) return TRUE;
DrvChk(dv);
try {
unlock=DrvLock(dv);
BlkDevInit(bd);
if (bd->flags&BDF_READ_ONLY && !(bd->flags & BDF_READ_ONLY_OVERRIDE))
throw('BlkDev');
if (dv->base_offset && blk<dv->base_offset ||
blk+cnt>dv->base_offset+dv->size)
throw('Drv');
if (cnt>0) {
switch (bd->type) {
case BDT_RAM:
MemCpy(bd->RAM_dsk+blk<<BLK_SIZE_BITS,buf,cnt<<BLK_SIZE_BITS);
break;
case BDT_ATA:
case BDT_ATAPI:
result=ATAWBlks(dv,buf,blk,cnt);
break;
}
bd->last_time=tS;
if (bd->flags & BDF_READ_CACHE)
DskCacheAdd(dv,buf,blk,cnt);
}
if (unlock)
DrvUnlock(dv);
} catch
if (unlock)
DrvUnlock(dv);
return result;
}
Kernel/Dsk/DskBlkDev.CPP
+134
View File
@@ -0,0 +1,134 @@
Bool BlkDevLock(CBlkDev *bd)
{//Make this task have exclusive access to BlkDev.
BlkDevChk(bd);
while (bd->lock_fwding)
bd=bd->lock_fwding; //If two blkdevs on same controller, use just one lock
if (!Bt(&bd->locked_flags,BDlf_LOCKED) || bd->owning_task!=Fs) {
while (LBts(&bd->locked_flags,BDlf_LOCKED))
Yield;
bd->owning_task=Fs;
return TRUE;
} else
return FALSE;
}
Bool BlkDevUnlock(CBlkDev *bd,Bool rst=FALSE)
{//Release exclusive lock on access to BlkDev.
BlkDevChk(bd);
while (bd->lock_fwding)
bd=bd->lock_fwding; //If two blkdevs on same controller, use just one lock
if (Bt(&bd->locked_flags,BDlf_LOCKED) && bd->owning_task==Fs) {
if (rst)
bd->flags&=~(BDF_INITIALIZED|BDF_INIT_IN_PROGRESS);
bd->owning_task=NULL;
LBtr(&bd->locked_flags,BDlf_LOCKED);
Yield; //Prevent deadlock
return TRUE;
} else
return FALSE;
}
Bool BlkDevInit(CBlkDev *bd)
{
CDrv *dv=Let2Drv(bd->first_drv_let);
Bool old_preempt=Preempt,result=FALSE;
if (!LBts(&bd->flags,BDf_INITIALIZED)) {
bd->flags|=BDF_INIT_IN_PROGRESS;
switch(bd->type) {
case BDT_RAM:
if (!bd->RAM_dsk) {
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->size=bd->max_blk+1;
if (RedSeaDrvValidate(bd->first_drv_let))
RedSeaDrvInit(dv);
else
RedSeaFmt(bd->first_drv_let);
result=TRUE;
break;
case BDT_ATA:
bd->max_reads=128;
bd->max_writes=1;
result=ATAInit(bd);
break;
case BDT_ATAPI:
//0xFFFF*4 is too big for my taste
bd->max_reads=0x800*4;
//max of maybe a quarter of disk cache
if (bd->max_reads>dsk.cache_size/BLK_SIZE/4)
bd->max_reads=dsk.cache_size/BLK_SIZE/4 & ~3;
if (bd->max_reads<128)
bd->max_reads=128;
bd->max_writes=0xFFFF*4;
if (result=ATAInit(bd))
dv->size=bd->max_blk+1;
break;
}
if (result && bd->flags & BDF_READ_CACHE)
DskCacheInvalidate(dv);
bd->flags&=~BDF_INIT_IN_PROGRESS;
} else
result=TRUE;
Preempt(old_preempt);
return result;
}
U0 BlkDevsRelease()
{//When task dies, release all owned BlkDevs.
I64 i;
CBlkDev *bd;
for (i=0;i<NUM_BLKDEVS;i++) {
bd=&dsk.blkdevs[i];
if (bd->owning_task==Fs && bd->bd_signature==BD_SIGNATURE_VAL)
BlkDevUnlock(bd,TRUE);
}
}
CBlkDev *BlkDevNextFree(U8 first_drv_let,I64 type)
{//Locate free slot for new BlkDev, like during $LK,"Mount",A="MN:Mount"$().
I64 i=0;
CBlkDev *result;
do {
result=&dsk.blkdevs[i];
if (result->bd_signature!=BD_SIGNATURE_VAL) {
MemSet(result,0,sizeof(CBlkDev));
result->first_drv_let=first_drv_let;
result->type=type;
if (type==BDT_ATAPI)
result->flags=BDF_REMOVABLE;
else
result->flags=0;
if (type!=BDT_RAM)
result->flags|=BDF_READ_CACHE;
if (type==BDT_ATAPI) {
result->blk_size=CD_BLK_SIZE;
result->flags|=BDF_READ_ONLY;
} else
result->blk_size=BLK_SIZE;
result->max_blk=0xEFFFFFFF;
return result;
}
} while (++i<NUM_BLKDEVS);
throw('BlkDev');
return NULL; //never gets here
}
U0 BlkDevChk(CBlkDev *bd)
{//Check for valid BlkDev. Throw exception.
if (!bd || bd->bd_signature!=BD_SIGNATURE_VAL ||
!(BDT_NULL<bd->type<BDT_NUM_TYPES))
throw('BlkDev');
}
CBlkDev *Let2BlkDev(U8 drv_let=0)
{//Drv letter to BlkDev ptr.
CDrv *dv=Let2Drv(drv_let);
CBlkDev *bd=dv->bd;
BlkDevChk(bd);
return bd;
}
Kernel/Dsk/DskC.CPP
-363
View File
@@ -1,363 +0,0 @@
Bool CopySingleZ(U8 *f1,U8 *f2) //Just one file
{
U8 *file_buf=NULL;
I64 size,attr=0,c;
CDirEntry de;
if (FileFind(f1,&de,FUF_JUST_FILES)) {
Free(de.full_name);
file_buf=FileRead(f1,&size,&attr);
attr=FileAttr(f2,attr);
if (file_buf) {
"Copying %s to %s\n",f1,f2;
c=FileWrite(f2,file_buf,size,de.datetime,attr);
Free(file_buf);
return ToBool(c);
} else
PrintErr("File not found.\n");
} else
PrintErr("File not found.\n");
return FALSE;
}
#define COPY_BUF_BLKS 0x80
Bool CopySingle(U8 *f1,U8 *f2) //Just one file
{
U8 *absf1=FileNameAbs(f1),*absf2=FileNameAbs(f2),*buf;
I64 cnt,n,size,attr1=FileAttr(f1),attr2=FileAttr(f2),i,j;
CFile *in_file=NULL,*out_file=NULL;
if (!StrCmp(absf1,absf2)) {//onto self?
Free(absf1);
Free(absf2);
return FALSE;
}
Free(absf1);
Free(absf2);
if (attr1!=attr2)
return CopySingleZ(f1,f2);
buf=MAlloc(COPY_BUF_BLKS<<BLK_SIZE_BITS);
if (attr1 & RS_ATTR_CONTIGUOUS)
in_file=FOpen(f1,"rc");
else
in_file=FOpen(f1,"r");
if (in_file) {
size=FSize(in_file);
cnt=(size+BLK_SIZE-1)>>BLK_SIZE_BITS;
if (attr2 & RS_ATTR_CONTIGUOUS)
out_file=FOpen(f2,"wc",cnt);
else
out_file=FOpen(f2,"w",cnt);
if (out_file) {
"Copying %s to %s\n",f1,f2;
j=size;
while (cnt>0) {
if (cnt>COPY_BUF_BLKS) {
n=COPY_BUF_BLKS;
i=n<<BLK_SIZE_BITS;
} else {
n=cnt;
i=j;
}
FRBlks(in_file, buf,FFB_NEXT_BLK,n);
FWBlks(out_file,buf,FFB_NEXT_BLK,n);
cnt-=n;
j-=n<<BLK_SIZE_BITS;
}
out_file->flags|=FF_USE_OLD_DATETIME;
out_file->de.datetime=in_file->de.datetime;
out_file->de.size=size;
out_file->de.attr=FileAttr(f2,in_file->de.attr);
FClose(out_file);
FClose(in_file);
Free(buf);
return TRUE;
} else
PrintErr("File not found.\n");
FClose(in_file);
} else
PrintErr("File not found.\n");
Free(buf);
return FALSE;
}
Bool MkDir(U8 *filename)
{//Make directory. $LK,"Cd",A="MN:Cd"$() can also make directories.
U8 *name;
CFileAccess *fa;
Bool result=FALSE;
if (FileFind(filename,,FUF_JUST_DIRS))
return FALSE;
if (fa=FileAccessNew(filename)) {
if (*fa->mask) {
if (!FileNameChk(fa->mask))
PrintErr("Invalid FileName.\n");
else {
"Make Directory:%s\n",filename;
name=MStrUtil(fa->mask,SUF_REM_LEADING|SUF_REM_TRAILING|SUF_REM_CTRL_CHARS);
switch (fa->dv->type) {
case DVT_REDSEA:
result=RedSeaMkDir(fa->dv,Fs->cur_dir,name);
break;
case DVT_FAT32:
result=FAT32MkDir(fa->dv,Fs->cur_dir,name);
break;
case DVT_ISO9660:
PrintErr("Not Writable\n");
break;
default:
PrintErr("File System Not Supported\n");
}
Free(name);
}
}
FileAccessDel(fa);
}
return result;
}
I64 SysDel(U8 *wild,Bool make_mask) //this is dangerous
{
I64 result=0;
CFileAccess *fa;
if (fa=FileAccessNew(wild,make_mask)) {
switch (fa->dv->type) {
case DVT_REDSEA:
result=RedSeaFilesDel(fa->dv,Fs->cur_dir,fa->mask,0,TRUE,TRUE);
break;
case DVT_FAT32:
result=FAT32FilesDel(fa->dv,Fs->cur_dir,fa->mask,0,TRUE,TRUE);
break;
case DVT_ISO9660:
PrintErr("Not Writable\n");
break;
default:
PrintErr("File System Not Supported\n");
}
FileAccessDel(fa);
}
return result;
}
U0 Fmt(I64 drv_let,Bool quick=TRUE,Bool confirm=TRUE,I64 type=DVT_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"$.
//You don't format a CD-ROM with this.
CDrv *dv=Let2Drv(drv_let);
Bool old_silent=IsSilent;
if (confirm && !AreYouSure)
return;
if (!dv) {
PrintErr("Invalid Drive\n");
return;
}
switch (type) {
case DVT_REDSEA:
Silent;
Drv(drv_let);
Silent(old_silent);
RedSeaFmt(drv_let,quick);
DskCacheInvalidate(Let2Drv(drv_let));
Drv(drv_let);
break;
case DVT_FAT32:
Silent;
Drv(drv_let);
Silent(old_silent);
FAT32Fmt(drv_let,quick);
DskCacheInvalidate(Let2Drv(drv_let));
Drv(drv_let);
break;
case DVT_ISO9660:
PrintErr("Not Writable\n");
break;
default:
PrintErr("File System Not Supported\n");
}
}
U0 CDImageRead(U8 cd_drv_let,U8 *out_name)
{//Read entire CD/DVD image into ISO file.
CBlkDev *bd=Let2BlkDev(cd_drv_let);
CDrv *dv=Let2Drv(cd_drv_let);
U8 *buf=MAlloc(COPY_BUF_BLKS<<BLK_SIZE_BITS),
*out_name2=DftExt(out_name,"ISO");
CFile *f=FOpen(out_name2,"w");
I64 n,spc=bd->blk_size>>BLK_SIZE_BITS,blk=0,cnt,retry;
BlkDevInit(bd);
if (bd->type!=BDT_ATAPI)
throw('BlkDev');
if (!out_name)
out_name=dsk.dft_iso_filename;
cnt=CeilU64(dv->size,spc);
while (cnt>0) {
if (cnt>COPY_BUF_BLKS)
n=COPY_BUF_BLKS;
else
n=cnt;
if (n>bd->max_reads)
n=bd->max_reads;
retry=4;
while (--retry)
if (ATAPIReadBlks2(bd,tS+7.0+0.004*n/spc,buf,blk/spc,n/spc,TRUE))
//n is 0x800 if max_reads. Up to 8 additional seconds
break;
if (!retry)
ATAPIReadBlks2(bd,0,buf,blk/spc,n/spc,TRUE);
FWBlks(f,buf,blk,n);
cnt-=n;
blk+=n;
}
FClose(f);
Free(buf);
Free(out_name2);
}
class CDualBuf
{
U8 *buf0,*buf1;
I64 in_buf,out_buf,cnt;
U8 *filename;
CBlkDev *cd_bd;
};
U0 CDImageWriteTask(CDualBuf *d)
{
U8 *buf;
I64 n,blk=0,cnt=d->cnt;
CFile *f;
Preempt(ON);
if (FileAttr(d->filename)&RS_ATTR_CONTIGUOUS)
f=FOpen(d->filename,"rc");
else
f=FOpen(d->filename,"r");
while (cnt>0) {
if (cnt>COPY_BUF_BLKS)
n=COPY_BUF_BLKS;
else
n=cnt;
if (n>d->cd_bd->max_writes)
n=d->cd_bd->max_writes;
if (d->in_buf&1)
buf=d->buf1;
else
buf=d->buf0;
while (d->in_buf>d->out_buf+1)
Yield;
FRBlks(f,buf,blk,n);
d->in_buf++;
cnt-=n;
blk+=n;
}
FClose(f);
}
U0 CDImageWrite(U8 cd_drv_let,U8 *in_name=NULL,I64 media_type=MT_CD)
{//Write CD/DVD ISO file to disk.
CDualBuf *d=CAlloc(sizeof(CDualBuf));
U8 *buf,*in_name2,*in_name3;
I64 i,n,spc,blk=0,cnt;
CDrv *dv=Let2Drv(cd_drv_let);
CBlkDev *bd=dv->bd,*bd2;
CTask *task;
Bool old_preempt;
CFile *f;
if (!in_name)
in_name=dsk.dft_iso_filename;
in_name3=DftExt(in_name,"ISO");
in_name2=FileNameAbs(in_name3);
f=FOpen(in_name2,"r");
if (!f) {
Free(d);
return;
}
cnt=(FSize(f)+BLK_SIZE-1)>>BLK_SIZE_BITS;
FClose(f);
if (bd->type!=BDT_ATAPI)
throw('BlkDev');
bd2=Let2BlkDev(*in_name2);
while (bd2->lock_fwding)
bd2=bd2->lock_fwding; //If two blkdevs on same controller, use just one lock
if ((bd2->type==BDT_ATA || bd2->type==BDT_ATAPI) &&
bd2->base0==bd->base0) {
"Can't Burn CD on same ATA ctrller as File.\n\n";
throw('BlkDev');
}
bd->flags|=BDF_READ_ONLY_OVERRIDE;
BlkDevInit(bd);
spc=bd->blk_size>>BLK_SIZE_BITS;
if (dv->size<cnt)
dv->size=cnt;
d->filename=in_name2;
d->cd_bd=bd;
d->buf0=MAlloc(COPY_BUF_BLKS<<BLK_SIZE_BITS);
d->buf1=MAlloc(COPY_BUF_BLKS<<BLK_SIZE_BITS);
d->cnt=cnt;
old_preempt=Preempt(OFF);
task=Spawn(&CDImageWriteTask,d,"Write CD");
while (d->in_buf<=d->out_buf)
Yield;
BlkDevLock(bd);
ATAPIWaitReady(bd,0);
progress1=0; progress1_max=cnt;
StrCpy(progress1_desc,"Writing");
while (cnt>0) {
if (cnt>COPY_BUF_BLKS)
n=COPY_BUF_BLKS;
else
n=cnt;
if (n>bd->max_writes)
n=bd->max_writes;
if (d->out_buf&1)
buf=d->buf1;
else
buf=d->buf0;
while (d->in_buf<=d->out_buf)
Yield;
ATAPIWriteBlks(bd,buf,blk/spc,(n+spc-1)/spc);
d->out_buf++;
cnt-=n;
blk+=n;
progress1+=n;
}
ATAPISync(bd);
progress1=0; progress1_max=2;
StrCpy(progress1_desc,"Closing");
for (i=0;i<2;i++) {
ATAPIClose(bd,0x100,i); //Close tracks
progress1++;
}
ATAPISync(bd);
ATAPIClose(bd,0x200); //close disk
ATAPISync(bd);
if (media_type==MT_DVD) {
ATAPIClose(bd,0x300);
ATAPISync(bd);
}
*progress1_desc=0;
progress1=progress1_max=0;
bd->flags&=~BDF_READ_ONLY_OVERRIDE;
BlkDevUnlock(bd);
Free(d->buf0);
Free(d->buf1);
Free(in_name2);
Free(in_name3);
Preempt(old_preempt);
Free(d);
}
Kernel/Dsk/DskCDDVD.CPP
+184
View File
@@ -0,0 +1,184 @@
U0 CDImageRead(U8 cd_drv_let,U8 *out_name)
{//Read entire CD/DVD image into ISO file.
CBlkDev *bd=Let2BlkDev(cd_drv_let);
CDrv *dv=Let2Drv(cd_drv_let);
U8 *buf=MAlloc(COPY_BUF_BLKS<<BLK_SIZE_BITS),
*out_name2=DftExt(out_name,"ISO");
CFile *f=FOpen(out_name2,"w");
I64 n,spc=bd->blk_size>>BLK_SIZE_BITS,blk=0,cnt,retry;
BlkDevInit(bd);
if (bd->type!=BDT_ATAPI)
throw('BlkDev');
if (!out_name)
out_name=dsk.dft_iso_filename;
cnt=CeilU64(dv->size,spc);
while (cnt>0) {
if (cnt>COPY_BUF_BLKS)
n=COPY_BUF_BLKS;
else
n=cnt;
if (n>bd->max_reads)
n=bd->max_reads;
retry=4;
while (--retry)
if (ATAPIReadBlks2(bd,tS+7.0+0.004*n/spc,buf,blk/spc,n/spc,TRUE))
//n is 0x800 if max_reads. Up to 8 additional seconds
break;
if (!retry)
ATAPIReadBlks2(bd,0,buf,blk/spc,n/spc,TRUE);
FWBlks(f,buf,blk,n);
cnt-=n;
blk+=n;
}
FClose(f);
Free(buf);
Free(out_name2);
}
class CDualBuf
{
U8 *buf0,*buf1;
I64 in_buf,out_buf,cnt;
U8 *filename;
CBlkDev *cd_bd;
};
U0 CDImageWriteTask(CDualBuf *d)
{
U8 *buf;
I64 n,blk=0,cnt=d->cnt;
CFile *f;
Preempt(ON);
if (FileAttr(d->filename)&RS_ATTR_CONTIGUOUS)
f=FOpen(d->filename,"rc");
else
f=FOpen(d->filename,"r");
while (cnt>0) {
if (cnt>COPY_BUF_BLKS)
n=COPY_BUF_BLKS;
else
n=cnt;
if (n>d->cd_bd->max_writes)
n=d->cd_bd->max_writes;
if (d->in_buf&1)
buf=d->buf1;
else
buf=d->buf0;
while (d->in_buf>d->out_buf+1)
Yield;
FRBlks(f,buf,blk,n);
d->in_buf++;
cnt-=n;
blk+=n;
}
FClose(f);
}
U0 CDImageWrite(U8 cd_drv_let,U8 *in_name=NULL,I64 media_type=MT_CD)
{//Write CD/DVD ISO file to disk.
CDualBuf *d=CAlloc(sizeof(CDualBuf));
U8 *buf,*in_name2,*in_name3;
I64 i,n,spc,blk=0,cnt;
CDrv *dv=Let2Drv(cd_drv_let);
CBlkDev *bd=dv->bd,*bd2;
CTask *task;
Bool old_preempt;
CFile *f;
if (!in_name)
in_name=dsk.dft_iso_filename;
in_name3=DftExt(in_name,"ISO");
in_name2=FileNameAbs(in_name3);
f=FOpen(in_name2,"r");
if (!f) {
Free(d);
return;
}
cnt=(FSize(f)+BLK_SIZE-1)>>BLK_SIZE_BITS;
FClose(f);
if (bd->type!=BDT_ATAPI)
throw('BlkDev');
bd2=Let2BlkDev(*in_name2);
while (bd2->lock_fwding)
bd2=bd2->lock_fwding; //If two blkdevs on same controller, use one lock
if ((bd2->type==BDT_ATA || bd2->type==BDT_ATAPI) &&
bd2->base0==bd->base0) {
"Can't Burn CD on same ATA ctrller as File.\n\n";
throw('BlkDev');
}
bd->flags|=BDF_READ_ONLY_OVERRIDE;
BlkDevInit(bd);
spc=bd->blk_size>>BLK_SIZE_BITS;
if (dv->size<cnt)
dv->size=cnt;
d->filename=in_name2;
d->cd_bd=bd;
d->buf0=MAlloc(COPY_BUF_BLKS<<BLK_SIZE_BITS);
d->buf1=MAlloc(COPY_BUF_BLKS<<BLK_SIZE_BITS);
d->cnt=cnt;
old_preempt=Preempt;
task=Spawn(&CDImageWriteTask,d,"Write CD");
while (d->in_buf<=d->out_buf)
Yield;
BlkDevLock(bd);
ATAPIWaitReady(bd,0);
progress1=0; progress1_max=cnt;
StrCpy(progress1_desc,"Writing");
while (cnt>0) {
if (cnt>COPY_BUF_BLKS)
n=COPY_BUF_BLKS;
else
n=cnt;
if (n>bd->max_writes)
n=bd->max_writes;
if (d->out_buf&1)
buf=d->buf1;
else
buf=d->buf0;
while (d->in_buf<=d->out_buf)
Yield;
ATAPIWriteBlks(bd,buf,blk/spc,(n+spc-1)/spc);
d->out_buf++;
cnt-=n;
blk+=n;
progress1+=n;
}
ATAPISync(bd);
progress1=0; progress1_max=2;
StrCpy(progress1_desc,"Closing");
for (i=0;i<2;i++) {
ATAPIClose(bd,0x100,i); //Close tracks
progress1++;
}
ATAPISync(bd);
ATAPIClose(bd,0x200); //close disk
ATAPISync(bd);
if (media_type==MT_DVD) {
ATAPIClose(bd,0x300);
ATAPISync(bd);
}
*progress1_desc=0;
progress1=progress1_max=0;
bd->flags&=~BDF_READ_ONLY_OVERRIDE;
BlkDevUnlock(bd);
Free(d->buf0);
Free(d->buf1);
Free(in_name2);
Free(in_name3);
Preempt(old_preempt);
Free(d);
}
Kernel/Dsk/DskCFile.CPP
+12 -12
View File
@@ -10,7 +10,7 @@ CFile *FOpen(U8 *filename,U8 *flags,I64 cnt=0)
{//Allows flags "r","w","w+". "c" for contiguous.
//(It uses $LK,"StrOcc",A="MN:StrOcc"$() for 'w', 'r', '+', 'c')
CFile *f=CAlloc(sizeof(CFile));
CFileAccess *fa;
CDirContext *dirc;
U8 *full_name;
Bool contiguous=StrOcc(flags,'c');
@@ -41,19 +41,19 @@ CFile *FOpen(U8 *filename,U8 *flags,I64 cnt=0)
return f;
}
} else
Del(full_name,FALSE);
Del(full_name,,,FALSE);
f->de.full_name=full_name;
f->flags|=FF_NEW_FILE;
if (fa=FileAccessNew(full_name)) {
StrCpy(f->de.name,fa->mask);
if (dirc=DirContextNew(full_name)) {
StrCpy(f->de.name,dirc->mask);
if (cnt>0) {//We pre-alloc the whole thing.
f->de.cluster=ClustersAlloc(f->dv,0,
(cnt+f->dv->spc-1)/f->dv->spc,contiguous);
(cnt+f->dv->spc-1)/f->dv->spc,contiguous);
f->de.size=cnt<<BLK_SIZE_BITS;
DirNew(fa->dv,Fs->cur_dir,&f->de,TRUE);
DirNew(dirc->dv,Fs->cur_dir,&f->de,TRUE);
f->flags&=~FF_NEW_FILE;
}
FileAccessDel(fa);
DirContextDel(dirc);
if (!contiguous || cnt>0)
return f;
}
@@ -72,21 +72,21 @@ CFile *FOpen(U8 *filename,U8 *flags,I64 cnt=0)
U0 FClose(CFile *f)
{//Close CFile, updating directory.
CFileAccess *fa;
CDirContext *dirc;
if (f) {
if (f->flags & FF_BUF_DIRTY) {
WClusters(f->dv,f->cluster_buf,f->cluster,1);
f->flags&=~FF_BUF_DIRTY;
}
if (f->flags & FF_NEEDS_WRITE) {
if (fa=FileAccessNew(f->de.full_name)) {
if (dirc=DirContextNew(f->de.full_name)) {
if (!(f->flags & FF_USE_OLD_DATETIME))
f->de.datetime=Now;
if (f->flags & FF_NEW_FILE)
DirNew(fa->dv,Fs->cur_dir,&f->de,TRUE);
DirNew(dirc->dv,Fs->cur_dir,&f->de,TRUE);
else
DirNew(fa->dv,Fs->cur_dir,&f->de,FALSE);
FileAccessDel(fa);
DirNew(dirc->dv,Fs->cur_dir,&f->de,FALSE);
DirContextDel(dirc);
} else
throw('File');
}
Kernel/Dsk/DskCache.CPP
+4 -3
View File
@@ -29,7 +29,8 @@ U0 DskCacheInit(I64 size_in_U8s)
dsk.cache_hash_table=AMAlloc(DSK_CACHE_HASH_SIZE*sizeof(U8 *)*2);
for (i=0;i<DSK_CACHE_HASH_SIZE;i++) {
tempc=dsk.cache_hash_table(U8 *)+i*sizeof(U8 *)*2-offset(CCacheBlk.next_hash);
tempc=dsk.cache_hash_table(U8 *)+i*sizeof(U8 *)*2
-offset(CCacheBlk.next_hash);
tempc->next_hash=tempc->last_hash=tempc;
}
}
@@ -121,7 +122,7 @@ U0 RCache(CDrv *dv,U8 **_buf, I64 *_blk, I64 *_cnt)
if (dsk.cache_base) {
while (LBts(&sys_semas[SYS_SEMA_DSK_CACHE],0))
Yield;
//fetch leading blks from cache
//fetch leading blks from cache
while (*_cnt>0) {
if (tempc=DskCacheFind(dv,*_blk)) {
MemCpy(*_buf,&tempc->body,BLK_SIZE);
@@ -131,7 +132,7 @@ U0 RCache(CDrv *dv,U8 **_buf, I64 *_blk, I64 *_cnt)
} else
break;
}
//fetch trailing blks from cache
//fetch trailing blks from cache
while (*_cnt>0) {
if (tempc=DskCacheFind(dv,*_blk+*_cnt-1)) {
MemCpy(*_buf+(*_cnt-1)<<BLK_SIZE_BITS,&tempc->body,BLK_SIZE);
Kernel/Dsk/DskCluster.CPP
+151
View File
@@ -0,0 +1,151 @@
I64 ClusterNumNext(CDrv *dv,I64 c,I64 cnt=1)
{//Return next cnt'th cluster in chain.
Bool unlock;
DrvChk(dv);
if (cnt<=0) return c;
try {
unlock=DrvLock(dv);
switch (dv->type) {
case DVT_ISO9660:
case DVT_REDSEA:
c+=cnt;
break;
case DVT_FAT32:
while (cnt-->0 && 0<c<0x0FFFFFF8) {
DrvMapBlkSet(dv,c);
c=dv->cur_map_blk[c & (BLK_SIZE/4-1)];
}
if (!(0<c<0x0FFFFFF8))
c=INVALID_CLUSTER;
break;
default:
throw('Drv');
}
if (unlock)
DrvUnlock(dv);
} catch
if (unlock)
DrvUnlock(dv);
return c;
}
I64 Cluster2Blk(CDrv *dv,I64 c)
{//Drv cluster num to blk num.
DrvChk(dv);
switch (dv->type) {
case DVT_REDSEA:
return c;
case DVT_ISO9660:
case DVT_FAT32:
return dv->data_area+c*dv->spc;
default:
throw('Drv');
}
}
I64 RClustersBlks(CDrv *dv,U8 *buf,I64 c,I64 blks)
{//Accepts blk count, so padding on last cluster is not read.
I64 i;
Bool unlock;
DrvChk(dv);
if (blks<=0) return c;
try {
unlock=DrvLock(dv);
switch (dv->type) {
case DVT_ISO9660:
RBlks(dv,buf,dv->data_area+c*dv->spc,blks);
c+=(blks+dv->spc-1)/dv->spc;
break;
case DVT_REDSEA:
RBlks(dv,buf,c,blks);
c+=blks;
break;
case DVT_FAT32:
while (blks && 0<c<0x0FFFFFF8) {
i=blks;
if (i>dv->spc)
i=dv->spc;
RBlks(dv,buf,dv->data_area+c*dv->spc,i);
buf+=i<<BLK_SIZE_BITS;
c=ClusterNumNext(dv,c,1);
blks-=i;
}
if (blks)
throw('Drv');
break;
default:
throw('Drv');
}
if (unlock)
DrvUnlock(dv);
} catch
if (unlock)
DrvUnlock(dv);
return c;
}
I64 RClusters(CDrv *dv,U8 *buf,I64 c,I64 cnt)
{//Read cluster cnt from drv to buf.
return RClustersBlks(dv,buf,c,cnt*dv->spc);
}
I64 WClustersBlks(CDrv *dv,U8 *buf,I64 c,I64 blks)
{//Accepts blk count, so padding on last cluster is not written.
I64 i;
Bool unlock;
DrvChk(dv);
if (blks<=0) return c;
try {
unlock=DrvLock(dv);
switch (dv->type) {
case DVT_REDSEA:
WBlks(dv,buf,c,blks);
c=0;
break;
case DVT_FAT32:
while (blks) {
if (!(0<c<0x0FFFFFF8))
throw('Drv');
i=blks;
if (i>dv->spc)
i=dv->spc;
WBlks(dv,buf,dv->data_area+c*dv->spc,i);
buf+=i<<BLK_SIZE_BITS;
c=ClusterNumNext(dv,c);
blks-=i;
}
break;
default:
throw('Drv');
}
if (unlock)
DrvUnlock(dv);
} catch
if (unlock)
DrvUnlock(dv);
return c;
}
I64 WClusters(CDrv *dv,U8 *buf,I64 c,I64 cnt)
{//Write cluster cnt from buf to drv.
return WClustersBlks(dv,buf,c,cnt*dv->spc);
}
I64 ClustersAlloc(CDrv *dv,I64 c=0,I64 cnt=1,Bool contiguous=FALSE)
{//Alloc cluster cnt into chain.
//c=0 means first cluster in chain
DrvChk(dv);
if (cnt<=0) return c;
switch (dv->type) {
case DVT_REDSEA:
return RedSeaAllocClusters(dv,cnt);
case DVT_FAT32:
if (contiguous) {
if (c) throw('File');
return FAT32AllocContiguousClusters(dv,cnt);
} else
return FAT32AllocClusters(dv,c,cnt);
default:
throw('Drv');
}
}
Kernel/Dsk/DskCopy.CPP
+106
View File
@@ -0,0 +1,106 @@
Bool CopySingleZ(U8 *f1,U8 *f2) //Just one file
{
U8 *file_buf=NULL;
I64 size,attr=0,c;
CDirEntry de;
if (FileFind(f1,&de,FUF_JUST_FILES)) {
Free(de.full_name);
file_buf=FileRead(f1,&size,&attr);
attr=FileAttr(f2,attr);
if (file_buf) {
"Copying %s to %s\n",f1,f2;
c=FileWrite(f2,file_buf,size,de.datetime,attr);
Free(file_buf);
return ToBool(c);
} else
PrintErr("File not found.\n");
} else
PrintErr("File not found.\n");
return FALSE;
}
#define COPY_BUF_BLKS 0x80
Bool CopySingle(U8 *f1,U8 *f2) //Just one file
{
U8 *absf1=FileNameAbs(f1),*absf2=FileNameAbs(f2),*buf;
I64 cnt,n,size,attr1=FileAttr(f1),attr2=FileAttr(f2),i,j;
CFile *in_file=NULL,*out_file=NULL;
if (!StrCmp(absf1,absf2)) {//onto self?
Free(absf1);
Free(absf2);
return FALSE;
}
Free(absf1);
Free(absf2);
if (attr1!=attr2)
return CopySingleZ(f1,f2);
buf=MAlloc(COPY_BUF_BLKS<<BLK_SIZE_BITS);
if (attr1 & RS_ATTR_CONTIGUOUS)
in_file=FOpen(f1,"rc");
else
in_file=FOpen(f1,"r");
if (in_file) {
size=FSize(in_file);
cnt=(size+BLK_SIZE-1)>>BLK_SIZE_BITS;
if (attr2 & RS_ATTR_CONTIGUOUS)
out_file=FOpen(f2,"wc",cnt);
else
out_file=FOpen(f2,"w",cnt);
if (out_file) {
"Copying %s to %s\n",f1,f2;
j=size;
while (cnt>0) {
if (cnt>COPY_BUF_BLKS) {
n=COPY_BUF_BLKS;
i=n<<BLK_SIZE_BITS;
} else {
n=cnt;
i=j;
}
FRBlks(in_file, buf,FFB_NEXT_BLK,n);
FWBlks(out_file,buf,FFB_NEXT_BLK,n);
cnt-=n;
j-=n<<BLK_SIZE_BITS;
}
out_file->flags|=FF_USE_OLD_DATETIME;
out_file->de.datetime=in_file->de.datetime;
out_file->de.size=size;
out_file->de.attr=FileAttr(f2,in_file->de.attr);
FClose(out_file);
FClose(in_file);
Free(buf);
return TRUE;
} else
PrintErr("File not found.\n");
FClose(in_file);
} else
PrintErr("File not found.\n");
Free(buf);
return FALSE;
}
I64 Del(U8 *files_find_mask,Bool make_mask=FALSE,
Bool del_dir=FALSE,Bool print_msg=TRUE)
{//Delete files.
I64 result=0;
CDirContext *dirc;
if (dirc=DirContextNew(files_find_mask,make_mask)) {
switch (dirc->dv->type) {
case DVT_REDSEA:
result=RedSeaFilesDel(dirc->dv,Fs->cur_dir,dirc->mask,
0,del_dir,print_msg);
break;
case DVT_FAT32:
result=FAT32FilesDel(dirc->dv,Fs->cur_dir,dirc->mask,
0,del_dir,print_msg);
break;
case DVT_ISO9660:
PrintErr("Not Writable\n");
break;
default:
PrintErr("File System Not Supported\n");
}
DirContextDel(dirc);
}
return result;
}
Kernel/Dsk/DskDir.CPP → Kernel/Dsk/DskDirA.CPP
+2 -86
View File
@@ -62,7 +62,7 @@ U0 DirTreeDel2(CDirEntry *tempde)
I64 DirEntryCompareName(CDirEntry *e1,CDirEntry *e2)
{
U8 buf1[CDIR_FILENAME_LEN],buf2[CDIR_FILENAME_LEN],
buf3[CDIR_FILENAME_LEN],buf4[CDIR_FILENAME_LEN];
buf3[CDIR_FILENAME_LEN],buf4[CDIR_FILENAME_LEN];
I64 d1=0,d2=0;
if (e1->attr & RS_ATTR_DIR)
d1=1;
@@ -164,35 +164,6 @@ CDirEntry *DirFilesFlatten(CDirEntry *tempde,CDirEntry **_result,I64 fuf_flags)
return _result;
}
CDirEntry *SysFilesFind(U8 *files_find_mask,I64 fuf_flags)
{
CDrv *dv=Fs->cur_dv;
CDirEntry *result=NULL;
DrvChk(dv);
switch (dv->type) {
case DVT_REDSEA:
result=RedSeaFilesFind(files_find_mask,fuf_flags);
break;
case DVT_FAT32:
result=FAT32FilesFind(files_find_mask,fuf_flags);
break;
case DVT_ISO9660:
result=ISO1FilesFind(files_find_mask,fuf_flags);
break;
default:
PrintErr("File System Not Supported\n");
result=NULL;
}
if (result) {
DirFilesSort(&result,SK_NAME);
if (fuf_flags&(FUF_FLATTEN_TREE|FUF_JUST_FILES))
DirFilesFlatten(result,&result,fuf_flags);
if (fuf_flags&FUF_CLUSTER_ORDER)
DirFilesSort(&result,SK_CLUSTER);
}
return result;
}
U0 PutFileLink(U8 *filename,I64 line=0,Bool plain_text=FALSE)
{//Put $LK,"DolDoc",A="FI:::/Doc/DolDocOverview.TXT"$ file,line link to StdOut, $LK,"DocPut",A="MN:DocPut"$.
U8 *buf;
@@ -203,7 +174,7 @@ U0 PutFileLink(U8 *filename,I64 line=0,Bool plain_text=FALSE)
else
"%s",filename;
} else {
//LK_DOC,LK_DOC_ANCHOR,LK_DOC_FIND,LK_DOC_LINE
//LK_DOC,LK_DOC_ANCHOR,LK_DOC_FIND,LK_DOC_LINE
if (filename[0]=='A'&&filename[2]==':') {
if (line) //See $LK,"SpriteEdText",A="MN:SpriteEdText"$()
"$$LK,\"%s,%04d\",A=\"AL:%s,%d\"$$",filename+3,line,filename+3,line;
@@ -239,58 +210,3 @@ U0 PutDirLink(U8 *dirname)
Free(buf);
}
}
I64 Dir2(U8 *files_find_mask,I64 fuf_flags,Bool full)
{
CDirEntry *tempde1=NULL,*tempde2;
U8 *st;
CDateStruct ds;
I64 csize=0xFFFF,c=0xFFFF,result=0;
tempde1=SysFilesFind(files_find_mask,fuf_flags);
if (!(st=CurDir))
PrintErr("Invalid Drive\n");
else {
if (tempde1) {
//Find max columns
tempde2=tempde1;
while (tempde2) {
if (tempde2->size>csize)
csize=tempde2->size;
if (tempde2->cluster>c)
c=tempde2->cluster;
tempde2=tempde2->next;
}
csize=Bsr(csize)/4+1;
c=Bsr(c)/4+1;
"$$MA,T=\"Directory\",LM=\"PopUpCd;Dir;\n\"$$ of %s\n",st;
if (full)
"__DATE__ __TIME__ %*ts %*ts\n",
csize,"SIZE",c,"CLUSTER";
else
"DATE_ TIME_ %*ts\n",csize,"SIZE";
while (tempde1) {
tempde2=tempde1->next;
result++;
if (full)
"%D %T %0*tX %0*tX ",tempde1->datetime,tempde1->datetime,
csize,tempde1->size,c,tempde1->cluster;
else {
Date2Struct(&ds,tempde1->datetime+local_time_offset);
"%02d/%02d %02d:%02d %0*tX ",ds.mon,ds.day_of_mon,ds.hour,ds.min,
csize,tempde1->size;
}
if (tempde1->attr & RS_ATTR_DIR)
PutDirLink(tempde1->name);
else
PutFileLink(tempde1->name);
'\n';
DirEntryDel(tempde1);
tempde1=tempde2;
}
} else
"No matching entries\n";
Free(st);
}
return result;
}
Kernel/Dsk/DskDirB.CPP
+180
View File
@@ -0,0 +1,180 @@
Bool Cd(U8 *dirname=NULL,Bool make_dirs=FALSE)
{//Change directory. Optionally, make directories, too.
I64 maxlen,cur_dir_cluster=0;
U8 *chg_to_buf,*new_cur_dir,*buf;
CDrv *dv;
Bool result=TRUE;
if (!dirname)
dirname="::/Home";
else if (!*dirname)
return TRUE;
if (dirname[1]==':') {
if (*dirname==':') {
if (Fs->cur_dv!=Let2Drv(':') && !Drv(*dirname))
return FALSE;
} else if (Fs->cur_dv!=Let2Drv(*dirname) && !Drv(*dirname))
return FALSE;
dirname+=2;
}
if (*dirname=='/' || !*dirname || !Fs->cur_dir) {
Free(Fs->cur_dir);
Fs->cur_dir=StrNew("/");
if (*dirname=='/')
dirname++;
}
chg_to_buf=MStrUtil(dirname,
SUF_REM_LEADING|SUF_REM_TRAILING|SUF_REM_CTRL_CHARS);
maxlen=StrLen(Fs->cur_dir)+1+StrLen(chg_to_buf)+1;
new_cur_dir=MAlloc(maxlen);
buf=MAlloc(maxlen);
StrCpy(new_cur_dir,Fs->cur_dir);
while (*chg_to_buf && result) {
StrFirstRem(chg_to_buf,"/",buf);
if (!*buf)
StrCpy(new_cur_dir,"/");
else if (!StrCmp(buf,"..")) {
StrLastRem(new_cur_dir,"/");
if (!*new_cur_dir)
StrCpy(new_cur_dir,"/");
} else if (StrCmp(buf,".") && *buf) {
dv=Fs->cur_dv;
cur_dir_cluster=Name2DirCluster(dv,new_cur_dir);
switch (dv->type) {
case DVT_REDSEA:
result=RedSeaCd(buf,cur_dir_cluster);
break;
case DVT_FAT32:
result=FAT32Cd(buf,cur_dir_cluster);
break;
case DVT_ISO9660:
result=ISO1Cd(buf,cur_dir_cluster);
break;
default:
PrintErr("File System Not Supported\n");
result=FALSE;
}
if (!result && make_dirs) {
Free(Fs->cur_dir);
Fs->cur_dir=StrNew(new_cur_dir);
result=MkDir(buf);
}
if (result) {
if (StrCmp(new_cur_dir,"/"))
CatPrint(new_cur_dir,"/");
CatPrint(new_cur_dir,buf);
}
}
}
Free(Fs->cur_dir);
Fs->cur_dir=StrNew(new_cur_dir);
Free(buf);
Free(chg_to_buf);
Free(new_cur_dir);
return result;
}
Bool IsDir(U8 *dir_name)
{//Is a str a valid, existing Dir?
U8 *mask=MStrPrint("%s/*",dir_name);
Bool result,old_silent=Silent;
CDirContext *dirc;
if (dirc=DirContextNew(mask)) {
DirContextDel(dirc);
result=TRUE;
} else
result=FALSE;
Free(mask);
Silent(old_silent);
return result;
}
I64 Dir(U8 *files_find_mask,Bool full)
{//List directory.
CDirEntry *tempde1=NULL,*tempde2;
U8 *st;
CDateStruct ds;
I64 csize=0xFFFF,c=0xFFFF,result=0;
tempde1=FilesFind(files_find_mask);
if (!(st=CurDir))
PrintErr("Invalid Drive\n");
else {
if (tempde1) {
//Find max columns
tempde2=tempde1;
while (tempde2) {
if (tempde2->size>csize)
csize=tempde2->size;
if (tempde2->cluster>c)
c=tempde2->cluster;
tempde2=tempde2->next;
}
csize=Bsr(csize)/4+1;
c=Bsr(c)/4+1;
"$$MA,T=\"Directory\",LM=\"PopUpCd;Dir;\n\"$$ of %s\n",st;
if (full)
"__DATE__ __TIME__ %*ts %*ts\n",
csize,"SIZE",c,"CLUSTER";
else
"DATE_ TIME_ %*ts\n",csize,"SIZE";
while (tempde1) {
tempde2=tempde1->next;
result++;
if (full)
"%D %T %0*tX %0*tX ",tempde1->datetime,tempde1->datetime,
csize,tempde1->size,c,tempde1->cluster;
else {
Date2Struct(&ds,tempde1->datetime+local_time_offset);
"%02d/%02d %02d:%02d %0*tX ",ds.mon,ds.day_of_mon,ds.hour,ds.min,
csize,tempde1->size;
}
if (tempde1->attr & RS_ATTR_DIR)
PutDirLink(tempde1->name);
else
PutFileLink(tempde1->name);
'\n';
DirEntryDel(tempde1);
tempde1=tempde2;
}
} else
"No matching entries\n";
Free(st);
}
return result;
}
Bool MkDir(U8 *filename)
{//Make directory. $LK,"Cd",A="MN:Cd"$() can also make directories.
U8 *name;
CDirContext *dirc;
Bool result=FALSE;
if (FileFind(filename,,FUF_JUST_DIRS))
return FALSE;
if (dirc=DirContextNew(filename)) {
if (*dirc->mask) {
if (!FileNameChk(dirc->mask))
PrintErr("Invalid FileName.\n");
else {
"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:
result=RedSeaMkDir(dirc->dv,Fs->cur_dir,name);
break;
case DVT_FAT32:
result=FAT32MkDir(dirc->dv,Fs->cur_dir,name);
break;
case DVT_ISO9660:
PrintErr("Not Writable\n");
break;
default:
PrintErr("File System Not Supported\n");
}
Free(name);
}
}
DirContextDel(dirc);
}
return result;
}
Kernel/Dsk/DskDirContext.CPP
+73
View File
@@ -0,0 +1,73 @@
U0 DirContextDel(CDirContext *dirc)
{//Change back to old cur_dir and drv.
CBlkDev *bd;
if (!dirc) return;
bd=dirc->old_dv->bd;
if (!(bd->flags & BDF_INIT_IN_PROGRESS)) {
if (dirc->old_dir) {
Drv(Drv2Let(dirc->old_dv));
Cd(dirc->old_dir);
}
} else {
Fs->cur_dv=dirc->old_dv;
Free(Fs->cur_dir);
Fs->cur_dir=StrNew("/");
}
Free(dirc->old_dir);
Free(dirc->mask);
Free(dirc);
}
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;
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;
if (*mask && mask[1]==':') {
if (Fs->cur_dv!=Let2Drv(*mask) && !Drv(*mask))
valid=FALSE;
mask+=2;
}
dirc->dv=Fs->cur_dv;
DrvChk(dirc->dv);
buf=MAlloc(StrLen(mask)+2);
StrCpy(buf,mask);
dirc->mask=MAlloc(StrLen(mask)+2);
if (no_mask)
*dirc->mask=0;
else
StrLastRem(buf,"/",dirc->mask);
if (*mask=='/' && !*buf)
StrCpy(buf,"/");
//If began with Dir, change to Dir.
if (*buf && !Cd(buf,make_dirs))
valid=FALSE;
if (valid && make_mask) {
if (!*dirc->mask) {
Free(dirc->mask);
dirc->mask=StrNew("*");
} else {
if (!make_dirs || FileNameChk(dirc->mask)) {
old_silent=Silent;
//Try mask to see if Dir. If Dir, change to dir and set to "*".
if (Cd(dirc->mask,make_dirs)) {
Free(dirc->mask);
dirc->mask=StrNew("*");
}
Silent(old_silent);
}
}
}
Free(buf);
Free(temp_mask);
if (!valid) {
DirContextDel(dirc);
dirc=NULL;
}
return dirc;
}
Kernel/Dsk/DskDrv.CPP
+289
View File
@@ -0,0 +1,289 @@
Bool DrvLock(CDrv *dv)
{//Make this task have exclusive access to drv & BlkDev.
DrvChk(dv);
BlkDevLock(dv->bd);
if (!Bt(&dv->locked_flags,DVlf_LOCKED) || dv->owning_task!=Fs) {
while (LBts(&dv->locked_flags,DVlf_LOCKED))
Yield;
dv->owning_task=Fs;
return TRUE;
} else
return FALSE;
}
Bool DrvUnlock(CDrv *dv,Bool rst=FALSE)
{//Release exclusive lock on access to drv & BlkDev.
DrvChk(dv);
if (Bt(&dv->locked_flags,DVlf_LOCKED) && dv->owning_task==Fs) {
BlkDevUnlock(dv->bd,rst);
dv->owning_task=NULL;
LBtr(&dv->locked_flags,DVlf_LOCKED);
Yield; //Prevent deadlock
return TRUE;
} else
return FALSE;
}
U0 DrvsRelease()
{//When task dies, release all owned drvs.
I64 i;
CDrv *dv;
for (i=0;i<NUM_DRVS;i++) {
dv=&dsk.drvs[i];
if (dv->owning_task==Fs && dv->dv_signature==DRV_SIGNATURE_VAL)
DrvUnlock(dv,TRUE);
}
}
CDrv *DrvMakeFree(U8 drv_let)
{//Make a slot free for a new drv, like during $LK,"Mount",A="MN:Mount"$().
//!!! drv_let is not a $LK,"remapped",A="MN:MapDrv"$ drv.
I64 i=ToUpper(drv_let)-'A';
CDrv *result;
if (!(0<=i<NUM_DRVS))
throw('Drv');
result=&dsk.drvs[i];
MemSet(result,0,sizeof(CDrv));
result->drv_let='A'+i;
return result;
}
CDrv *DrvNextFree(U8 first_drv_let='C')
{//Locate free slot for new drv, like during $LK,"Mount",A="MN:Mount"$().
//!!! first_drv_let is not a $LK,"remapped",A="MN:MapDrv"$ drv.
I64 i=ToUpper(first_drv_let)-'A';
if (!(0<=i<NUM_DRVS))
throw('Drv');
do
if (dsk.drvs[i].dv_signature!=DRV_SIGNATURE_VAL)
return DrvMakeFree(i+'A');
while (++i<NUM_DRVS);
throw('Drv');
return NULL; //never gets here
}
U0 DrvMapBlkAlloc(CDrv *dv)
{
DrvChk(dv);
Free(dv->cur_map_blk);
dv->cur_map_blk=AMAlloc(BLK_SIZE);
dv->cur_map_blk_num=0;
dv->map_blk_dirty=0;
RBlks(dv,dv->cur_map_blk,dv->map1,1);
}
U0 DrvMapBlkClean(CDrv *dv,I64 map_select=3)
{
if ((dv->type==DVT_FAT32 || dv->type==DVT_REDSEA)&&Bt(&dv->map_blk_dirty,0)) {
if (dv->map1==dv->map2) {
WBlks(dv,dv->cur_map_blk,dv->map1+dv->cur_map_blk_num,1);
LBtr(&dv->map_blk_dirty,0);
} else {
if (map_select==3 || !map_select)
WBlks(dv,dv->cur_map_blk,dv->map1+dv->cur_map_blk_num,1);
if (map_select==3 || map_select==1) {
WBlks(dv,dv->cur_map_blk,dv->map2+dv->cur_map_blk_num,1);
LBtr(&dv->map_blk_dirty,0);
}
}
}
}
U0 DrvMapBlkSet(CDrv *dv,I64 c,I64 map_select=3)
{
I64 map_blk_num;
if (c==INVALID_CLUSTER)
throw('Drv');
switch (dv->type) {
case DVT_FAT32:
map_blk_num=c>>(BLK_SIZE_BITS-2);
break;
case DVT_REDSEA:
map_blk_num=(c-dv->data_area)>>(BLK_SIZE_BITS+3);
break;
default:
throw('Drv');
}
if (map_blk_num!=dv->cur_map_blk_num) {
DrvMapBlkClean(dv,map_select);
dv->cur_map_blk_num=map_blk_num;
if (map_select==3 || !map_select)
RBlks(dv,dv->cur_map_blk,dv->map1+dv->cur_map_blk_num,1);
else
RBlks(dv,dv->cur_map_blk,dv->map2+dv->cur_map_blk_num,1);
}
}
U0 DrvChk(CDrv *dv)
{//Check for valid drv. Throw exception.
if (!dv || dv->dv_signature!=DRV_SIGNATURE_VAL)
throw('Drv');
}
U8 Drv2Let(CDrv *dv=NULL)
{//Drv ptr to Drv letter.
if (!dv)
dv=Fs->cur_dv;
DrvChk(dv);
return dv->drv_let;
}
CDrv *Let2Drv(U8 drv_let=0)
{//Drv letter to Drv ptr.
CDrv *dv;
if (!drv_let)
dv=Fs->cur_dv;
else {
if (drv_let==':')
drv_let=dsk.boot_drv_let;
drv_let=ToUpper(drv_let);
if (!('A'<=drv_let<='Z'))
throw('Drv');
dv=dsk.let_to_drv[drv_let-'A'];
}
DrvChk(dv);
return dv;
}
Bool DrvIsWritable(U8 drv_let=0)
{//Is drive writable?
CBlkDev *bd=Let2BlkDev(drv_let);
if (bd->flags & BDF_READ_ONLY)
return FALSE;
else
return TRUE;
}
U0 DskCacheInvalidate(CDrv *dv)
{//Needed for removable media. Called by $LK,"ChgDsk",A="MN:ChgDsk"$().
Bool unlock;
CBlkDev *bd=dv->bd;
DrvChk(dv);
try {
unlock=DrvLock(dv);
BlkDevInit(bd);
if (bd->flags & BDF_READ_CACHE)
DskCacheInvalidate2(dv);
if (dv->type==DVT_ISO9660 && !(bd->flags & BDF_READ_ONLY_OVERRIDE))
ISODrvInit(dv,(32767/bd->blk_size+1)*bd->blk_size>>BLK_SIZE_BITS);
if (unlock)
DrvUnlock(dv);
} catch
if (unlock)
DrvUnlock(dv);
}
U0 ChgDsk(U8 drv_let=0)
{//Change disk. (Needed for removable media.)
CDrv *dv=Let2Drv(drv_let);
CBlkDev *bd=dv->bd;
Bool old_preempt=Preempt;
if (!(bd->flags&BDF_INITIALIZED))
BlkDevInit(bd);
else if (bd->flags&BDF_REMOVABLE)
DskCacheInvalidate(dv);
Drv(drv_let);
RedSeaFreeFreeLst(dv);
Preempt(old_preempt);
}
Bool MapDrv(U8 drv_let,CDrv *dv)
{//Make drive letter map to another.
drv_let=ToUpper(drv_let);
if ('A'<=drv_let<='Z') {
dsk.let_to_drv[drv_let-'A']=dv;
dv->drv_let=drv_let;
return TRUE;
} else
return FALSE;
}
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);
if (dv!=Fs->cur_dv) {
if (bd->flags & BDF_REMOVABLE && !(bd->flags & BDF_INITIALIZED))
ChgDsk(Drv2Let(dv));
if (bd->type==BDT_RAM)
BlkDevInit(bd);
}
Fs->cur_dv=dv;
Free(Fs->cur_dir);
Fs->cur_dir=StrNew("/");
switch (dv->type) {
case DVT_REDSEA:
case DVT_FAT32:
case DVT_ISO9660:
return TRUE;
default:
PrintErr("File System Not Supported\n");
return FALSE;
}
}
U8 *DrvSerialNum(U8 drv_let=0)
{//20 bytes max.
CBlkDev *bd=Let2BlkDev(drv_let);
U16 *st,*result=NULL;
I64 i;
if (bd->dev_id_record) {
st=CAlloc(20+1);
for (i=0;i<10;i++)
st[i]=EndianU16(bd->dev_id_record[10+i]);
result=MStrUtil(st,SUF_REM_LEADING|SUF_REM_TRAILING);
Free(st);
}
return result;
}
U8 *DrvModelNum(U8 drv_let=0)
{//40 bytes max.
CBlkDev *bd=Let2BlkDev(drv_let);
U16 *st,*result=NULL;
I64 i;
if (bd->dev_id_record) {
st=CAlloc(40+1);
for (i=0;i<20;i++)
st[i]=EndianU16(bd->dev_id_record[27+i]);
result=MStrUtil(st,SUF_REM_LEADING|SUF_REM_TRAILING);
Free(st);
}
return result;
}
U0 DrvRep()
{//Drive report.
CDrv *dv;
CBlkDev *bd;
I64 i,drv_let;
U8 *st;
"\nDefined Drives:\n\n";
for (i=0,dv=dsk.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";
else if (drv_let==dsk.boot_drv_let)
"$$GREEN$$:";
else
'' CH_SPACE;
"$$PURPLE$$%C %-8Z %-9Z %04X %04X %02X$$FG$$\n",
drv_let,dv->type.u16[0],"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;
Free(st);
}
if (st=DrvSerialNum(drv_let)) {
" $$CYAN$$Serial#:%s$$FG$$\n",st;
Free(st);
}
" %016X-%016X\n",
dv->base_offset,dv->base_offset+dv->size-1;
dv->base_offset,dv->base_offset+dv->size-1;
}
}
}
Kernel/Dsk/DskFile.CPP
+139
View File
@@ -0,0 +1,139 @@
U8 *FileRead(U8 *filename,I64 *_size=NULL,I64 *_attr=NULL)
{//Read whole file from disk.
CHashGeneric *temph;
U8 *absname,*altname,*curname,*result=NULL;
I64 i,size=0,attr=0;
CDirContext *dirc;
CArcCompress *arc;
absname=FileNameAbs(filename);
altname=ToggleZorNotZ(absname);
if ((temph=HashFind(absname,adam_task->hash_table,HTT_FILE))||
(temph=HashFind(altname,adam_task->hash_table,HTT_FILE))) {
size=temph->user_data1;
result=MAlloc(size+1);
MemCpy(result,temph->user_data0,size);
result[size]=0; //Terminate
attr=FileAttr(temph->str,attr);
} else {
for (i=0;i<2 && !result;i++) {//Try name, then altname
if (!i)
curname=absname;
else
curname=altname;
if (dirc=DirContextNew(curname)) {
switch (dirc->dv->type) {
case DVT_REDSEA:
result=RedSeaFileRead(dirc->dv,Fs->cur_dir,dirc->mask,
&size,&attr);
break;
case DVT_FAT32:
result=FAT32FileRead(dirc->dv,Fs->cur_dir,dirc->mask,
&size,&attr);
break;
case DVT_ISO9660:
result=ISO1FileRead(dirc->dv,Fs->cur_dir,dirc->mask,
&size,&attr);
break;
default:
PrintErr("File System Not Supported\n");
}
DirContextDel(dirc);
}
}
//Search parent directories.
for (i=0;i<2 && !result;i++) {//Try name, then altname
if (!i)
curname=absname;
else
curname=altname;
if (dirc=DirContextNew(curname)) {
while (!result && StrCmp(Fs->cur_dir,"/")) {
Cd("..");
switch (Fs->cur_dv->type) {
case DVT_REDSEA:
result=RedSeaFileRead(dirc->dv,Fs->cur_dir,dirc->mask,
&size,&attr);
break;
case DVT_FAT32:
result=FAT32FileRead(dirc->dv,Fs->cur_dir,dirc->mask,
&size,&attr);
break;
case DVT_ISO9660:
result=ISO1FileRead(dirc->dv,Fs->cur_dir,dirc->mask,
&size,&attr);
break;
default:
PrintErr("File System Not Supported\n");
}
}
DirContextDel(dirc);
}
}
if (!result) {
"%s ",filename;
PrintErr("File not found.\n");
}
if (result && attr & RS_ATTR_RESIDENT)
HashGenericAdd(curname,HTT_FILE,
AMAllocIdentical(result),size,0,adam_task);
}
if (result && attr & RS_ATTR_COMPRESSED) {
arc=result;
size=arc->expanded_size;
result=ExpandBuf(arc);
Free(arc);
}
if (_attr) *_attr=attr;
if (_size) *_size=size;
Free(absname);
Free(altname);
return result;
}
I64 FileWrite(U8 *filename,U8 *fbuf,
I64 size,CDate cdt=0,I64 attr=0)
{//Write whole file to disk.
I64 c=0;
CHashGeneric *temph;
CDirContext *dirc;
U8 *fbuf2,*absname=FileNameAbs(filename);
if (dirc=DirContextNew(filename,FALSE,TRUE)) {
attr=FileAttr(dirc->mask,attr);
if (attr&RS_ATTR_COMPRESSED) {
fbuf=CompressBuf(fbuf,size);
size=fbuf(CArcCompress *)->compressed_size;
fbuf2=fbuf;
} else
fbuf2=NULL;
if (!cdt) cdt=Now;
switch (dirc->dv->type) {
case DVT_REDSEA:
c=RedSeaFileWrite(dirc->dv,Fs->cur_dir,dirc->mask,fbuf,
size,cdt,attr);
break;
case DVT_FAT32:
c=FAT32FileWrite(dirc->dv,Fs->cur_dir,dirc->mask,fbuf,
size,cdt,attr);
break;
case DVT_ISO9660:
PrintErr("Not Writable\n");
break;
default:
PrintErr("File System Not Supported\n");
}
if (temph=HashFind(absname,adam_task->hash_table,HTT_FILE)) {
if (attr & RS_ATTR_RESIDENT) {
Free(temph->user_data0);
temph->user_data0=AMAllocIdentical(fbuf);
temph->user_data1=size;
} else
HashRemDel(temph,adam_task->hash_table);
} else if (attr & RS_ATTR_RESIDENT)
HashGenericAdd(absname,HTT_FILE,AMAllocIdentical(fbuf),size,0,adam_task);
Free(fbuf2);
DirContextDel(dirc);
}
Free(absname);
return c;
}
Kernel/Dsk/DskFind.CPP
+161
View File
@@ -0,0 +1,161 @@
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:
result=RedSeaFilesFind(files_find_mask,fuf_flags);
break;
case DVT_FAT32:
result=FAT32FilesFind(files_find_mask,fuf_flags);
break;
case DVT_ISO9660:
result=ISO1FilesFind(files_find_mask,fuf_flags);
break;
default:
PrintErr("File System Not Supported\n");
result=NULL;
}
if (result) {
DirFilesSort(&result,SK_NAME);
if (fuf_flags&(FUF_FLATTEN_TREE|FUF_JUST_FILES))
DirFilesFlatten(result,&result,fuf_flags);
if (fuf_flags&FUF_CLUSTER_ORDER)
DirFilesSort(&result,SK_CLUSTER);
}
return result;
}
CDirEntry *FilesFind(U8 *files_find_mask,I64 fuf_flags=0)
{/* See $LK,"::/Doc/FileUtils.TXT"$.
Find files and make a directory tree in memory.
When done, you free with $LK,"DirEntryDel",A="MN:DirEntryDel"$(),$LK,"DirEntryDel2",A="MN:DirEntryDel2"$(),
$LK,"DirTreeDel",A="MN:DirTreeDel"$() or $LK,"DirTreeDel2",A="MN:DirTreeDel2"$().
*/
CDirEntry *result;
CDirContext *dirc;
if (fuf_flags&~FUG_FILES_FIND)
throw('FUF');
if (fuf_flags&FUF_SINGLE) {
result=MAlloc(sizeof(CDirEntry));
if (!FileFind(files_find_mask,result)) {
Free(result);
return NULL;
}
} else if (dirc=DirContextNew(files_find_mask,TRUE)) {
result=FilesFind2(dirc->mask,fuf_flags);
DirContextDel(dirc);
} else
return NULL;
return result;
}
Bool FileFind(U8 *filename,CDirEntry *_de=NULL,I64 fuf_flags=0)
{//$LK,"FUF_JUST_DIRS",A="MN:FUF_JUST_DIRS"$, $LK,"FUF_JUST_FILES",A="MN:FUF_JUST_FILES"$, $LK,"FUF_Z_OR_NOT_Z",A="MN:FUF_Z_OR_NOT_Z"$, $LK,"FUF_SCAN_PARENTS",A="MN:FUF_SCAN_PARENTS"$
//If you pass _de, you must Free(_de->full_name);
I64 i,j,cur_dir_cluster;
U8 *altname,*curname,*full_name=NULL;
CDirEntry de;
CDirContext *dirc;
Bool result=FALSE,old_silent;
if (fuf_flags&~FUG_FILE_FIND)
throw('FUF');
if (!filename) return FALSE;
altname=ToggleZorNotZ(filename);
if (fuf_flags&FUF_Z_OR_NOT_Z)
j=2;
else
j=1;
for (i=0;i<j && !result;i++) {
if (!i)
curname=filename;
else
curname=altname;
old_silent=Silent;
if (!(dirc=DirContextNew(curname)))
Silent(old_silent);
else {
Silent(old_silent);
cur_dir_cluster=Name2DirCluster(dirc->dv,Fs->cur_dir);
switch (dirc->dv->type) {
case DVT_REDSEA:
result=RedSeaFileFind(dirc->dv,cur_dir_cluster,dirc->mask,
&de,fuf_flags);
break;
case DVT_FAT32:
result=FAT32FileFind(dirc->dv,cur_dir_cluster,dirc->mask,
&de,fuf_flags);
break;
case DVT_ISO9660:
result=ISO1FileFind(dirc->dv,cur_dir_cluster,dirc->mask,
&de,fuf_flags);
break;
default:
PrintErr("File System Not Supported\n");
}
if (result && _de) {
if (StrCmp(Fs->cur_dir,"/"))
full_name=MStrPrint("%C:%s/%s",
Drv2Let(Fs->cur_dv),Fs->cur_dir,de.name);
else
full_name=MStrPrint("%C:/%s",Drv2Let(Fs->cur_dv),de.name);
}
DirContextDel(dirc);
}
}
for (i=0;i<j && !result && fuf_flags&FUF_SCAN_PARENTS;i++) {
if (!i)
curname=filename;
else
curname=altname;
old_silent=Silent;
if (!(dirc=DirContextNew(curname)))
Silent(old_silent);
else {
Silent(old_silent);
cur_dir_cluster=Name2DirCluster(dirc->dv,Fs->cur_dir);
while (!result && StrCmp(Fs->cur_dir,"/")) {
Cd("..");
cur_dir_cluster=Name2DirCluster(dirc->dv,Fs->cur_dir);
switch (dirc->dv->type) {
case DVT_REDSEA:
result=RedSeaFileFind(dirc->dv,cur_dir_cluster,
dirc->mask,&de,fuf_flags);
break;
case DVT_FAT32:
result=FAT32FileFind(dirc->dv,cur_dir_cluster,
dirc->mask,&de,fuf_flags);
break;
case DVT_ISO9660:
result=ISO1FileFind(dirc->dv,cur_dir_cluster,
dirc->mask,&de,fuf_flags);
break;
default:
PrintErr("File System Not Supported\n");
}
}
if (result && _de) {
if (StrCmp(Fs->cur_dir,"/"))
full_name=MStrPrint("%C:%s/%s",
Drv2Let(Fs->cur_dv),Fs->cur_dir,de.name);
else
full_name=MStrPrint("%C:/%s",
Drv2Let(Fs->cur_dv),de.name);
}
DirContextDel(dirc);
}
}
if (_de) {
if (result) {
MemCpy(_de,&de,sizeof(CDirEntry));
_de->full_name=full_name;
} else
MemSet(_de,0,sizeof(CDirEntry));
}
Free(altname);
return result;
}
Kernel/Dsk/DskFmt.CPP
+90
View File
@@ -0,0 +1,90 @@
Bool DrvTypeSet(U8 drv_let,I64 type=DVT_REDSEA)
{//Very dangerous
I64 i,j,ext_base,drv_num,offset,cur_type;
CMasterBoot mbr;
CBlkDev *bd=Let2BlkDev(drv_let);
drv_num=bd->first_drv_let-'A';
switch (bd->type) {
case BDT_ATA:
offset=0;
ext_base=INVALID_CLUSTER;
while (TRUE) {
ATAReadBlks(bd,&mbr,offset,1);
j=-1;
for (i=0;i<4;i++) {
cur_type=mbr.p[i].type;
if (cur_type) {
if (cur_type==5 || cur_type==15)
j=i;
else {
if (drv_num+'A'==ToUpper(drv_let)) {
switch (type) {
case DVT_REDSEA:
mbr.p[i].type=MBR_PT_REDSEA;
break;
case DVT_FAT32:
mbr.p[i].type=MBR_PT_FAT32a;
break;
default:
throw('Drv');
}
mbr.p[i].active=0x80;
ATAWriteBlks(bd,&mbr,offset,1);
return TRUE;
}
drv_num++;
}
}
}
if (j<0)
break;
if (!mbr.p[j].offset)
break;
if (ext_base==INVALID_CLUSTER) {
offset=mbr.p[j].offset;
ext_base=offset;
} else
offset=mbr.p[j].offset+ext_base;
}
break;
}
}
U0 Fmt(I64 drv_let,Bool quick=TRUE,Bool confirm=TRUE,I64 type=DVT_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"$.
//You don't format a CD-ROM with this.
CDrv *dv=Let2Drv(drv_let);
Bool old_silent=IsSilent;
if (confirm && !AreYouSure)
return;
if (!dv) {
PrintErr("Invalid Drive\n");
return;
}
switch (type) {
case DVT_REDSEA:
Silent;
Drv(drv_let);
Silent(old_silent);
RedSeaFmt(drv_let,quick);
DskCacheInvalidate(Let2Drv(drv_let));
Drv(drv_let);
break;
case DVT_FAT32:
Silent;
Drv(drv_let);
Silent(old_silent);
FAT32Fmt(drv_let,quick);
DskCacheInvalidate(Let2Drv(drv_let));
Drv(drv_let);
break;
case DVT_ISO9660:
PrintErr("Not Writable\n");
break;
default:
PrintErr("File System Not Supported\n");
}
}
Kernel/Dsk/DskStr.CPP → Kernel/Dsk/DskStrA.CPP
+45 -95
View File
@@ -40,7 +40,7 @@ Bool IsDotC(U8 *filename)
Bool FilesFindMatch(U8 *test_filename,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);
*st2=MAlloc(StrLen(files_find_mask)+1);
Bool result=FALSE;
while (TRUE) {
StrFirstRem(st1,";",st2);
@@ -52,19 +52,24 @@ Bool FilesFindMatch(U8 *test_filename,U8 *files_find_mask,I64 fuf_flags=0)
}
} else {
if (WildMatch(test_filename,st2)) {
if (Bt(&fuf_flags,FUf_JUST_TXT) && !FilesFindMatch(test_filename,FILEMASK_TXT)) {
if (Bt(&fuf_flags,FUf_JUST_TXT) &&
!FilesFindMatch(test_filename,FILEMASK_TXT)) {
result=FALSE;
break;
} else if (Bt(&fuf_flags,FUf_JUST_SRC) && !FilesFindMatch(test_filename,FILEMASK_SRC)) {
} else if (Bt(&fuf_flags,FUf_JUST_SRC) &&
!FilesFindMatch(test_filename,FILEMASK_SRC)) {
result=FALSE;
break;
} else if (Bt(&fuf_flags,FUf_JUST_AOT) && !FilesFindMatch(test_filename,FILEMASK_AOT)) {
} else if (Bt(&fuf_flags,FUf_JUST_AOT) &&
!FilesFindMatch(test_filename,FILEMASK_AOT)) {
result=FALSE;
break;
} else if (Bt(&fuf_flags,FUf_JUST_JIT) && !FilesFindMatch(test_filename,FILEMASK_JIT)) {
} else if (Bt(&fuf_flags,FUf_JUST_JIT) &&
!FilesFindMatch(test_filename,FILEMASK_JIT)) {
result=FALSE;
break;
} else if (Bt(&fuf_flags,FUf_JUST_GRA) && !FilesFindMatch(test_filename,FILEMASK_GRA)) {
} else if (Bt(&fuf_flags,FUf_JUST_GRA) &&
!FilesFindMatch(test_filename,FILEMASK_GRA)) {
result=FALSE;
break;
} else
@@ -79,74 +84,6 @@ Bool FilesFindMatch(U8 *test_filename,U8 *files_find_mask,I64 fuf_flags=0)
return result;
}
U0 DrvChk(CDrv *dv)
{//Check for valid drv. Throw exception.
if (!dv || dv->dv_signature!=DRV_SIGNATURE_VAL)
throw('Drv');
}
U8 Drv2Let(CDrv *dv=NULL)
{//Drv ptr to Drv letter.
if (!dv)
dv=Fs->cur_dv;
DrvChk(dv);
return dv->drv_let;
}
CDrv *Let2Drv(U8 drv_let=0)
{//Drv letter to Drv ptr.
CDrv *dv;
if (!drv_let)
dv=Fs->cur_dv;
else {
if (drv_let==':')
drv_let=dsk.boot_drv_let;
drv_let=ToUpper(drv_let);
if (!('A'<=drv_let<='Z'))
throw('Drv');
dv=dsk.let_to_drv[drv_let-'A'];
}
DrvChk(dv);
return dv;
}
U0 BlkDevChk(CBlkDev *bd)
{//Check for valid BlkDev. Throw exception.
if (!bd || bd->bd_signature!=BD_SIGNATURE_VAL ||
!(BDT_NULL<bd->type<BDT_NUM_TYPES))
throw('BlkDev');
}
CBlkDev *Let2BlkDev(U8 drv_let=0)
{//Drv letter to BlkDev ptr.
CDrv *dv=Let2Drv(drv_let);
CBlkDev *bd=dv->bd;
BlkDevChk(bd);
return bd;
}
Bool IsDrvWritable(U8 drv_let=0)
{//Is drive writable?
CBlkDev *bd=Let2BlkDev(drv_let);
if (bd->flags & BDF_READ_ONLY)
return FALSE;
else
return TRUE;
}
U8 *CurDir(CTask *task=NULL,CTask *mem_task=NULL)
{//MAlloc copy of cur dir with drv letter.
U8 *st;
if (!task) task=Fs;
if (!task->cur_dir)
return NULL;
st=MAlloc(StrLen(task->cur_dir)+3,mem_task);
*st=Drv2Let(task->cur_dv);
st[1]=':';
StrCpy(st+2,task->cur_dir);
return st;
}
U8 *DirNameAbs(U8 *_dirname)
{//MAlloc absolute dir string with drv letter.
I64 maxlen;
@@ -229,7 +166,7 @@ U8 *FileNameAbs(U8 *_filename,I64 fuf_flags=0)
Free(buf_file);
Free(buf_dir);
Free(free_filename);
if (fuf_flags&&FileFind(result,&de,fuf_flags|FUF_JUST_FILES)) {
if (fuf_flags && FileFind(result,&de,fuf_flags|FUF_JUST_FILES)) {
Free(result);
result=de.full_name;
}
@@ -260,7 +197,7 @@ CDirEntry *Cd2DirEntry(CDirEntry *tempde,U8 *abs_name)
while (tempde) {
i=StrLen(tempde->full_name);
if (StrNCmp(tempde->full_name,abs_name,i)||
i && tempde->full_name[i-1]!='/' && abs_name[i] && abs_name[i]!='/')
i && tempde->full_name[i-1]!='/' && abs_name[i] && abs_name[i]!='/')
tempde=tempde->next;
else
if (StrLen(abs_name)==i)
@@ -293,11 +230,40 @@ Bool FileNameChk(U8 *filename)
}
if (StrLen(filename)>=CDIR_FILENAME_LEN) return FALSE;
while (*ptr)
if (!Bt(chars_bitmap_filename,*ptr++))
if (!Bt(chars_bmp_filename,*ptr++))
return FALSE;
return TRUE;
}
U8 *ToggleZorNotZ(U8 *name)
{//MAlloc name with Z if not Z or vice versa.
U8 *result;
if (IsDotZ(name)) {
result=StrNew(name);
result[StrLen(name)-2]=0;
} else
result=MStrPrint("%s.Z",name);
return result;
}
U8 *FileNameTempTxt()
{//Make pretty-safe temp filename in home dir.
return MStrPrint("::/Home/SysTemp%X.TXT.Z",GetTSC>>8&0xFFFFFFFF);
}
U8 *CurDir(CTask *task=NULL,CTask *mem_task=NULL)
{//MAlloc copy of cur dir with drv letter.
U8 *st;
if (!task) task=Fs;
if (!task->cur_dir)
return NULL;
st=MAlloc(StrLen(task->cur_dir)+3,mem_task);
*st=Drv2Let(task->cur_dv);
st[1]=':';
StrCpy(st+2,task->cur_dir);
return st;
}
U8 *DirFile(U8 *dirname,U8 *name=NULL,U8 *_extension=NULL)
{/*Strips file from dirname, scans for file upward until found or
returns default.
@@ -321,7 +287,7 @@ returns default.
st2=StrNew(st);
st3=StrNew(st);
StrLastRem(st2,"/",st3);
if (name)
result=MStrPrint("%s/%s%s",st,name,ext);
else {
@@ -332,7 +298,7 @@ returns default.
}
if (!dft)
dft=StrNew(result);
if (!*ext&&(!name||!*name)||FileFind(result)) {
if (!*ext && (!name||!*name) || FileFind(result)) {
Free(st3);
Free(st2);
Free(st);
@@ -348,19 +314,3 @@ returns default.
Free(ext);
return dft;
}
U8 *ToggleZorNotZ(U8 *name)
{//MAlloc name with Z if not Z or vice versa.
U8 *result;
if (IsDotZ(name)) {
result=StrNew(name);
result[StrLen(name)-2]=0;
} else
result=MStrPrint("%s.Z",name);
return result;
}
U8 *FileNameTempTxt()
{//Make pretty-safe temp filename in home dir.
return MStrPrint("::/Home/SysTemp%X.TXT.Z",GetTSC>>8&0xFFFFFFFF);
}
Kernel/Dsk/DskStrB.CPP
+97
View File
@@ -0,0 +1,97 @@
Bool CFileNameTo(U8 *dst,U8 *src)
{
MemSet(dst,0,CDIR_FILENAME_LEN);
if (!FileNameChk(src))
return FALSE;
StrCpy(dst,src);
return TRUE;
}
I64 Name2DirCluster(CDrv *dv,U8 *dirname)
{
Bool cont=TRUE,unlock;
I64 cur_dir_cluster;
CDirEntry de;
U8 *buf=StrNew(dirname),*buf2=StrNew(dirname);
DrvChk(dv);
try {
unlock=DrvLock(dv);
cur_dir_cluster=dv->root_cluster;
while (*buf && cont) {
StrFirstRem(buf,"/",buf2);
if (*buf2) {
switch (dv->type) {
case DVT_REDSEA:
cont=RedSeaFileFind(dv,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
break;
case DVT_FAT32:
cont=FAT32FileFind(dv,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
break;
case DVT_ISO9660:
cont=ISO1FileFind(dv,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
break;
default:
throw('Drv');
}
cur_dir_cluster=de.cluster;
}
}
if (!cont) {
"%s ",dirname;
PrintErr("File not found.\n");
cur_dir_cluster=0;
}
if (unlock)
DrvUnlock(dv);
} catch
if (unlock)
DrvUnlock(dv);
Free(buf);
Free(buf2);
return cur_dir_cluster;
}
I64 Name2ParentDirCluster(CDrv *dv,U8 *dirname)
{
Bool cont=TRUE,unlock;
I64 cur_dir_cluster,cur_dir_cluster2;
CDirEntry de;
U8 *buf=StrNew(dirname),*buf2=StrNew(dirname);
DrvChk(dv);
try {
unlock=DrvLock(dv);
cur_dir_cluster=cur_dir_cluster2=dv->root_cluster;
while (*buf && cont) {
cur_dir_cluster2=cur_dir_cluster;
StrFirstRem(buf,"/",buf2);
if (*buf2) {
switch (dv->type) {
case DVT_REDSEA:
cont=RedSeaFileFind(dv,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
break;
case DVT_FAT32:
cont=FAT32FileFind(dv,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
break;
case DVT_ISO9660:
cont=ISO1FileFind(dv,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
break;
default:
throw('Drv');
}
cur_dir_cluster=de.cluster;
}
}
if (!cont) {
"%s ",dirname;
PrintErr("File not found.\n");
cur_dir_cluster2=0;
}
if (unlock)
DrvUnlock(dv);
} catch
if (unlock)
DrvUnlock(dv);
Free(buf);
Free(buf2);
return cur_dir_cluster2;
}
Kernel/Dsk/FileSysFAT.CPP
+88 -72
View File
@@ -1,7 +1,7 @@
U0 CDate2Dos(U16 *t,U16 *d,CDate cdt)
{
CDateStruct ds;
Date2Struct(&ds,cdt+local_time_offset);
Date2Struct(&ds,cdt);
*d=ds.day_of_mon+(ds.mon+(ds.year-1980)<<4)<<5;
*t=ds.sec>>1+(ds.min+ds.hour<<6)<<5;
}
@@ -16,7 +16,7 @@ CDate Dos2CDate(U16 t,U16 d)
ds.sec=(t&0x1F)*2; t=t>>5;
ds.min=t&0x3F;
ds.hour=t>>6;
return Struct2Date(&ds)-local_time_offset;
return Struct2Date(&ds);
}
U0 FAT32DrvInit(CDrv *dv)
@@ -30,7 +30,8 @@ U0 FAT32DrvInit(CDrv *dv)
dv->file_system_info_sect=dv->base_offset+br32.file_system_info_sect;
dv->map1=dv->base_offset+br32.reserved_sects;
dv->map2=dv->map1+br32.sects_per_fat;
dv->data_area=dv->map2+br32.sects_per_fat-2*br32.sects_per_cluster; //Starts at Cluster 2
dv->data_area=dv->map2+br32.sects_per_fat
-2*br32.sects_per_cluster; //Starts at Cluster 2
dv->spc=br32.sects_per_cluster;
dv->root_cluster=br32.root_cluster;
DrvMapBlkAlloc(dv);
@@ -52,9 +53,9 @@ Bool FAT32DrvValidate(U8 drv_let)
try {
dv=Let2Drv(drv_let);
if (dv->type==DVT_FAT32 &&
RBlks(dv,&br,dv->base_offset,1) &&
br.signature==0xAA55 &&
br.sects==dv->size)
RBlks(dv,&br,dv->base_offset,1) &&
br.signature==0xAA55 &&
br.sects==dv->size)
result=TRUE;
} catch
Fs->catch_except=TRUE;
@@ -90,7 +91,7 @@ U0 FAT32Fmt(U8 drv_let,Bool quick=TRUE)
br->sects_per_cluster=32;
else
br->sects_per_cluster=64;
br->reserved_sects=32;
br->copies_of_fat=2;
br->media_desc=0xF8;
@@ -110,13 +111,13 @@ U0 FAT32Fmt(U8 drv_let,Bool quick=TRUE)
fis->free_clusters=-1;
fis->most_recently_alloced=0;
fis->signature3=0xAA550000;
if (quick)
i=br->reserved_sects+2*l+4*br->sects_per_cluster;
else
i=dv->size;
WZeroBlks(dv,dv->base_offset,i);
WBlks(dv,fis,dv->base_offset+br->file_system_info_sect,1);
WBlks(dv,br,dv->base_offset,1);
FAT32DrvInit(dv);
@@ -227,7 +228,8 @@ Bool DirLongNameFill(CDirEntry *tempde,CFAT32DirEntryLong *de,I64 *xsum)
return TRUE;
}
Bool FAT32CDirFill(CDirEntry *tempde,CFAT32DirEntry *de)
Bool FAT32CDirFill(CDirEntry *tempde,
CFAT32DirEntry *de,CDate _local_time_offset)
{
Bool result;
if (*tempde->name)
@@ -237,11 +239,12 @@ Bool FAT32CDirFill(CDirEntry *tempde,CFAT32DirEntry *de)
tempde->cluster=de->cluster_lo+de->cluster_hi<<16;
tempde->size=de->size;
tempde->attr=de->attr;
tempde->datetime=Dos2CDate(de->WrtTime,de->WrtDate);
tempde->datetime=Dos2CDate(de->WrtTime,de->WrtDate)-_local_time_offset;
return result;
}
Bool FAT32DirFill(CFAT32DirEntry *de,CDirEntry *tempde,I64 *_de_cnt=NULL)
Bool FAT32DirFill(CFAT32DirEntry *de,
CDirEntry *tempde,I64 *_de_cnt,CDate _local_time_offset)
{//Fill up to 3 entries and store cnt of entries.
I64 de_cnt=0,i,l,xsum,ord;
U8 *ptr,dname[16];
@@ -290,13 +293,15 @@ Bool FAT32DirFill(CFAT32DirEntry *de,CDirEntry *tempde,I64 *_de_cnt=NULL)
de[de_cnt].attr=tempde->attr;
if (!tempde->datetime)
tempde->datetime=Now;
CDate2Dos(&de[de_cnt].WrtTime,&de[de_cnt].WrtDate,tempde->datetime);
CDate2Dos(&de[de_cnt].WrtTime,&de[de_cnt].WrtDate,
tempde->datetime+_local_time_offset);
if (_de_cnt)
*_de_cnt=de_cnt+1;
return result;
}
Bool FAT32FileFind(CDrv *dv,I64 cur_dir_cluster,U8 *name,CDirEntry *_result,I64 fuf_flags=0)
Bool FAT32FileFind(CDrv *dv,I64 cur_dir_cluster,
U8 *name,CDirEntry *_result,I64 fuf_flags=0)
{//$LK,"FUF_JUST_DIRS",A="MN:FUF_JUST_DIRS"$, $LK,"FUF_JUST_FILES",A="MN:FUF_JUST_FILES"$
Bool result=FALSE,unlock;
CFAT32DirEntry *buf;
@@ -332,7 +337,8 @@ Bool FAT32FileFind(CDrv *dv,I64 cur_dir_cluster,U8 *name,CDirEntry *_result,I64
MemSet(_result,0,sizeof(CDirEntry));
if (!(fuf_flags&FUF_JUST_DIRS && !(attr & RS_ATTR_DIR)) &&
!(fuf_flags&FUF_JUST_FILES && attr & RS_ATTR_DIR) &&
FAT32CDirFill(_result,&buf[cur_dir_entry]) &&
FAT32CDirFill(_result,&buf[cur_dir_entry],
dv->fat32_local_time_offset) &&
!StrCmp(dname,_result->name)) {
result=TRUE;
goto fff_done;
@@ -430,7 +436,7 @@ U0 FAT32FreeClusters(CDrv *dv,I64 c)
c=next;
} while (0<c<0x0FFFFFF8);
DrvMapBlkClean(dv,0);
c=saved_c;
do {
DrvMapBlkSet(dv,c,1);
@@ -456,7 +462,7 @@ I64 FAT32AllocClusters(CDrv *dv,I64 c,I64 cnt)
{
Bool wrap_around=FALSE,unlock,unlock_break;
I64 first=INVALID_CLUSTER,j,l;
if (cnt<=0) return 0x0FFFFFFF;
try {
unlock_break=BreakLock;
@@ -486,14 +492,14 @@ I64 FAT32AllocClusters(CDrv *dv,I64 c,I64 cnt)
}
c=j;
}
if (0<c<l) {
DrvMapBlkSet(dv,c);
dv->cur_map_blk[c&(BLK_SIZE/4-1)]=0x0FFFFFFF;
LBts(&dv->map_blk_dirty,0);
}
DrvMapBlkClean(dv);
dv->fis->most_recently_alloced=j;
dv->fis->free_clusters=-1;
WBlks(dv,dv->fis,dv->file_system_info_sect,1);
@@ -514,7 +520,7 @@ I64 FAT32AllocContiguousClusters(CDrv *dv,I64 cnt)
{
I64 i,first=1;
Bool cont,unlock,unlock_break;
if (cnt<=0) return 0x0FFFFFFF;
try {
unlock_break=BreakLock;
@@ -536,7 +542,7 @@ I64 FAT32AllocContiguousClusters(CDrv *dv,I64 cnt)
first=first+i;
else {
DrvMapBlkClean(dv);
for (i=0;i<cnt;i++) {
DrvMapBlkSet(dv,first+i,0);
if (i+1==cnt)
@@ -546,7 +552,7 @@ I64 FAT32AllocContiguousClusters(CDrv *dv,I64 cnt)
LBts(&dv->map_blk_dirty,0);
}
DrvMapBlkClean(dv,0);
for (i=0;i<cnt;i++) {
DrvMapBlkSet(dv,first+i,1);
if (i+1==cnt)
@@ -577,12 +583,12 @@ Bool FAT32DirNew(CDrv *dv,U8 *cur_dir,CDirEntry *tempde,Bool free_old_chain)
//See $LK,"::/Doc/CutCorners.TXT"$.
CFAT32DirEntry *buf,*last_buf,*temp_buf,de[3];
I64 i,attr,avail_cnt,de_cnt,c,
cur_dir_entry,entries_per_cluster,
cur_dir_cluster,xsum=0,last_dir_cluster=INVALID_CLUSTER;
cur_dir_entry,entries_per_cluster,
cur_dir_cluster,xsum=0,last_dir_cluster=INVALID_CLUSTER;
U8 ch;
Bool written=FALSE,unlock,unlock_break;
CDirEntry long_name;
FAT32DirFill(&de,tempde,&de_cnt);
FAT32DirFill(&de,tempde,&de_cnt,dv->fat32_local_time_offset);
MemSet(&long_name,0,sizeof(CDirEntry));
try {
unlock_break=BreakLock;
@@ -598,7 +604,8 @@ Bool FAT32DirNew(CDrv *dv,U8 *cur_dir,CDirEntry *tempde,Bool free_old_chain)
if (ch!=0xE5 && attr&RS_ATTR_LONG_NAME_MASK==RS_ATTR_LONG_NAME)
DirLongNameFill(&long_name,&buf[cur_dir_entry],&xsum);
else {
avail_cnt=FAT32_ENTRIES_PER_BLK-cur_dir_entry & (FAT32_ENTRIES_PER_BLK-1);
avail_cnt=FAT32_ENTRIES_PER_BLK-cur_dir_entry
&(FAT32_ENTRIES_PER_BLK-1);
for (i=0;i<avail_cnt;i++)
if (*buf[cur_dir_entry+i].name!=0xE5) {
if (*buf[cur_dir_entry+i].name)
@@ -608,8 +615,8 @@ Bool FAT32DirNew(CDrv *dv,U8 *cur_dir,CDirEntry *tempde,Bool free_old_chain)
if (ch==0xE5 && !written && avail_cnt>=de_cnt) {
MemCpy(&buf[cur_dir_entry],&de,de_cnt*sizeof(CFAT32DirEntry));
WBlks(dv,&buf[cur_dir_entry & -FAT32_ENTRIES_PER_BLK],
dv->data_area+cur_dir_cluster*dv->spc
+cur_dir_entry>>FAT32_ENTRIES_BITS,1);
dv->data_area+cur_dir_cluster*dv->spc
+cur_dir_entry>>FAT32_ENTRIES_BITS,1);
cur_dir_entry+=de_cnt-1; //gets inc'ed
written=TRUE;
} else if (ch!=0xE5 && !(attr&RS_ATTR_VOL_ID)) {
@@ -617,38 +624,40 @@ Bool FAT32DirNew(CDrv *dv,U8 *cur_dir,CDirEntry *tempde,Bool free_old_chain)
MemSet(&long_name,0,sizeof(CDirEntry));
if (!*long_name.name)
FATFromName(long_name.name,buf[cur_dir_entry].name);
//Del old entry with same name
//Del old entry with same name
if (!StrCmp(long_name.name,tempde->name)) {
if (free_old_chain)
FAT32FreeClusters(dv,buf[cur_dir_entry].cluster_lo+
buf[cur_dir_entry].cluster_hi<<16);
buf[cur_dir_entry].cluster_hi<<16);
if (!written) {
MemCpy(&buf[cur_dir_entry],&de[de_cnt-1],sizeof(CFAT32DirEntry));
WBlks(dv,&buf[cur_dir_entry & -FAT32_ENTRIES_PER_BLK],
dv->data_area+cur_dir_cluster*dv->spc
+cur_dir_entry>>FAT32_ENTRIES_BITS,1);
dv->data_area+cur_dir_cluster*dv->spc
+cur_dir_entry>>FAT32_ENTRIES_BITS,1);
written=TRUE;
} else {
*buf[cur_dir_entry].name=0xE5;
i=1;
while (i<=cur_dir_entry &&
buf[cur_dir_entry-i].attr&RS_ATTR_LONG_NAME_MASK==RS_ATTR_LONG_NAME)
buf[cur_dir_entry-i].attr&RS_ATTR_LONG_NAME_MASK
==RS_ATTR_LONG_NAME)
*buf[cur_dir_entry-i++].name=0xE5;
i--;
WBlks(dv,&buf[(cur_dir_entry-i)&-FAT32_ENTRIES_PER_BLK],
dv->data_area+cur_dir_cluster*dv->spc
+(cur_dir_entry-i)>>FAT32_ENTRIES_BITS,
(i+FAT32_ENTRIES_PER_BLK)>>FAT32_ENTRIES_BITS);
dv->data_area+cur_dir_cluster*dv->spc
+(cur_dir_entry-i)>>FAT32_ENTRIES_BITS,
(i+FAT32_ENTRIES_PER_BLK)>>FAT32_ENTRIES_BITS);
if (i==cur_dir_entry && 0<last_dir_cluster<0x0FFFFFF8) {
i=1;
while (i<=entries_per_cluster &&
last_buf[entries_per_cluster-i].attr&RS_ATTR_LONG_NAME_MASK==RS_ATTR_LONG_NAME)
last_buf[entries_per_cluster-i].attr
&RS_ATTR_LONG_NAME_MASK==RS_ATTR_LONG_NAME)
*last_buf[entries_per_cluster-i++].name=0xE5;
if (--i>0)
WBlks(dv,&buf[(entries_per_cluster-i)&-FAT32_ENTRIES_PER_BLK],
dv->data_area+last_dir_cluster*dv->spc
+(entries_per_cluster-i)>>FAT32_ENTRIES_BITS,
(i+FAT32_ENTRIES_PER_BLK-1)>>FAT32_ENTRIES_BITS);
dv->data_area+last_dir_cluster*dv->spc
+(entries_per_cluster-i)>>FAT32_ENTRIES_BITS,
(i+FAT32_ENTRIES_PER_BLK-1)>>FAT32_ENTRIES_BITS);
}
}
break;
@@ -676,8 +685,8 @@ Bool FAT32DirNew(CDrv *dv,U8 *cur_dir,CDirEntry *tempde,Bool free_old_chain)
for (i=0;i<avail_cnt;i++)
*buf[cur_dir_entry+i].name=0xE5;
WBlks(dv,&buf[cur_dir_entry &-FAT32_ENTRIES_PER_BLK],
dv->data_area+cur_dir_cluster*dv->spc
+cur_dir_entry>>FAT32_ENTRIES_BITS,1);
dv->data_area+cur_dir_cluster*dv->spc
+cur_dir_entry>>FAT32_ENTRIES_BITS,1);
cur_dir_entry+=avail_cnt;
if (cur_dir_entry==entries_per_cluster) {
last_dir_cluster=cur_dir_cluster;
@@ -690,8 +699,8 @@ Bool FAT32DirNew(CDrv *dv,U8 *cur_dir,CDirEntry *tempde,Bool free_old_chain)
}
MemCpy(&buf[cur_dir_entry],&de,de_cnt*sizeof(CFAT32DirEntry));
WBlks(dv,&buf[cur_dir_entry &-FAT32_ENTRIES_PER_BLK],
dv->data_area+cur_dir_cluster*dv->spc+
cur_dir_entry>>FAT32_ENTRIES_BITS,1);
dv->data_area+cur_dir_cluster*dv->spc+
cur_dir_entry>>FAT32_ENTRIES_BITS,1);
cur_dir_entry+=de_cnt;
if (cur_dir_entry==entries_per_cluster) {
cur_dir_cluster=ClustersAlloc(dv,cur_dir_cluster,1);
@@ -700,8 +709,8 @@ Bool FAT32DirNew(CDrv *dv,U8 *cur_dir,CDirEntry *tempde,Bool free_old_chain)
} else {
MemSet(&buf[cur_dir_entry],0,sizeof(CFAT32DirEntry));
WBlks(dv,&buf[cur_dir_entry &-FAT32_ENTRIES_PER_BLK],
dv->data_area+cur_dir_cluster*dv->spc
+cur_dir_entry>>FAT32_ENTRIES_BITS,1);
dv->data_area+cur_dir_cluster*dv->spc
+cur_dir_entry>>FAT32_ENTRIES_BITS,1);
}
}
Free(last_buf);
@@ -724,7 +733,7 @@ I64 FAT32FilesDel(CDrv *dv,U8 *cur_dir,U8 *files_find_mask,I64 fuf_flags,
{
CFAT32DirEntry *buf,*last_buf,*temp_buf;
I64 i,result=0,attr,xsum=0,last_dir_cluster=INVALID_CLUSTER,
cur_dir_entry,entries_per_cluster,cur_dir_cluster;
cur_dir_entry,entries_per_cluster,cur_dir_cluster;
U8 ch;
Bool unlock_break;
CDirEntry long_name;
@@ -745,7 +754,7 @@ I64 FAT32FilesDel(CDrv *dv,U8 *cur_dir,U8 *files_find_mask,I64 fuf_flags,
DirLongNameFill(&long_name,&buf[cur_dir_entry],&xsum);
else {
if (!(attr & RS_ATTR_VOL_ID) &&
(del_dir || !(attr & RS_ATTR_DIR))) {
(del_dir || !(attr & RS_ATTR_DIR))) {
if (xsum!=FATNameXSum(buf[cur_dir_entry].name))
MemSet(&long_name,0,sizeof(CDirEntry));
if (!*long_name.name)
@@ -757,26 +766,28 @@ I64 FAT32FilesDel(CDrv *dv,U8 *cur_dir,U8 *files_find_mask,I64 fuf_flags,
*buf[cur_dir_entry].name=0xE5;
i=1;
while (i<=cur_dir_entry &&
buf[cur_dir_entry-i].attr&RS_ATTR_LONG_NAME_MASK==RS_ATTR_LONG_NAME)
buf[cur_dir_entry-i].attr&RS_ATTR_LONG_NAME_MASK
==RS_ATTR_LONG_NAME)
*buf[cur_dir_entry-i++].name=0xE5;
i--;
WBlks(dv,&buf[(cur_dir_entry-i)&-FAT32_ENTRIES_PER_BLK],
dv->data_area+cur_dir_cluster*dv->spc
+(cur_dir_entry-i)>>FAT32_ENTRIES_BITS,
(i+FAT32_ENTRIES_PER_BLK)>>FAT32_ENTRIES_BITS);
dv->data_area+cur_dir_cluster*dv->spc
+(cur_dir_entry-i)>>FAT32_ENTRIES_BITS,
(i+FAT32_ENTRIES_PER_BLK)>>FAT32_ENTRIES_BITS);
if (i==cur_dir_entry && last_dir_cluster!=INVALID_CLUSTER) {
i=1;
while (i<=entries_per_cluster &&
last_buf[entries_per_cluster-i].attr&RS_ATTR_LONG_NAME_MASK==RS_ATTR_LONG_NAME)
last_buf[entries_per_cluster-i].attr
&RS_ATTR_LONG_NAME_MASK==RS_ATTR_LONG_NAME)
*last_buf[entries_per_cluster-i++].name=0xE5;
if (--i>0)
WBlks(dv,&buf[(entries_per_cluster-i)&-FAT32_ENTRIES_PER_BLK],
dv->data_area+last_dir_cluster*dv->spc
+(entries_per_cluster-i)>>FAT32_ENTRIES_BITS,
(i+FAT32_ENTRIES_PER_BLK-1)>>FAT32_ENTRIES_BITS);
dv->data_area+last_dir_cluster*dv->spc
+(entries_per_cluster-i)>>FAT32_ENTRIES_BITS,
(i+FAT32_ENTRIES_PER_BLK-1)>>FAT32_ENTRIES_BITS);
}
FAT32FreeClusters(dv,buf[cur_dir_entry].cluster_lo+
buf[cur_dir_entry].cluster_hi<<16);
buf[cur_dir_entry].cluster_hi<<16);
}
}
MemSet(&long_name,0,sizeof(CDirEntry));
@@ -837,12 +848,13 @@ I64 FAT32FileWrite(CDrv *dv,U8 *cur_dir,U8 *name,U8 *buf,I64 size,
return c;
}
CDirEntry *FAT32FilesFind(U8 *files_find_mask,I64 fuf_flags,CDirEntry *parent=NULL,I64 *_dir_size=NULL)
CDirEntry *FAT32FilesFind(U8 *files_find_mask,
I64 fuf_flags,CDirEntry *parent=NULL,I64 *_dir_size=NULL)
{
CDrv *dv=Fs->cur_dv;
CFAT32DirEntry *buf;
I64 attr,xsum=0,dir_size=0,sub_dir_size,
cur_dir_cluster,cur_dir_entry,entries_per_cluster;
cur_dir_cluster,cur_dir_entry,entries_per_cluster;
U8 ch;
CDirEntry *result=NULL,*tempde,long_name;
if (fuf_flags&~FUG_FILES_FIND)
@@ -853,8 +865,8 @@ CDirEntry *FAT32FilesFind(U8 *files_find_mask,I64 fuf_flags,CDirEntry *parent=NU
cur_dir_cluster=Name2DirCluster(dv,Fs->cur_dir);
buf=MAlloc(BLK_SIZE*dv->spc);
entries_per_cluster=dv->spc<<FAT32_ENTRIES_BITS;
RClusters(Fs->cur_dv,buf,cur_dir_cluster,1);
dir_size+=Fs->cur_dv->spc*BLK_SIZE;
RClusters(dv,buf,cur_dir_cluster,1);
dir_size+=dv->spc*BLK_SIZE;
cur_dir_entry=0;
while (ch=*buf[cur_dir_entry].name) {
attr=buf[cur_dir_entry].attr;
@@ -868,22 +880,26 @@ CDirEntry *FAT32FilesFind(U8 *files_find_mask,I64 fuf_flags,CDirEntry *parent=NU
MemCpy(tempde,&long_name,sizeof(CDirEntry));
else
MemSet(tempde,0,sizeof(CDirEntry));
if (FAT32CDirFill(tempde,&buf[cur_dir_entry])) {
if (FAT32CDirFill(tempde,&buf[cur_dir_entry],
dv->fat32_local_time_offset)) {
tempde->parent=parent;
if (Bt(&fuf_flags,FUf_RECURSE) && attr&RS_ATTR_DIR && *tempde->name!='.') {
if (Bt(&fuf_flags,FUf_RECURSE) && attr&RS_ATTR_DIR &&
*tempde->name!='.') {
tempde->next=result;
result=tempde;
tempde->full_name=DirNameAbs(tempde->name);
DrvUnlock(dv);
if (Cd(tempde->name)) {
tempde->sub=FAT32FilesFind(files_find_mask,fuf_flags,tempde,&sub_dir_size);
tempde->sub=FAT32FilesFind(files_find_mask,fuf_flags,
tempde,&sub_dir_size);
tempde->size=sub_dir_size;
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)) {
!(Bt(&fuf_flags,FUf_RECURSE) &&
*tempde->name=='.' && attr&RS_ATTR_DIR) &&
FilesFindMatch(tempde->name,files_find_mask,fuf_flags)) {
tempde->next=result;
result=tempde;
tempde->full_name=FileNameAbs(tempde->name);
@@ -902,7 +918,7 @@ CDirEntry *FAT32FilesFind(U8 *files_find_mask,I64 fuf_flags,CDirEntry *parent=NU
break;
else {
RClusters(dv,buf,cur_dir_cluster,1);
dir_size+=Fs->cur_dv->spc*BLK_SIZE;
dir_size+=dv->spc*BLK_SIZE;
cur_dir_entry=0;
}
}
@@ -919,12 +935,12 @@ CDirEntry *FAT32FilesFind(U8 *files_find_mask,I64 fuf_flags,CDirEntry *parent=NU
Bool FAT32MkDir(CDrv *dv,U8 *cur_dir,U8 *name)
{
I64 size=dv->spc<<BLK_SIZE_BITS,c,
cur_dir_cluster=Name2DirCluster(dv,cur_dir);
cur_dir_cluster=Name2DirCluster(dv,cur_dir);
U8 *buf=CAlloc(size);
CDirEntry d_native;
CFAT32DirEntry *dFAT=buf;
Bool unlock_break;
try {
unlock_break=BreakLock;
c=FileWrite(name,buf,size,0,RS_ATTR_DIR);
@@ -935,9 +951,9 @@ Bool FAT32MkDir(CDrv *dv,U8 *cur_dir,U8 *name)
d_native.cluster=c;
d_native.size=0;
d_native.datetime=Now;
FAT32DirFill(dFAT,&d_native);
FAT32DirFill(dFAT,&d_native,NULL,dv->fat32_local_time_offset);
dFAT++;
MemSet(&d_native,0,sizeof(CDirEntry));
d_native.attr=RS_ATTR_DIR;
*d_native.name='.';
@@ -946,7 +962,7 @@ Bool FAT32MkDir(CDrv *dv,U8 *cur_dir,U8 *name)
d_native.cluster=cur_dir_cluster;
d_native.size=0;
d_native.datetime=Now;
FAT32DirFill(dFAT,&d_native);
FAT32DirFill(dFAT,&d_native,NULL,dv->fat32_local_time_offset);
WClusters(dv,buf,c,1);
Free(buf);
if (unlock_break)
Kernel/Dsk/FileSysISO.CPP
+20 -13
View File
@@ -21,7 +21,8 @@ Bool ISODrvInit(CDrv *dv,I64 blk)
RBlks(dv,iso,i*spc,spc);
buf[0](U32)=iso->id[0](U32);
buf[4](U16)=iso->id[4](U8);
switch (LstMatch(buf,"CD001\0CDW02\0BEA01\0BOOT2\0NSR02\0NSR03\0TEA01\0",LMF_EXACT)) {
switch (LstMatch(buf,"CD001\0CDW02\0BEA01\0BOOT2\0NSR02\0NSR03\0TEA01\0",
LMF_EXACT)) {
case 0:
dv->type=DVT_ISO9660;
switch (iso->type) {
@@ -101,7 +102,7 @@ Bool ISO1FromName(U8 *dst,U8 *src)
src++;
if (*src==';')
break;
if (Bt(chars_bitmap_filename,*src)) {
if (Bt(chars_bmp_filename,*src)) {
if (j>=CDIR_FILENAME_LEN-1)
return FALSE;
dst[j++]=*src++;
@@ -126,7 +127,8 @@ Bool ISO1CDirFill(CDirEntry *tempde,CISO1DirEntry *de)
return result;
}
Bool ISO1FileFind(CDrv *dv,I64 cur_dir_cluster,U8 *name,CDirEntry *_result,I64 fuf_flags=0)
Bool ISO1FileFind(CDrv *dv,I64 cur_dir_cluster,U8 *name,
CDirEntry *_result,I64 fuf_flags=0)
{//$LK,"FUF_JUST_DIRS",A="MN:FUF_JUST_DIRS"$, $LK,"FUF_JUST_FILES",A="MN:FUF_JUST_FILES"$
CISO1DirEntry *isoptr,*buf;
U8 dname[CDIR_FILENAME_LEN];
@@ -141,11 +143,11 @@ Bool ISO1FileFind(CDrv *dv,I64 cur_dir_cluster,U8 *name,CDirEntry *_result,I64 f
try {
unlock=DrvLock(dv);
isoptr=MAlloc(dv->spc<<BLK_SIZE_BITS);
RClusters(Fs->cur_dv,isoptr,cur_dir_cluster,1);
RClusters(dv,isoptr,cur_dir_cluster,1);
if (isoptr->name_len==1 && !isoptr->name) {//curdir
i=(isoptr->size.little+dv->spc<<BLK_SIZE_BITS-1)/dv->spc<<BLK_SIZE_BITS;
buf=MAlloc(dv->spc<<BLK_SIZE_BITS*i);
RClusters(Fs->cur_dv,buf,cur_dir_cluster,i);
RClusters(dv,buf,cur_dir_cluster,i);
Free(isoptr);
} else {
buf=isoptr;
@@ -163,7 +165,8 @@ Bool ISO1FileFind(CDrv *dv,I64 cur_dir_cluster,U8 *name,CDirEntry *_result,I64 f
if (!StrCmp(name,dname)) {
result=ISO1CDirFill(_result,isoptr);
if (result &&
!(fuf_flags&FUF_JUST_DIRS && !(_result->attr & RS_ATTR_DIR)) &&
!(fuf_flags&FUF_JUST_DIRS &&
!(_result->attr & RS_ATTR_DIR)) &&
!(fuf_flags&FUF_JUST_FILES && _result->attr & RS_ATTR_DIR) )
goto iff_done;
else
@@ -227,7 +230,8 @@ Bool ISO1Cd(U8 *name,I64 cur_dir_cluster)
return FALSE;
}
CDirEntry *ISO1FilesFind(U8 *files_find_mask,I64 fuf_flags,CDirEntry *parent=NULL)
CDirEntry *ISO1FilesFind(U8 *files_find_mask,
I64 fuf_flags,CDirEntry *parent=NULL)
{
CDrv *dv=Fs->cur_dv;
CISO1DirEntry *buf,*buf2,*isoptr;
@@ -236,11 +240,11 @@ CDirEntry *ISO1FilesFind(U8 *files_find_mask,I64 fuf_flags,CDirEntry *parent=NUL
if (fuf_flags&~FUG_FILES_FIND)
throw('FUF');
isoptr=MAlloc(dv->spc<<BLK_SIZE_BITS);
RClusters(Fs->cur_dv,isoptr,cur_dir_cluster,1);
RClusters(dv,isoptr,cur_dir_cluster,1);
if (isoptr->name_len==1 && !isoptr->name) {//curdir
i=(isoptr->size.little+dv->spc<<BLK_SIZE_BITS-1)/dv->spc<<BLK_SIZE_BITS;
buf=MAlloc(dv->spc<<BLK_SIZE_BITS*i);
RClusters(Fs->cur_dv,buf,cur_dir_cluster,i);
RClusters(dv,buf,cur_dir_cluster,i);
Free(isoptr);
} else {
buf=isoptr;
@@ -256,7 +260,8 @@ CDirEntry *ISO1FilesFind(U8 *files_find_mask,I64 fuf_flags,CDirEntry *parent=NUL
tempde=MAlloc(sizeof(CDirEntry));
if (ISO1CDirFill(tempde,buf)) {
tempde->parent=parent;
if (Bt(&fuf_flags,FUf_RECURSE) && tempde->attr&RS_ATTR_DIR && *tempde->name!='.') {
if (Bt(&fuf_flags,FUf_RECURSE) && tempde->attr&RS_ATTR_DIR &&
*tempde->name!='.') {
tempde->next=result;
result=tempde;
tempde->full_name=DirNameAbs(tempde->name);
@@ -264,9 +269,11 @@ CDirEntry *ISO1FilesFind(U8 *files_find_mask,I64 fuf_flags,CDirEntry *parent=NUL
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)) {
} 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;
tempde->full_name=FileNameAbs(tempde->name);
Kernel/Dsk/FileSysRedSea.CPP
+36 -30
View File
@@ -87,8 +87,8 @@ Bool RedSeaDrvValidate(U8 drv_let)
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)
br.signature==MBR_PT_REDSEA && br.signature2==0xAA55 &&
br.sects==dv->size)
result=TRUE;
} catch
Fs->catch_except=TRUE;
@@ -104,7 +104,7 @@ U0 RedSeaFmt(U8 drv_let,Bool quick=TRUE)
I64 i,n;
try {
DrvLock(dv);
// DrvTypeSet(drv_let,DVT_REDSEA);
// DrvTypeSet(drv_let,DVT_REDSEA);
DrvTypeSet(drv_let,DVT_FAT32);
dv->type=DVT_REDSEA;
br->signature=MBR_PT_REDSEA;
@@ -115,36 +115,36 @@ U0 RedSeaFmt(U8 drv_let,Bool quick=TRUE)
br->bitmap_sects=n;
br->unique_id=GetTSC^Now()(U64);
br->root_cluster=0;
if (quick)
i=n+1;
else
i=dv->size;
WZeroBlks(dv,dv->base_offset,i);
WBlks(dv,br,dv->base_offset,1);
RedSeaDrvInit(dv);
ClustersAlloc(dv,0,1,FALSE); //Alloc #1
br->root_cluster=ClustersAlloc(dv,0,1,FALSE);
WBlks(dv,br,dv->base_offset,1);
root_dir=CAlloc(BLK_SIZE);
d_native=root_dir-offset(CDirEntry.start);
d_native->attr=RS_ATTR_DIR|RS_ATTR_CONTIGUOUS;
*d_native->name='.';
d_native->cluster=br->root_cluster;
d_native->size=BLK_SIZE;
d_native->datetime=Now;
d_native(U8 *)+=CDIR_SIZE;
*d_native->name='.';
d_native->name[1]='.';
d_native->attr=RS_ATTR_DIR|RS_ATTR_CONTIGUOUS;
d_native->cluster=br->root_cluster;
d_native->datetime=Now;
WBlks(dv,root_dir,br->root_cluster,1);
RedSeaDrvInit(dv);
DrvUnlock(dv);
@@ -154,7 +154,8 @@ U0 RedSeaFmt(U8 drv_let,Bool quick=TRUE)
Free(root_dir);
}
Bool RedSeaFileFind(CDrv *dv,I64 cur_dir_cluster,U8 *name,CDirEntry *_result,I64 fuf_flags=0)
Bool RedSeaFileFind(CDrv *dv,I64 cur_dir_cluster,U8 *name,
CDirEntry *_result,I64 fuf_flags=0)
{//$LK,"FUF_JUST_DIRS",A="MN:FUF_JUST_DIRS"$, $LK,"FUF_JUST_FILES",A="MN:FUF_JUST_FILES"$
CDirEntry *buf,*buf2,*ptr;
U8 dname[CDIR_FILENAME_LEN];
@@ -287,7 +288,7 @@ U0 RedSeaFreeClusters(CDrv *dv,I64 c,I64 cnt)
c++;
}
DrvMapBlkClean(dv);
if (unlock)
DrvUnlock(dv);
if (unlock_break)
@@ -364,11 +365,11 @@ Bool RedSeaDirNew(CDrv *dv,U8 *cur_dir,CDirEntry *de,Bool free_old_chain)
cur_dir_cluster=Name2DirCluster(dv,cur_dir);
buf2=MAlloc(BLK_SIZE);
RBlks(dv,buf2,cur_dir_cluster,1);
ptr=buf2(U8 *)-offset(CDirEntry.start);
buf=MAlloc(ptr->size);
RBlks(dv,buf,cur_dir_cluster,ptr->size>>BLK_SIZE_BITS);
dir_size=ptr->size;
ptr=buf(U8 *)-offset(CDirEntry.start)+CDIR_SIZE;
Free(buf2);
@@ -406,7 +407,7 @@ Bool RedSeaDirNew(CDrv *dv,U8 *cur_dir,CDirEntry *de,Bool free_old_chain)
parent_dir=StrNew("/");
}
if (RedSeaFileFind(dv,Name2DirCluster(dv,parent_dir),
temp,&de2,FUF_JUST_DIRS)) {
temp,&de2,FUF_JUST_DIRS)) {
de2.cluster=c;
de2.size=dir_size;
RedSeaDirNew(dv,parent_dir,&de2,FALSE);
@@ -427,12 +428,12 @@ Bool RedSeaDirNew(CDrv *dv,U8 *cur_dir,CDirEntry *de,Bool free_old_chain)
if (!StrCmp(de->name,ptr->name)) {
if (free_old_chain)
RedSeaFreeClusters(dv,ptr->cluster,
(ptr->size+BLK_SIZE-1)>>BLK_SIZE_BITS);
(ptr->size+BLK_SIZE-1)>>BLK_SIZE_BITS);
if (!written)
MemCpy(&ptr->start,&de->start,CDIR_SIZE);
else
ptr->attr|=RS_ATTR_DELETED;
WBlks(dv,buf(U8 *)+j<<BLK_SIZE_BITS,cur_dir_cluster+j,1);
WBlks(dv,buf(U8 *)+j<<BLK_SIZE_BITS,cur_dir_cluster+j,1);
break;
}
}
@@ -468,12 +469,12 @@ I64 RedSeaFilesDel(CDrv *dv,U8 *cur_dir,U8 *files_find_mask,I64 fuf_flags,
cur_dir_cluster=Name2DirCluster(dv,cur_dir);
buf2=MAlloc(BLK_SIZE);
RBlks(dv,buf2,cur_dir_cluster,1);
ptr=buf2(U8 *)-offset(CDirEntry.start);
buf=MAlloc(ptr->size);
RBlks(dv,buf,cur_dir_cluster,ptr->size>>BLK_SIZE_BITS);
Free(buf2);
ptr=buf(U8 *)-offset(CDirEntry.start);
*ptr->name='.';
ptr->name[1]=0;
@@ -481,14 +482,15 @@ I64 RedSeaFilesDel(CDrv *dv,U8 *cur_dir,U8 *files_find_mask,I64 fuf_flags,
if (!(ch=*ptr->name))
break;
else if (!(ptr->attr & RS_ATTR_DELETED) && ch!='.' && (del_dir ||
!(ptr->attr & RS_ATTR_DIR)) &&
FilesFindMatch(ptr->name,files_find_mask,fuf_flags)) {
!(ptr->attr & RS_ATTR_DIR)) &&
FilesFindMatch(ptr->name,files_find_mask,fuf_flags)) {
if (!(ptr->attr & RS_ATTR_DIR)) result++;
if (print_msg)
"Del %s\n",ptr->name;
ptr->attr|=RS_ATTR_DELETED;
WBlks(dv,buf(U8 *)+j<<BLK_SIZE_BITS,cur_dir_cluster+j,1);
RedSeaFreeClusters(dv,ptr->cluster,(ptr->size+BLK_SIZE-1)>>BLK_SIZE_BITS);
RedSeaFreeClusters(dv,ptr->cluster,
(ptr->size+BLK_SIZE-1)>>BLK_SIZE_BITS);
}
ptr(U8 *)+=CDIR_SIZE;
if (++i>=n) {
@@ -536,7 +538,8 @@ I64 RedSeaFileWrite(CDrv *dv,U8 *cur_dir,U8 *name,U8 *buf,I64 size,
return c;
}
CDirEntry *RedSeaFilesFind(U8 *files_find_mask,I64 fuf_flags,CDirEntry *parent=NULL)
CDirEntry *RedSeaFilesFind(U8 *files_find_mask,I64 fuf_flags,
CDirEntry *parent=NULL)
{
CDrv *dv=Fs->cur_dv;
CDirEntry *buf,*buf2,*ptr,*result=NULL,*tempde;
@@ -548,12 +551,12 @@ CDirEntry *RedSeaFilesFind(U8 *files_find_mask,I64 fuf_flags,CDirEntry *parent=N
cur_dir_cluster=Name2DirCluster(dv,Fs->cur_dir);
buf2=MAlloc(BLK_SIZE);
RBlks(dv,buf2,cur_dir_cluster,1);
ptr=buf2(U8 *)-offset(CDirEntry.start);
buf=MAlloc(ptr->size);
RBlks(dv,buf,cur_dir_cluster,ptr->size>>BLK_SIZE_BITS);
Free(buf2);
ptr=buf(U8 *)-offset(CDirEntry.start);
*ptr->name='.';
ptr->name[1]=0;
@@ -567,7 +570,8 @@ CDirEntry *RedSeaFilesFind(U8 *files_find_mask,I64 fuf_flags,CDirEntry *parent=N
tempde=CAlloc(sizeof(CDirEntry));
MemCpy(&tempde->start,&ptr->start,CDIR_SIZE);
tempde->parent=parent;
if (Bt(&fuf_flags,FUf_RECURSE) && tempde->attr&RS_ATTR_DIR && *tempde->name!='.') {
if (Bt(&fuf_flags,FUf_RECURSE) && tempde->attr&RS_ATTR_DIR &&
*tempde->name!='.') {
tempde->next=result;
result=tempde;
tempde->full_name=DirNameAbs(tempde->name);
@@ -577,9 +581,11 @@ CDirEntry *RedSeaFilesFind(U8 *files_find_mask,I64 fuf_flags,CDirEntry *parent=N
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)) {
} 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;
tempde->full_name=FileNameAbs(tempde->name);
@@ -611,7 +617,7 @@ Bool RedSeaMkDir(CDrv *dv,U8 *cur_dir,U8 *name)
d_native->size=size;
d_native->datetime=Now;
d_native(U8 *)+=CDIR_SIZE;
d_native->attr=RS_ATTR_DIR|RS_ATTR_CONTIGUOUS;
*d_native->name='.';
d_native->name[1]='.';
Kernel/EdLite.CPP
+1 -1
View File
@@ -232,7 +232,7 @@ Bool EdLite(U8 *filename,I64 num=1,I64 edf_dof_flags=0)
}
break;
default:
if (Bt(chars_bitmap_getkey,ch)) {
if (Bt(chars_bmp_getkey,ch)) {
if (cur_line==&root) {
cur_line=MAlloc(sizeof(CLine));
cur_line->line=StrNew("");
Kernel/Font8x8.CPP
+257 -257
View File
@@ -1,260 +1,260 @@
//See $LK,"::/Doc/Credits.TXT"$.
U8 sys_font_8x8[256*8]= {
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,//
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//
0x18,0x3C,0x3C,0x18,0x18,0x00,0x18,0x00,//!
0x36,0x36,0x36,0x00,0x00,0x00,0x00,0x00,//"
0x6C,0x6C,0xFE,0x6C,0xFE,0x6C,0x6C,0x00,//#
0x30,0xFC,0x16,0x7C,0xD0,0x7E,0x18,0x00,//$$
0x06,0x66,0x30,0x18,0x0C,0x66,0x60,0x00,//%
0x1C,0x36,0x36,0x1C,0xB6,0x66,0xDC,0x00,//&
0x18,0x18,0x18,0x00,0x00,0x00,0x00,0x00,//'
0x30,0x18,0x0C,0x0C,0x0C,0x18,0x30,0x00,//(
0x0C,0x18,0x30,0x30,0x30,0x18,0x0C,0x00,//)
0x00,0x18,0x7E,0x3C,0x7E,0x18,0x00,0x00,//*
0x00,0x18,0x18,0x7E,0x18,0x18,0x00,0x00,//+
0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x0C,//,
0x00,0x00,0x00,0x7E,0x00,0x00,0x00,0x00,//-
0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x00,//.
0x00,0x60,0x30,0x18,0x0C,0x06,0x00,0x00,///
0x3C,0x66,0x76,0x7E,0x6E,0x66,0x3C,0x00,//0
0x18,0x1C,0x18,0x18,0x18,0x18,0x7E,0x00,//1
0x3C,0x66,0x60,0x30,0x18,0x0C,0x7E,0x00,//2
0x3C,0x66,0x60,0x38,0x60,0x66,0x3C,0x00,//3
0x30,0x38,0x3C,0x36,0x7E,0x30,0x30,0x00,//4
0x7E,0x06,0x3E,0x60,0x60,0x66,0x3C,0x00,//5
0x38,0x0C,0x06,0x3E,0x66,0x66,0x3C,0x00,//6
0x7E,0x60,0x30,0x18,0x0C,0x0C,0x0C,0x00,//7
0x3C,0x66,0x66,0x3C,0x66,0x66,0x3C,0x00,//8
0x3C,0x66,0x66,0x7C,0x60,0x30,0x1C,0x00,//9
0x00,0x00,0x18,0x18,0x00,0x18,0x18,0x00,//:
0x00,0x00,0x18,0x18,0x00,0x18,0x18,0x0C,//;
0x30,0x18,0x0C,0x06,0x0C,0x18,0x30,0x00,//<
0x00,0x00,0x7E,0x00,0x7E,0x00,0x00,0x00,//=
0x0C,0x18,0x30,0x60,0x30,0x18,0x0C,0x00,//>
0x3C,0x66,0x30,0x18,0x18,0x00,0x18,0x00,//?
0x3C,0x66,0x76,0x56,0x76,0x06,0x3C,0x00,//@
0x3C,0x66,0x66,0x7E,0x66,0x66,0x66,0x00,//A
0x3E,0x66,0x66,0x3E,0x66,0x66,0x3E,0x00,//B
0x3C,0x66,0x06,0x06,0x06,0x66,0x3C,0x00,//C
0x1E,0x36,0x66,0x66,0x66,0x36,0x1E,0x00,//D
0x7E,0x06,0x06,0x3E,0x06,0x06,0x7E,0x00,//E
0x7E,0x06,0x06,0x3E,0x06,0x06,0x06,0x00,//F
0x3C,0x66,0x06,0x76,0x66,0x66,0x3C,0x00,//G
0x66,0x66,0x66,0x7E,0x66,0x66,0x66,0x00,//H
0x7E,0x18,0x18,0x18,0x18,0x18,0x7E,0x00,//I
0x7C,0x30,0x30,0x30,0x30,0x36,0x1C,0x00,//J
0x66,0x36,0x1E,0x0E,0x1E,0x36,0x66,0x00,//K
0x06,0x06,0x06,0x06,0x06,0x06,0x7E,0x00,//L
0xC6,0xEE,0xFE,0xD6,0xD6,0xC6,0xC6,0x00,//M
0x66,0x66,0x6E,0x7E,0x76,0x66,0x66,0x00,//N
0x3C,0x66,0x66,0x66,0x66,0x66,0x3C,0x00,//O
0x3E,0x66,0x66,0x3E,0x06,0x06,0x06,0x00,//P
0x3C,0x66,0x66,0x66,0x56,0x36,0x6C,0x00,//Q
0x3E,0x66,0x66,0x3E,0x36,0x66,0x66,0x00,//R
0x3C,0x66,0x06,0x3C,0x60,0x66,0x3C,0x00,//S
0x7E,0x18,0x18,0x18,0x18,0x18,0x18,0x00,//T
0x66,0x66,0x66,0x66,0x66,0x66,0x3C,0x00,//U
0x66,0x66,0x66,0x66,0x66,0x3C,0x18,0x00,//V
0xC6,0xC6,0xD6,0xD6,0xFE,0xEE,0xC6,0x00,//W
0x66,0x66,0x3C,0x18,0x3C,0x66,0x66,0x00,//X
0x66,0x66,0x66,0x3C,0x18,0x18,0x18,0x00,//Y
0x7E,0x60,0x30,0x18,0x0C,0x06,0x7E,0x00,//Z
0x3E,0x06,0x06,0x06,0x06,0x06,0x3E,0x00,//[
0x00,0x06,0x0C,0x18,0x30,0x60,0x00,0x00,//\
0x7C,0x60,0x60,0x60,0x60,0x60,0x7C,0x00,//]
0x3C,0x66,0x00,0x00,0x00,0x00,0x00,0x00,//^
0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xFF,//_
0x0C,0x18,0x30,0x00,0x00,0x00,0x00,0x00,//`
0x00,0x00,0x3C,0x60,0x7C,0x66,0x7C,0x00,//a
0x06,0x06,0x3E,0x66,0x66,0x66,0x3E,0x00,//b
0x00,0x00,0x3C,0x66,0x06,0x66,0x3C,0x00,//c
0x60,0x60,0x7C,0x66,0x66,0x66,0x7C,0x00,//d
0x00,0x00,0x3C,0x66,0x7E,0x06,0x3C,0x00,//e
0x38,0x0C,0x0C,0x3E,0x0C,0x0C,0x0C,0x00,//f
0x00,0x00,0x7C,0x66,0x66,0x7C,0x60,0x3C,//g
0x06,0x06,0x3E,0x66,0x66,0x66,0x66,0x00,//h
0x18,0x00,0x1C,0x18,0x18,0x18,0x3C,0x00,//i
0x18,0x00,0x1C,0x18,0x18,0x18,0x18,0x0E,//j
0x06,0x06,0x66,0x36,0x1E,0x36,0x66,0x00,//k
0x1C,0x18,0x18,0x18,0x18,0x18,0x3C,0x00,//l
0x00,0x00,0x6C,0xFE,0xD6,0xD6,0xC6,0x00,//m
0x00,0x00,0x3E,0x66,0x66,0x66,0x66,0x00,//n
0x00,0x00,0x3C,0x66,0x66,0x66,0x3C,0x00,//o
0x00,0x00,0x3E,0x66,0x66,0x3E,0x06,0x06,//p
0x00,0x00,0x7C,0x66,0x66,0x7C,0x60,0xE0,//q
0x00,0x00,0x36,0x6E,0x06,0x06,0x06,0x00,//r
0x00,0x00,0x7C,0x06,0x3C,0x60,0x3E,0x00,//s
0x0C,0x0C,0x3E,0x0C,0x0C,0x0C,0x38,0x00,//t
0x00,0x00,0x66,0x66,0x66,0x66,0x7C,0x00,//u
0x00,0x00,0x66,0x66,0x66,0x3C,0x18,0x00,//v
0x00,0x00,0xC6,0xD6,0xD6,0xFE,0x6C,0x00,//w
0x00,0x00,0x66,0x3C,0x18,0x3C,0x66,0x00,//x
0x00,0x00,0x66,0x66,0x66,0x7C,0x60,0x3C,//y
0x00,0x00,0x7E,0x30,0x18,0x0C,0x7E,0x00,//z
0x30,0x18,0x18,0x0E,0x18,0x18,0x30,0x00,//{
0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x00,//|
0x0C,0x18,0x18,0x70,0x18,0x18,0x0C,0x00,//}
0x8C,0xD6,0x62,0x00,0x00,0x00,0x00,0x00,//~
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0x1E,0x33,0x03,0x33,0x1E,0x18,0x30,0x1E,//€
0x00,0x33,0x00,0x33,0x33,0x33,0x7E,0x00,//�
0x38,0x00,0x1E,0x33,0x3F,0x03,0x1E,0x00,//‚
0x7E,0xC3,0x3C,0x60,0x7C,0x66,0xFC,0x00,//ƒ
0x33,0x00,0x1E,0x30,0x3E,0x33,0x7E,0x00,//„
0x07,0x00,0x1E,0x30,0x3E,0x33,0x7E,0x00,//…
0x0C,0x0C,0x1E,0x30,0x3E,0x33,0x7E,0x00,//†
0x00,0x00,0x3E,0x03,0x03,0x3E,0x60,0x3C,//‡
0x7E,0xC3,0x3C,0x66,0x7E,0x06,0x3C,0x00,//ˆ
0x33,0x00,0x1E,0x33,0x3F,0x03,0x1E,0x00,//‰
0x07,0x00,0x1E,0x33,0x3F,0x03,0x1E,0x00,//Š
0x33,0x00,0x0E,0x0C,0x0C,0x0C,0x1E,0x00,//‹
0x3E,0x63,0x1C,0x18,0x18,0x18,0x3C,0x00,//Œ
0x07,0x00,0x0E,0x0C,0x0C,0x0C,0x1E,0x00,//�
0x33,0x0C,0x1E,0x33,0x33,0x3F,0x33,0x00,//Ž
0x0C,0x0C,0x00,0x1E,0x33,0x3F,0x33,0x00,//�
0x38,0x00,0x3F,0x06,0x1E,0x06,0x3F,0x00,//�
0x00,0x00,0xFE,0x30,0xFE,0x33,0xFE,0x00,//‘
0x7C,0x36,0x33,0x7F,0x33,0x33,0x73,0x00,//’
0x1E,0x33,0x00,0x1E,0x33,0x33,0x1E,0x00,//“
0x00,0x33,0x00,0x1E,0x33,0x33,0x1E,0x00,//”
0x00,0x07,0x00,0x1E,0x33,0x33,0x1E,0x00,//•
0x1E,0x33,0x00,0x33,0x33,0x33,0x7E,0x00,//–
0x00,0x07,0x00,0x33,0x33,0x33,0x7E,0x00,//—
0x00,0x33,0x00,0x33,0x33,0x3F,0x30,0x1F,//˜
0x63,0x1C,0x3E,0x63,0x63,0x3E,0x1C,0x00,//™
0x33,0x00,0x33,0x33,0x33,0x33,0x1E,0x00,//š
0x18,0x18,0x7E,0x03,0x03,0x7E,0x18,0x18,//›
0x1C,0x36,0x26,0x0F,0x06,0x67,0x3F,0x00,//œ
0x33,0x33,0x1E,0x3F,0x0C,0x3F,0x0C,0x00,//�
0x0F,0x1B,0x1B,0x2F,0x33,0x7B,0x33,0x70,//ž
0x70,0xD8,0x18,0x7E,0x18,0x18,0x1B,0x0E,//Ÿ
0x38,0x00,0x1E,0x30,0x3E,0x33,0x7E,0x00,// 
0x1C,0x00,0x0E,0x0C,0x0C,0x0C,0x1E,0x00,//¡
0x00,0x38,0x00,0x1E,0x33,0x33,0x1E,0x00,//¢
0x00,0x38,0x00,0x33,0x33,0x33,0x7E,0x00,//£
0x00,0x1F,0x00,0x1F,0x33,0x33,0x33,0x00,//¤
0x3F,0x00,0x33,0x37,0x3F,0x3B,0x33,0x00,//¥
0x3C,0x36,0x36,0x7C,0x00,0x7E,0x00,0x00,//¦
0x3C,0x66,0x66,0x3C,0x00,0x7E,0x00,0x00,//§
0x0C,0x00,0x0C,0x06,0x03,0x33,0x1E,0x00,//¨
0x00,0x00,0x00,0x3F,0x03,0x03,0x00,0x00,//©
0x00,0x00,0x00,0x3F,0x30,0x30,0x00,0x00,//ª
0x63,0x33,0x1B,0x7C,0xC6,0x73,0x19,0xF8,//«
0x63,0x33,0x1B,0xCF,0xE6,0xF3,0xF9,0xC0,//¬
0x00,0x18,0x00,0x18,0x18,0x3C,0x3C,0x18,//­
0x00,0xCC,0x66,0x33,0x66,0xCC,0x00,0x00,//®
0x00,0x33,0x66,0xCC,0x66,0x33,0x00,0x00,//¯
0x44,0x11,0x44,0x11,0x44,0x11,0x44,0x11,//°
0xAA,0x55,0xAA,0x55,0xAA,0x55,0xAA,0x55,//±
0xBB,0xEE,0xBB,0xEE,0xBB,0xEE,0xBB,0xEE,//²
0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,//³
0x18,0x18,0x18,0x18,0x1F,0x18,0x18,0x18,//´
0x18,0x18,0x1F,0x18,0x1F,0x18,0x18,0x18,//µ
0x6C,0x6C,0x6C,0x6C,0x6F,0x6C,0x6C,0x6C,//¶
0x00,0x00,0x00,0x00,0x7F,0x6C,0x6C,0x6C,//·
0x00,0x00,0x1F,0x18,0x1F,0x18,0x18,0x18,//¸
0x6C,0x6C,0x6F,0x60,0x6F,0x6C,0x6C,0x6C,//¹
0x6C,0x6C,0x6C,0x6C,0x6C,0x6C,0x6C,0x6C,//º
0x00,0x00,0x7F,0x60,0x6F,0x6C,0x6C,0x6C,//»
0x6C,0x6C,0x6F,0x60,0x7F,0x00,0x00,0x00,//¼
0x6C,0x6C,0x6C,0x6C,0x7F,0x00,0x00,0x00,//½
0x18,0x18,0x1F,0x18,0x1F,0x00,0x00,0x00,//¾
0x00,0x00,0x00,0x00,0x1F,0x18,0x18,0x18,//¿
0x18,0x18,0x18,0x18,0xF8,0x00,0x00,0x00,//À
0x18,0x18,0x18,0x18,0xFF,0x00,0x00,0x00,//Á
0x00,0x00,0x00,0x00,0xFF,0x18,0x18,0x18,//Â
0x18,0x18,0x18,0x18,0xF8,0x18,0x18,0x18,//Ã
0x00,0x00,0x00,0x00,0xFF,0x00,0x00,0x00,//Ä
0x18,0x18,0x18,0x18,0xFF,0x18,0x18,0x18,//Å
0x18,0x18,0xF8,0x18,0xF8,0x18,0x18,0x18,//Æ
0x6C,0x6C,0x6C,0x6C,0xEC,0x6C,0x6C,0x6C,//Ç
0x6C,0x6C,0xEC,0x0C,0xFC,0x00,0x00,0x00,//È
0x00,0x00,0xFC,0x0C,0xEC,0x6C,0x6C,0x6C,//É
0x6C,0x6C,0xEF,0x00,0xFF,0x00,0x00,0x00,//Ê
0x00,0x00,0xFF,0x00,0xEF,0x6C,0x6C,0x6C,//Ë
0x6C,0x6C,0xEC,0x0C,0xEC,0x6C,0x6C,0x6C,//Ì
0x00,0x00,0xFF,0x00,0xFF,0x00,0x00,0x00,//Í
0x6C,0x6C,0xEF,0x00,0xEF,0x6C,0x6C,0x6C,//Î
0x18,0x18,0xFF,0x00,0xFF,0x00,0x00,0x00,//Ï
0x6C,0x6C,0x6C,0x6C,0xFF,0x00,0x00,0x00,//Ð
0x00,0x00,0xFF,0x00,0xFF,0x18,0x18,0x18,//Ñ
0x00,0x00,0x00,0x00,0xFF,0x6C,0x6C,0x6C,//Ò
0x6C,0x6C,0x6C,0x6C,0xFC,0x00,0x00,0x00,//Ó
0x18,0x18,0xF8,0x18,0xF8,0x00,0x00,0x00,//Ô
0x00,0x00,0xF8,0x18,0xF8,0x18,0x18,0x18,//Õ
0x00,0x00,0x00,0x00,0xFC,0x6C,0x6C,0x6C,//Ö
0x6C,0x6C,0x6C,0x6C,0xEF,0x6C,0x6C,0x6C,//×
0x18,0x18,0xFF,0x00,0xFF,0x18,0x18,0x18,//Ø
0x18,0x18,0x18,0x18,0x1F,0x00,0x00,0x00,//Ù
0x00,0x00,0x00,0x00,0xF8,0x18,0x18,0x18,//Ú
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,//Û
0x00,0x00,0x00,0x00,0xFF,0xFF,0xFF,0xFF,//Ü
0x0F,0x0F,0x0F,0x0F,0x0F,0x0F,0x0F,0x0F,//Ý
0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,//Þ
0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00,//ß
0x00,0x00,0x6E,0x3B,0x13,0x3B,0x6E,0x00,//à
0x00,0x1E,0x33,0x1F,0x33,0x1F,0x03,0x03,//á
0x00,0x7F,0x63,0x03,0x03,0x03,0x03,0x00,//â
0x00,0x7F,0x36,0x36,0x36,0x36,0x36,0x00,//ã
0x7F,0x66,0x0C,0x18,0x0C,0x66,0x7F,0x00,//ä
0x00,0x00,0x7E,0x33,0x33,0x33,0x1E,0x00,//å
0x00,0x66,0x66,0x66,0x66,0x3E,0x06,0x03,//æ
0x00,0x6E,0x3B,0x18,0x18,0x18,0x18,0x00,//ç
0x3F,0x0C,0x1E,0x33,0x33,0x1E,0x0C,0x3F,//è
0x1C,0x36,0x63,0x7F,0x63,0x36,0x1C,0x00,//é
0x1C,0x36,0x63,0x63,0x36,0x36,0x77,0x00,//ê
0x38,0x0C,0x18,0x3E,0x33,0x33,0x1E,0x00,//ë
0x00,0x00,0x7E,0xDB,0xDB,0x7E,0x00,0x00,//ì
0x60,0x30,0x7E,0xDB,0xDB,0x7E,0x06,0x03,//í
0x3C,0x06,0x03,0x3F,0x03,0x06,0x3C,0x00,//î
0x1E,0x33,0x33,0x33,0x33,0x33,0x33,0x00,//ï
0x00,0x3F,0x00,0x3F,0x00,0x3F,0x00,0x00,//ð
0x0C,0x0C,0x3F,0x0C,0x0C,0x00,0x3F,0x00,//ñ
0x06,0x0C,0x18,0x0C,0x06,0x00,0x3F,0x00,//ò
0x18,0x0C,0x06,0x0C,0x18,0x00,0x3F,0x00,//ó
0x70,0xD8,0xD8,0x18,0x18,0x18,0x18,0x18,//ô
0x18,0x18,0x18,0x18,0x18,0x1B,0x1B,0x0E,//õ
0x0C,0x0C,0x00,0x3F,0x00,0x0C,0x0C,0x00,//ö
0x00,0x4E,0x39,0x00,0x4E,0x39,0x00,0x00,//÷
0x1C,0x36,0x36,0x1C,0x00,0x00,0x00,0x00,//ø
0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00,//ù
0x00,0x00,0x00,0x00,0x18,0x00,0x00,0x00,//ú
0xF0,0x30,0x30,0x30,0x37,0x36,0x3C,0x38,//û
0x1E,0x36,0x36,0x36,0x36,0x00,0x00,0x00,//ü
0x1E,0x30,0x1C,0x06,0x3E,0x00,0x00,0x00,//ý
0x00,0x00,0x3C,0x3C,0x3C,0x3C,0x00,0x00,//þ
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//ÿ
U64 sys_font_8x8[256]= {
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0008000000000000,//
0x0000000000000000,//
0x00180018183C3C18,//!
0x0000000000363636,//"
0x006C6CFE6CFE6C6C,//#
0x00187ED07C16FC30,//$$
0x0060660C18306606,//%
0x00DC66B61C36361C,//&
0x0000000000181818,//'
0x0030180C0C0C1830,//(
0x000C18303030180C,//)
0x0000187E3C7E1800,//*
0x000018187E181800,//+
0x0C18180000000000,//,
0x000000007E000000,//-
0x0018180000000000,//.
0x0000060C18306000,///
0x003C666E7E76663C,//0
0x007E181818181C18,//1
0x007E0C183060663C,//2
0x003C66603860663C,//3
0x0030307E363C3830,//4
0x003C6660603E067E,//5
0x003C66663E060C38,//6
0x000C0C0C1830607E,//7
0x003C66663C66663C,//8
0x001C30607C66663C,//9
0x0018180018180000,//:
0x0C18180018180000,//;
0x0030180C060C1830,//<
0x0000007E007E0000,//=
0x000C18306030180C,//>
0x001800181830663C,//?
0x003C06765676663C,//@
0x006666667E66663C,//A
0x003E66663E66663E,//B
0x003C66060606663C,//C
0x001E36666666361E,//D
0x007E06063E06067E,//E
0x000606063E06067E,//F
0x003C66667606663C,//G
0x006666667E666666,//H
0x007E18181818187E,//I
0x001C36303030307C,//J
0x0066361E0E1E3666,//K
0x007E060606060606,//L
0x00C6C6D6D6FEEEC6,//M
0x006666767E6E6666,//N
0x003C66666666663C,//O
0x000606063E66663E,//P
0x006C36566666663C,//Q
0x006666363E66663E,//R
0x003C66603C06663C,//S
0x001818181818187E,//T
0x003C666666666666,//U
0x00183C6666666666,//V
0x00C6EEFED6D6C6C6,//W
0x0066663C183C6666,//X
0x001818183C666666,//Y
0x007E060C1830607E,//Z
0x003E06060606063E,//[
0x00006030180C0600,//\
0x007C60606060607C,//]
0x000000000000663C,//^
0xFFFF000000000000,//_
0x000000000030180C,//`
0x007C667C603C0000,//a
0x003E6666663E0606,//b
0x003C6606663C0000,//c
0x007C6666667C6060,//d
0x003C067E663C0000,//e
0x000C0C0C3E0C0C38,//f
0x3C607C66667C0000,//g
0x00666666663E0606,//h
0x003C1818181C0018,//i
0x0E181818181C0018,//j
0x0066361E36660606,//k
0x003C18181818181C,//l
0x00C6D6D6FE6C0000,//m
0x00666666663E0000,//n
0x003C6666663C0000,//o
0x06063E66663E0000,//p
0xE0607C66667C0000,//q
0x000606066E360000,//r
0x003E603C067C0000,//s
0x00380C0C0C3E0C0C,//t
0x007C666666660000,//u
0x00183C6666660000,//v
0x006CFED6D6C60000,//w
0x00663C183C660000,//x
0x3C607C6666660000,//y
0x007E0C18307E0000,//z
0x003018180E181830,//{
0x0018181818181818,//|
0x000C18187018180C,//}
0x000000000062D68C,//~
0xFFFFFFFFFFFFFFFF,
0x1E30181E3303331E,//€
0x007E333333003300,//�
0x001E033F331E0038,//‚
0x00FC667C603CC37E,//ƒ
0x007E333E301E0033,//„
0x007E333E301E0007,//…
0x007E333E301E0C0C,//†
0x3C603E03033E0000,//‡
0x003C067E663CC37E,//ˆ
0x001E033F331E0033,//‰
0x001E033F331E0007,//Š
0x001E0C0C0C0E0033,//‹
0x003C1818181C633E,//Œ
0x001E0C0C0C0E0007,//�
0x00333F33331E0C33,//Ž
0x00333F331E000C0C,//�
0x003F061E063F0038,//�
0x00FE33FE30FE0000,//‘
0x007333337F33367C,//’
0x001E33331E00331E,//“
0x001E33331E003300,//”
0x001E33331E000700,//•
0x007E33333300331E,//–
0x007E333333000700,//—
0x1F303F3333003300,//˜
0x001C3E63633E1C63,//™
0x001E333333330033,//š
0x18187E03037E1818,//›
0x003F67060F26361C,//œ
0x000C3F0C3F1E3333,//�
0x70337B332F1B1B0F,//ž
0x0E1B18187E18D870,//Ÿ
0x007E333E301E0038,// 
0x001E0C0C0C0E001C,//¡
0x001E33331E003800,//¢
0x007E333333003800,//£
0x003333331F001F00,//¤
0x00333B3F3733003F,//¥
0x00007E007C36363C,//¦
0x00007E003C66663C,//§
0x001E3303060C000C,//¨
0x000003033F000000,//©
0x000030303F000000,//ª
0xF81973C67C1B3363,//«
0xC0F9F3E6CF1B3363,//¬
0x183C3C1818001800,//­
0x0000CC663366CC00,//®
0x00003366CC663300,//¯
0x1144114411441144,//°
0x55AA55AA55AA55AA,//±
0xEEBBEEBBEEBBEEBB,//²
0x1818181818181818,//³
0x1818181F18181818,//´
0x1818181F181F1818,//µ
0x6C6C6C6F6C6C6C6C,//¶
0x6C6C6C7F00000000,//·
0x1818181F181F0000,//¸
0x6C6C6C6F606F6C6C,//¹
0x6C6C6C6C6C6C6C6C,//º
0x6C6C6C6F607F0000,//»
0x0000007F606F6C6C,//¼
0x0000007F6C6C6C6C,//½
0x0000001F181F1818,//¾
0x1818181F00000000,//¿
0x000000F818181818,//À
0x000000FF18181818,//Á
0x181818FF00000000,//Â
0x181818F818181818,//Ã
0x000000FF00000000,//Ä
0x181818FF18181818,//Å
0x181818F818F81818,//Æ
0x6C6C6CEC6C6C6C6C,//Ç
0x000000FC0CEC6C6C,//È
0x6C6C6CEC0CFC0000,//É
0x000000FF00EF6C6C,//Ê
0x6C6C6CEF00FF0000,//Ë
0x6C6C6CEC0CEC6C6C,//Ì
0x000000FF00FF0000,//Í
0x6C6C6CEF00EF6C6C,//Î
0x000000FF00FF1818,//Ï
0x000000FF6C6C6C6C,//Ð
0x181818FF00FF0000,//Ñ
0x6C6C6CFF00000000,//Ò
0x000000FC6C6C6C6C,//Ó
0x000000F818F81818,//Ô
0x181818F818F80000,//Õ
0x6C6C6CFC00000000,//Ö
0x6C6C6CEF6C6C6C6C,//×
0x181818FF00FF1818,//Ø
0x0000001F18181818,//Ù
0x181818F800000000,//Ú
0xFFFFFFFFFFFFFFFF,//Û
0xFFFFFFFF00000000,//Ü
0x0F0F0F0F0F0F0F0F,//Ý
0xF0F0F0F0F0F0F0F0,//Þ
0x00000000FFFFFFFF,//ß
0x006E3B133B6E0000,//à
0x03031F331F331E00,//á
0x0003030303637F00,//â
0x0036363636367F00,//ã
0x007F660C180C667F,//ä
0x001E3333337E0000,//å
0x03063E6666666600,//æ
0x00181818183B6E00,//ç
0x3F0C1E33331E0C3F,//è
0x001C36637F63361C,//é
0x007736366363361C,//ê
0x001E33333E180C38,//ë
0x00007EDBDB7E0000,//ì
0x03067EDBDB7E3060,//í
0x003C06033F03063C,//î
0x003333333333331E,//ï
0x00003F003F003F00,//ð
0x003F000C0C3F0C0C,//ñ
0x003F00060C180C06,//ò
0x003F00180C060C18,//ó
0x1818181818D8D870,//ô
0x0E1B1B1818181818,//õ
0x000C0C003F000C0C,//ö
0x0000394E00394E00,//÷
0x000000001C36361C,//ø
0x0000001818000000,//ù
0x0000001800000000,//ú
0x383C3637303030F0,//û
0x000000363636361E,//ü
0x0000003E061C301E,//ý
0x00003C3C3C3C0000,//þ
0x0000000000000000,//ÿ
};
Kernel/Ints.CPP
+2 -3
View File
@@ -1,5 +1,4 @@
asm {
USE64
SYS_MP_CRASH_HANDLER_ADDR:: //Forward reference to work around compiler
DU32 &MPCrash;
@@ -106,7 +105,7 @@ U8 *IntEntryGet(I64 irq)
U8 *IntEntrySet(I64 irq,U0 (*fp_new_handler)(),I64 type=IDTET_IRQ,I64 dpl=0)
{//Set interrupt vector. See $LK,"IDTET_IRQ",A="MN:IDTET_IRQ"$.
//See $LK,"::/Demo/Lectures/InterruptDemo.CPP"$.
//See $LK,"::/Demo/MultiCore/Interrupts.CPP"$.
//See $LK,"::/Demo/MultiCore/Interrupts.CPP"$.
I64 fp=fp_new_handler;
U8 *result,*dst;
PUSHFD
@@ -170,7 +169,7 @@ U0 IntInit1()
temp_ptr.limit=256*16-1;
temp_ptr.base =dev.idt;
SetRAX(&temp_ptr);
LIDT U64 [RAX]
LIDT U64 [RAX]
}
U0 IntInit2()
Kernel/KCfg.CPP
+44 -43
View File
@@ -22,19 +22,19 @@ class CKernelCfg
U8 *boot_rescue_drv_file,*boot_rescue_drv_start;
Bool opts[CFG_NUM_OPTIONS];
U8 mem_init_val,heap_init_val,var_init_val,
boot_drv_let,auto_mount_ide_hd_let,auto_mount_ide_cd_let;
boot_drv_let,auto_mount_ide_hd_let,auto_mount_ide_cd_let;
Bool cdrom_ports_pmt;
};
CDoc *KernelCfgAddDev(CKernelCfg *c)
{
I64 ch,num_hints,first_drv_num,type,unit,cnt=0;
U8 blks_buf[256],addr_buf[256],base0_buf[128],base1_buf[128];
U8 blks_buf[STR_LEN],addr_buf[STR_LEN],base0_buf[STR_LEN],base1_buf[STR_LEN];
CATARep *root=NULL,*tempha;
CDoc *doc=DocNew;
Bool make_free;
"\n\nIn anticipation of the drives you will\n"
"\n\nIn anticipation of the drives you will\n"
"define shortly, enter the drive letter\n"
"of the drive with the account directory.\n"
"\n($$PURPLE$$<ENTER>$$FG$$ for cur drv) Home Drv:";
@@ -44,49 +44,49 @@ CDoc *KernelCfgAddDev(CKernelCfg *c)
else
c->boot_drv_let=Drv2Let(Fs->cur_dv);
"\n\n$$BK,1$$$$PURPLE$$Mount drives so they will be present when "
"\n\n$$BK,1$$$$PURPLE$$Mount drives so they will be present when "
"you boot.$$FG$$$$BK,0$$\n";
do {
"\n****** Mount Drives ******\n"
"The first drive letter is the letter\n"
"of the first partition. If adding\n"
"a hard drive, you should pick 'C'.\n"
"If more than one partition is present\n"
"they will be lettered in sequence.\n"
"\nFirst Drive Letter ($$PURPLE$$<ENTER>$$FG$$ to exit):";
"\n****** Mount Drives ******\n"
"The first drive letter is the letter\n"
"of the first partition. If adding\n"
"a hard drive, you should pick 'C'.\n"
"If more than one partition is present\n"
"they will be lettered in sequence.\n"
"\nFirst Drive Letter ($$PURPLE$$<ENTER>$$FG$$ to exit):";
first_drv_num=ToUpper(GetChar)-'A';
'\n';
if (0<=first_drv_num<NUM_DRVS) {
"\t$$PURPLE$$1$$FG$$=RAM\n\t$$PURPLE$$2$$FG$$=ATA(Harddisk)\n"
"\t$$PURPLE$$3$$FG$$=ATAPI(CD-ROM)\nType:";
"\t$$PURPLE$$1$$FG$$=RAM\n\t$$PURPLE$$2$$FG$$=ATA(Harddisk)\n"
"\t$$PURPLE$$3$$FG$$=ATAPI(CD-ROM)\nType:";
type=GetChar-'0';
'\n';
unit=0;
if (type==BDT_RAM) {
"Addr of RAM disk ($$PURPLE$$<ENTER>$$FG$$ to MAlloc):";
GetS(addr_buf,256);
GetS(addr_buf,STR_LEN);
"Blks of 512 bytes:";
GetS(blks_buf,256);
GetS(blks_buf,STR_LEN);
} else if (type==BDT_ATA ||
type==BDT_ATAPI) {
type==BDT_ATAPI) {
num_hints=ATARep(,,&root);
if (type==BDT_ATAPI) {
"<ENTER> to use booted CD-ROM\n";
if (num_hints)
"Enter dev number or\nport with $$PURPLE$$0x$$FG$$ prefix.\n"
"I/O Port Base0:\n";
"Enter dev number or\nport with $$PURPLE$$0x$$FG$$ prefix.\n"
"I/O Port Base0:\n";
else
"Include $$PURPLE$$0x$$FG$$ prefix.\nI/O Port Base0:\n";
GetS(base0_buf,128);
"Include $$PURPLE$$0x$$FG$$ prefix.\nI/O Port Base0:\n";
GetS(base0_buf,STR_LEN);
} else
do {
if (num_hints)
"Enter dev number or\nport with $$PURPLE$$0x$$FG$$ prefix.\n"
"I/O Port Base0:\n";
"Enter dev number or\nport with $$PURPLE$$0x$$FG$$ prefix.\n"
"I/O Port Base0:\n";
else
"Include $$PURPLE$$0x$$FG$$ prefix.\nI/O Port Base0:\n";
GetS(base0_buf,128);
"Include $$PURPLE$$0x$$FG$$ prefix.\nI/O Port Base0:\n";
GetS(base0_buf,STR_LEN);
} while (!Str2I64(base0_buf));
if (1<=Str2I64(base0_buf)<=num_hints) {
tempha=ATARepFind(root,Str2I64(base0_buf));
@@ -98,11 +98,11 @@ CDoc *KernelCfgAddDev(CKernelCfg *c)
StrCpy(base1_buf,"0");
else
do {
"I/O Port Base1:\n";
GetS(base1_buf,128);
"I/O Port Base1:\n";
GetS(base1_buf,STR_LEN);
} while (!Str2I64(base1_buf));
do {
"\t$$PURPLE$$0$$FG$$=Master\n\t$$PURPLE$$1$$FG$$=Slave\nUnit:";
"\t$$PURPLE$$0$$FG$$=Master\n\t$$PURPLE$$1$$FG$$=Slave\nUnit:";
unit=GetChar-'0';
} while (!(0<=unit<=1));
'\n';
@@ -111,7 +111,7 @@ CDoc *KernelCfgAddDev(CKernelCfg *c)
}
if (BDT_NULL<type<BDT_NUM_TYPES && 0<=unit<=1) {
DocPrint(doc,"bd=BlkDevNextFree(%d,%d);"
"bd->unit=%d;",first_drv_num+'A',type,unit);
"bd->unit=%d;",first_drv_num+'A',type,unit);
if (type==BDT_RAM) {
if (!*addr_buf) StrCpy(addr_buf,"0");
DocPrint(doc,"bd->RAM_dsk=%s;",addr_buf);
@@ -126,7 +126,7 @@ CDoc *KernelCfgAddDev(CKernelCfg *c)
make_free=TRUE;
} else
DocPrint(doc,"bd->base0=%s;bd->base1=%s;",
base0_buf,base1_buf);
base0_buf,base1_buf);
}
DocPrint(doc,"BlkDevAdd(bd,FALSE,%d);",make_free);
cnt++;
@@ -150,16 +150,17 @@ U0 KernelCfgOptions(CKernelCfg *c)
st=GetStr("Option ($$PURPLE$$<ENTER>$$FG$$ when done):","");
i=LstMatch(st,kernel_cfg_options,LMF_IGNORE_CASE);
if (i==CFG_HELP)
"\n"
"$$PURPLE$$MemInit$$FG$$ Initializes memory above 0x100000 to a val at boot.\n"
"$$PURPLE$$HeapInit$$FG$$ Initializes MAlloc() memory to a val.\n"
"$$PURPLE$$VarInit$$FG$$ Initializes glbl var memory to a val.\n"
"$$PURPLE$$NoMP$$FG$$ No multicore.\n"
"$$PURPLE$$TextMode$$FG$$ Text Mode (requires hard reboot).\n"
"$$PURPLE$$DontProbe$$FG$$ Just prompt CD-ROM ports, don't probe.\n"
"$$PURPLE$$AutoMountIDE$$FG$$ AutoMount IDE drives to 'C' and 'T'.\n"
"$$PURPLE$$BootRescueDrv$$FG$$ Include RAM Drv in Kernel.BIN.\n"
"\n";
"\n"
"$$PURPLE$$MemInit$$FG$$ Initializes memory above 0x100000 "
"to a val at boot.\n"
"$$PURPLE$$HeapInit$$FG$$ Initializes MAlloc() memory to a val.\n"
"$$PURPLE$$VarInit$$FG$$ Initializes glbl var memory to a val.\n"
"$$PURPLE$$NoMP$$FG$$ No multicore.\n"
"$$PURPLE$$TextMode$$FG$$ Text Mode (requires hard reboot).\n"
"$$PURPLE$$DontProbe$$FG$$ Just prompt CD-ROM ports, don't probe.\n"
"$$PURPLE$$AutoMountIDE$$FG$$ AutoMount IDE drives to 'C' and 'T'.\n"
"$$PURPLE$$BootRescueDrv$$FG$$ Include RAM Drv in Kernel.BIN.\n"
"\n";
else
if (0<=i<CFG_NUM_OPTIONS) {
state=c->opts[i]=!c->opts[i];
@@ -223,10 +224,10 @@ CKernelCfg *KernelCfgNew()
c->add_dev=KernelCfgAddDev(c);
c->dsk_cache_size_exp=GetStr(
"Disk Cache Size in Bytes,\n"
"gets rounded-up funny,\n"
"($$PURPLE$$<ENTER>$$FG$$ will use default.):",
"Scale2Mem(0x80000,0x8000000)");
"Disk Cache Size in Bytes,\n"
"gets rounded-up funny,\n"
"($$PURPLE$$<ENTER>$$FG$$ will use default.):",
"Scale2Mem(0x80000,0x8000000)");
KernelCfgOptions(c);
return c;
}
Kernel/KDataTypes.CPP
+2 -2
View File
@@ -39,7 +39,7 @@ I64 LinkedLstSize(U8 **_lst)
}
U0 QueDel(CQue *root,Bool querem=FALSE)
{//Free entrie queue, not root.
{//Free entries in queue, not root.
CQue *tempq=root->next,*tempq1;
while (tempq!=root) {
tempq1=tempq->next;
@@ -87,7 +87,7 @@ I64 QueSize(CQue *root)
CQueVectU8 *QueVectU8New(I64 min_index=0)
{//Create new queue vecter.
CQueVectU8 *result=MAlloc(sizeof(CQueVectU8));
result->next=result->last=result;
QueInit(result);
result->total_cnt=result->node_cnt=0;
result->min_index=min_index;
return result;
Kernel/KDbg.CPP
+51 -48
View File
@@ -34,7 +34,8 @@ Bool ChkOnStk(U8 *ptr,CTask *task=NULL)
PUSHFD
CLI
if (task) {
if (&task->stk->stk_base<=ptr<=(&task->stk->stk_base)(U8 *)+task->stk->stk_size)
if (&task->stk->stk_base<=ptr<=
(&task->stk->stk_base)(U8 *)+task->stk->stk_size)
result=TRUE;
} else if (sys_heap_base<=ptr<=sys_heap_limit)
result=TRUE;
@@ -103,7 +104,7 @@ U8 *TaskCaller(CTask *task=NULL,I64 num=0,Bool saved_context=FALSE)
U0 StkRep(CTask *task=NULL)
{//Reports whats on the stk.
I64 i,j,addr,
**rbp,**rsp,*my_rsp[STK_REP_LEN];
**rbp,**rsp,*my_rsp[STK_REP_LEN];
CHashTable *old_hash=Fs->hash_table;
if (!task) task=Fs;
if (!TaskValidate(task))
@@ -127,9 +128,10 @@ U0 StkRep(CTask *task=NULL)
Fs->hash_table=task->hash_table;
for (i=0;i<STK_REP_LEN;i++) {
"%08X [RSP+%04X]: %016X ",rsp+i,
i*sizeof(U8 *),my_rsp[i];
i*sizeof(U8 *),my_rsp[i];
while (TRUE) {
if (!(&task->stk->stk_base<=rbp<(&task->stk->stk_base)(U8 *)+task->stk->stk_size))
if (!(&task->stk->stk_base<=rbp<
(&task->stk->stk_base)(U8 *)+task->stk->stk_size))
break;
j=rbp-rsp;
if (j>=i)
@@ -232,7 +234,7 @@ U0 RawPrint(I64 mS=100,U8 *fmt,...)
U0 RawD(I64 mS=100,U8 *addr,I64 cnt=0x80)
{//Dumps a block of mem using $LK,"Raw",A="MN:Raw"$
//screen output for a fixed length
//of time.
//of time.
Bool old_raw,old_input_filter;
PUSHFD
CLI
@@ -248,7 +250,7 @@ U0 RawD(I64 mS=100,U8 *addr,I64 cnt=0x80)
U0 RawDm(I64 mS=100,U8 *addr,I64 cnt=0x80)
{//Dumps a block of mem using $LK,"Raw",A="MN:Raw"$
//screen output for a fixed length
//of time.
//of time.
Bool old_raw,old_input_filter;
PUSHFD
CLI
@@ -451,12 +453,12 @@ U0 G(U8 *ip=INVALID_PTR,CTask *task=NULL)
if (!task) task=Fs;
if (ip!=INVALID_PTR) task->rip=ip;
if (BptFind(task->rip,task))
"\nDo one of the following, first:\n"
">S;\t\t\t//Single step\n"
">B2;\t\t\t//Clear all break points\n"
">G2;\t\t\t//Clear all break points and Go\n\n"
"After resuming, <CTRL-ALT-t> changes focus task\n"
"After resuming, <CTRL-ALT-f> flushes screen VGA cache\n";
"\nDo one of the following, first:\n"
">S;\t\t\t//Single step\n"
">B2;\t\t\t//Clear all break points\n"
">G2;\t\t\t//Clear all break points and Go\n\n"
"After resuming, <CTRL-ALT-t> changes focus task\n"
"After resuming, <CTRL-ALT-f> flushes screen VGA cache\n";
else {
LBtr(&task->task_flags,TASKf_DISABLE_BPTS);
LBtr(&task->rflags,RFLAGf_TRAP);//No single step
@@ -464,7 +466,7 @@ U0 G(U8 *ip=INVALID_PTR,CTask *task=NULL)
if (task==Fs) {
if (IsDbg && task->next_lex!=&task->next_lex) {
"Exit Dbg\n";
Btr(&task->last_lex->flags,Lf_PMT);
Btr(&task->last_lex->flags,CCf_PMT);
}
} else
Exit;
@@ -493,7 +495,7 @@ public U0 S(U8 *ip=INVALID_PTR,CTask *task=NULL) //Single-step.
if (task==Fs) {
if (IsDbg) {
if (task->next_lex!=&task->next_lex)
Btr(&task->last_lex->flags,Lf_PMT);
Btr(&task->last_lex->flags,CCf_PMT);
}
} else
Exit;
@@ -502,37 +504,37 @@ public U0 S(U8 *ip=INVALID_PTR,CTask *task=NULL) //Single-step.
U0 DbgHelp()
{
"\n"
"The cmd line is basically the same as normal. Here are some common\n"
"debugging commands.\n\n"
">EdLite(\"FileName\");\t\t//Edit file.\n"
">D(0x100000);\t\t\t//Dump page tables.\n"
">Dm(0x100000);\t\t\t//Dump page tables.\n"
">Dm(Fs,sizeof(CTask));\t\t//Dump current task record.\n"
">ClassRep(Fs,\"CTask\",1);\t//Dump current task record.\n"
">ClassRep(Fs,,1);\t\t//(It knows lastclass.)\n"
">CallerRep;\t\t\t//Stack trace report.\n"
">Da(_RSP);\t\t\t//Dump stk.\n"
">Dr;\t\t\t\t//Dump Regs.\n"
">1+2*3+&Print;\t\t\t//Show calculation result.\n"
">*(0x70000)(I64 *)=0x123456789;\t//Assign value to 0x70000-0x70007.\n"
">_RAX=0x1234;\t\t\t//Set RAX to 0x1234.\n"
">_RIP=&SysThrowBreak;\t\t//Set RIP.\n"
">I64 i;\t\t\t\t//Declare variable.\n"
">i=_RCX+_RDX;\t\t\t//Assign to variable.\n"
">U(&Print+0x8);\t\t\t//Unassemble Print.\n"
">Uf(\"Print\");\t\t\t//Unassembler function \"Print\".\n"
">Man(\"Print\");\t\t\t//Edit Src for \"Print\".\n"
">E(_RIP);\t\t\t//Edit Src Code.\n"
">Fix;\t\t\t\t//Edit Last Err Src Code.\n"
">B(&Main+0x20);\t\t\t//Toggle break point.\n"
">B2;\t\t\t\t//Clear all break points.\n"
">S;\t\t\t\t//Single step.\n"
">G;\t\t\t\t//Resume execution.\n"
">G2;\t\t\t\t//B2;VGAFlush;WinFocus;G;\n"
">Exit;\t\t\t\t//Exit (kill) task.\n\n"
"After resuming, <CTRL-ALT-t> changes focus task.\n"
"After resuming, <CTRL-ALT-f> flushes screen VGA cache.\n\n";
"\n"
"The cmd line is basically the same as normal. Here are some common\n"
"debugging commands.\n\n"
">EdLite(\"FileName\");\t\t//Edit file.\n"
">D(0x100000);\t\t\t//Dump page tables.\n"
">Dm(0x100000);\t\t\t//Dump page tables.\n"
">Dm(Fs,sizeof(CTask));\t\t//Dump current task record.\n"
">ClassRep(Fs,\"CTask\",1);\t//Dump current task record.\n"
">ClassRep(Fs,,1);\t\t//(It knows lastclass.)\n"
">CallerRep;\t\t\t//Stack trace report.\n"
">Da(_RSP);\t\t\t//Dump stk.\n"
">Dr;\t\t\t\t//Dump Regs.\n"
">1+2*3+&Print;\t\t\t//Show calculation result.\n"
">*(0x70000)(I64 *)=0x123456789;\t//Assign value to 0x70000-0x70007.\n"
">_RAX=0x1234;\t\t\t//Set RAX to 0x1234.\n"
">_RIP=&SysThrowBreak;\t\t//Set RIP.\n"
">I64 i;\t\t\t\t//Declare variable.\n"
">i=_RCX+_RDX;\t\t\t//Assign to variable.\n"
">U(&Print+0x8);\t\t\t//Unassemble Print.\n"
">Uf(\"Print\");\t\t\t//Unassembler function \"Print\".\n"
">Man(\"Print\");\t\t\t//Edit Src for \"Print\".\n"
">E(_RIP);\t\t\t//Edit Src Code.\n"
">Fix;\t\t\t\t//Edit Last Err Src Code.\n"
">B(&Main+0x20);\t\t\t//Toggle break point.\n"
">B2;\t\t\t\t//Clear all break points.\n"
">S;\t\t\t\t//Single step.\n"
">G;\t\t\t\t//Resume execution.\n"
">G2;\t\t\t\t//B2;VGAFlush;WinFocus;G;\n"
">Exit;\t\t\t\t//Exit (kill) task.\n\n"
"After resuming, <CTRL-ALT-t> changes focus task.\n"
"After resuming, <CTRL-ALT-f> flushes screen VGA cache.\n\n";
}
U0 Dbg2()
@@ -578,7 +580,7 @@ U0 Fault3(I64 fault_num,I64 fault_err_code)
SysHlt;
}
"\n\tTempleOS Debugger\n\n"
">Help;\t//For help.\n\n";
">Help;\t//For help.\n\n";
Beep(500,TRUE);
if (fault_num==I_DBG) {
if (dbg.msg) {
@@ -616,7 +618,8 @@ U0 Fault2(I64 fault_num,I64 fault_err_code)
"Task \"";
"%s",Fs->task_title;
"\"\n";
"Fault:0x%02X %Z\t\tErr Code:%08X\n",fault_num,fault_num,"ST_INT_NAMES",fault_err_code;
"Fault:0x%02X %Z\t\tErr Code:%08X\n",
fault_num,fault_num,"ST_INT_NAMES",fault_err_code;
"RIP:%08X",Fs->rip; //Sometimes crashes on %p, so do this first
":%p RSP:%08X\n",Fs->rip,Fs->rsp;
if (fault_num==I_PAGE_FAULT) {
@@ -635,7 +638,7 @@ U0 Fault2(I64 fault_num,I64 fault_err_code)
}
U0 Dbg(U8 *msg=NULL,I64 msg_num=0)
{//Enters the debugger. Can be used as a panic.
{//Enters the debugger.Can be used as a panic.
PUSHFD
CLI
dbg.msg=msg;
Kernel/KDefine.CPP
+26 -25
View File
@@ -97,35 +97,34 @@ U0 DefinePrint(U8 *name,U8 *src,...)
U0 SysDefinesLoad()
{
DefineLstLoad("ST_OFF_ON","Off\0On\0");
DefineLstLoad("ST_HTT_TYPES","ExportSysSym\0ImportSysSym\0DefineStr\0GlbVar\0Class\0"
"IntType\0Funct\0Word\0DictWord\0KeyWord\0AsmKeyWord\0OpCode\0Reg\0"
"File\0Module\0HelpFile\0Frame Ptr\0"
" \0 \0 \0 \0 \0 \0"
"Private\0Public\0Export\0Import\0Imm\0Goto\0Res\0Unres\0Local\0");
DefineLstLoad("ST_HTT_TYPES","ExportSysSym\0ImportSysSym\0DefineStr\0GlbVar\0"
"Class\0IntType\0Funct\0Word\0DictWord\0KeyWord\0AsmKeyWord\0OpCode\0"
"Reg\0File\0Module\0HelpFile\0Frame Ptr\0 \0 \0 \0 \0 \0 \0Private\0"
"Public\0Export\0Import\0Imm\0Goto\0Res\0Unres\0Local\0");
DefineLstLoad("ST_DAYS_OF_WEEK","Sunday\0Monday\0Tuesday\0Wednesday\0"
"Thursday\0Friday\0Saturday\0");
"Thursday\0Friday\0Saturday\0");
DefineLstLoad("ST_MONTHS","January\0February\0March\0April\0May\0"
"June\0July\0August\0September\0October\0November\0December\0");
"June\0July\0August\0September\0October\0November\0December\0");
DefineLstLoad("ST_FILE_ATTRS","R\0H\0S\0V\0D\0A\0 \0 \0X\0T\0Z\0C\0F\0");
DefineLstLoad("ST_FILE_UTIL_FLAGS","r\0d\0i\0a\0c\0R\0p\0m\0x\0s\0"
"D\0F\0T\0S\0A\0J\0G\0Z\0O\0P\0f\0l\0lb\0la\0");
"D\0F\0T\0S\0A\0J\0G\0Z\0O\0P\0f\0l\0lb\0la\0");
DefineLstLoad("ST_BLKDEV_TYPES","NULL\0RAM\0ATA\0ATAPI\0");
DefineLstLoad("ST_DRV_TYPES","NULL\0REDSEA\0FAT32\0ISO9660\0ISO13490\0ISO13346\0NTFS\0UNKNOWN\0");
DefineLstLoad("ST_DRV_TYPES",
"NULL\0REDSEA\0FAT32\0ISO9660\0ISO13490\0ISO13346\0NTFS\0UNKNOWN\0");
DefineLstLoad("ST_COLORS","BLACK\0BLUE\0GREEN\0CYAN\0"
"RED\0PURPLE\0BROWN\0LTGRAY\0DKGRAY\0LTBLUE\0LTGREEN\0"
"LTCYAN\0LTRED\0LTPURPLE\0YELLOW\0WHITE\0");
DefineLstLoad("ST_INT_NAMES",
"Divide Error\0SingleStep\0NMI\0Breakpoint\0Overflow\0BOUND Range Exceeded\0Invalid Opcode\0No Math Coprocessor\0"
"Double Fault\0Coprocessor Segment Fault\0Invalid TASK\0Segment Not Present\0Stk Segment Fault\0General Protection\0Page Fault\0 \0"
"Math Fault\0Alignment Check\0Machine Check\0SIMD Exception\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"
"MP Crash\0Wake\0Dbg\0");
DefineLstLoad("ST_INT_NAMES","Divide Error\0SingleStep\0NMI\0Breakpoint\0"
"Overflow\0BOUND Range Exceeded\0Invalid Opcode\0No Math Coprocessor\0"
"Double Fault\0Coprocessor Segment Fault\0Invalid TASK\0"
"Segment Not Present\0Stk Segment Fault\0General Protection\0"
"Page Fault\0 \0Math Fault\0Alignment Check\0Machine Check\0"
"SIMD Exception\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 \0MP Crash\0Wake\0Dbg\0");
}
U8 *Color2Str(U8 *buf,CColorROPU32 c)
{//$LK,"CColorROPU32",A="MN:CColorROPU32"$ with flags to $LK,"GrLighting",A="MN:GrLighting"$ str.
{//$LK,"CColorROPU32",A="MN:CColorROPU32"$ with flags to $LK,"DCLighting",A="MN:DCLighting"$ str.
*buf=0;
if (c.c0.rop&ROPBF_TWO_SIDED)
CatPrint(buf,"TWO|");
@@ -153,18 +152,20 @@ U8 *Color2Str(U8 *buf,CColorROPU32 c)
return buf;
}
U8 *str2color_lst="/,)}>";
CColorROPU16 Str2ColorU16(U8 *st)
{//$LK,"GrLighting",A="MN:GrLighting"$ color str with flags to $LK,"CColorROPU16",A="MN:CColorROPU16"$.
{//$LK,"DCLighting",A="MN:DCLighting"$ color str with flags to $LK,"CColorROPU16",A="MN:CColorROPU16"$.
CColorROPU16 result=COLOR_INVALID;
I64 i;
U8 *ptr,*ptr2,*st2;
if (!st) return COLOR_INVALID;
while (TRUE) {
if (!*st||StrOcc("/,)}>",*st))
if (!*st||StrOcc(str2color_lst,*st))
return result;
if (Bt(chars_bitmap_alpha,*st)) {
if (Bt(chars_bmp_alpha,*st)) {
ptr=st;
while (Bt(chars_bitmap_alpha_numeric,*ptr))
while (Bt(chars_bmp_alpha_numeric,*ptr))
ptr++;
st2=ptr2=MAlloc(ptr-st+1);
while (st<ptr)
@@ -183,7 +184,7 @@ CColorROPU16 Str2ColorU16(U8 *st)
return COLOR_INVALID;
}
Free(st2);
} else if (*st=='+'||*st=='|'||Bt(chars_bitmap_white_space,*st))
} else if (*st=='+'||*st=='|'||Bt(chars_bmp_white_space,*st))
st++;
else if ('0'<=*st<='9') {
i=Str2I64(st,10,&ptr);
@@ -198,12 +199,12 @@ CColorROPU16 Str2ColorU16(U8 *st)
}
CColorROPU32 Str2ColorU32(U8 *st)
{//$LK,"GrLighting",A="MN:GrLighting"$ color str with flags to $LK,"CColorROPU32",A="MN:CColorROPU32"$.
{//$LK,"DCLighting",A="MN:DCLighting"$ color str with flags to $LK,"CColorROPU32",A="MN:CColorROPU32"$.
U8 *st2;
CColorROPU32 result=0;
if (!st) return COLOR_INVALID;
st2=MAlloc(StrLen(st)+1);
StrFirstRem(st,"/,)}>",st2);
StrFirstRem(st,str2color_lst,st2);
result.c0=Str2ColorU16(st2);
if (*st) {
result.c1=Str2ColorU16(st);
Kernel/KEnd.CPP
+33 -27
View File
@@ -13,12 +13,14 @@ U0 SysGlblsInit()
dsk.dft_iso_filename="::/Temp/CDDVD.ISO";
StrCpy(dsk.temp_filename,"::/Home/Temp.TXT.Z");
dsk.cdrom_boot_is_good=TRUE;
#exe {
if (!kernel_cfg->auto_mount_ide_hd_let) kernel_cfg->auto_mount_ide_hd_let='C';
if (!kernel_cfg->auto_mount_ide_cd_let) kernel_cfg->auto_mount_ide_cd_let='T';
StreamPrint("dsk.first_hd_drv_let=%d;",kernel_cfg->auto_mount_ide_hd_let);
StreamPrint("dsk.first_cd_drv_let=%d;",kernel_cfg->auto_mount_ide_cd_let);
}
#exe {
if (!kernel_cfg->auto_mount_ide_hd_let)
kernel_cfg->auto_mount_ide_hd_let='C';
if (!kernel_cfg->auto_mount_ide_cd_let)
kernel_cfg->auto_mount_ide_cd_let='T';
StreamPrint("dsk.first_hd_drv_let=%d;",kernel_cfg->auto_mount_ide_hd_let);
StreamPrint("dsk.first_cd_drv_let=%d;",kernel_cfg->auto_mount_ide_cd_let);
}
InDbg(ON);
reverse_bits_table =CAlloc(256);
@@ -49,7 +51,7 @@ U0 SysGlblsInit()
ProgressBarsRst;
//$AN,"Independent HeapCtrl Example",A="Independent HeapCtrl Example"$
//$AN,"Independent HeapCtrl Example",A="Independent HeapCtrl Example"$
i=1; //Rqst 1 blk, we might get more.
m=Mem2MegUncachedAlloc(&i,sys_code_bp);
dev.uncached_heap=HeapCtrlBPInit(m,i*0x200000/0x200);
@@ -86,12 +88,12 @@ U0 TimersInit()
OutU8(0x40,SYS_TIMER0_PERIOD);
OutU8(0x40,SYS_TIMER0_PERIOD>>8);
// High Precision Event Timer
//High Precision Event Timer
if (PCIReadU16(0,31,0,0)==0x8086) {//Intel?
//D31 F0, cfg 0xF0=RCBA of PCI-LPC Bridge
//D31 F0, cfg 0xF0=RCBA of PCI-LPC Bridge
_d=PCIReadU32(0,31,0,0xF0)(U8 *)&~0x3FFF+0x3404; //HPET cfg
//7 enable
//1:0 HPET is at 0xFED00000,0xFED01000, 0xFED02000 or 0xFED03000.
//7 enable
//1:0 HPET is at 0xFED00000,0xFED01000, 0xFED02000 or 0xFED03000.
*_d=*_d&3|0x80;
}
@@ -146,8 +148,8 @@ U0 KernelMain()
BSPInit;
IntInit1;
//Before this point use $LK,"Snd",A="MN:Snd"$() and $LK,"BusyWait",A="MN:BusyWait"$()
//to debug. After this point, use $LK,"RawPrint",A="MN:RawPrint"$()
//Before this point use $LK,"Snd",A="MN:Snd"$() and $LK,"BusyWait",A="MN:BusyWait"$()
//to debug. After this point, use $LK,"RawPrint",A="MN:RawPrint"$()
LBts(&sys_run_level,RLf_RAW);
TimersInit;
if (BIOSTotalMem<ToI64(0.95*MEM_MIN_MEG*0x100000))
@@ -155,7 +157,7 @@ U0 KernelMain()
IntsInit;
"Enable IRQ's\n";
SetRFlags(SYS_NORMAL_RFLAGS);
SetRFlags(RFLAGG_NORMAL);
BusyWait(2000);
IntInit2;
LBts(&sys_run_level,RLf_INTERRUPTS);
@@ -163,12 +165,12 @@ U0 KernelMain()
TimeStampFreqCal;
Preempt(ON);
#exe {
if (!kernel_cfg->opts[CFG_NO_MP])
StreamPrint("\"MultiCore Start\\n\\n\";"
"BSPStartMP;"
"LBts(&sys_run_level,RLf_MP);");
};
#exe {
if (!kernel_cfg->opts[CFG_NO_MP])
StreamPrint("\"MultiCore Start\\n\\n\";"
"BSPStartMP;"
"LBts(&sys_run_level,RLf_MP);");
};
KbdMouseVarsInit;
IPVarsInit;
@@ -181,10 +183,13 @@ U0 KernelMain()
"BlkDevsInitAll\n";
BlkDevsInitAll;
"BlkDevsInitAll Done\n";
#exe {
if (kernel_cfg->cdrom_ports_pmt)
StreamPrint("if (dsk.boot_rescue_drv_pmt) \"%%S\",\"ST_CDROM_PORTS_PMT2\";");
};
#exe {
if (kernel_cfg->cdrom_ports_pmt)
StreamPrint(
"if (dsk.boot_rescue_drv_pmt) \"%%S\",\"ST_CDROM_PORTS_PMT2\";");
};
ChgDsk(':');
LBts(&sys_run_level,RLf_DSK);
@@ -197,7 +202,7 @@ U0 KernelMain()
cnts.time_stamp_freq_initial=TimeStampFreqCal;
Cd("/");
try
ExeFile("Adam"); //Continues $LK,"/Adam.CPP",A="FL:/Adam.CPP,1"$
ExeFile("Adam"); //Continues $LK,"/Adam.CPP",A="FL:/Adam.CPP,1"$
catch {
Raw(ON);
PutExcept;
@@ -213,7 +218,8 @@ SYS_KERNEL_END::
#exe {
if (kernel_cfg->opts[CFG_BOOT_RESCUE_DRV])
StreamPrint("DU8 0x%X-(SYS_KERNEL_END-SYS_KERNEL+"
"BOOT_RAM_BASE+sizeof(CBinFile)) DUP (0);"
"BINFILE \"%s\";",kernel_cfg->boot_rescue_drv_start,kernel_cfg->boot_rescue_drv_file);
"BOOT_RAM_BASE+sizeof(CBinFile)) DUP (0);"
"BINFILE \"%s\";",kernel_cfg->boot_rescue_drv_start,
kernel_cfg->boot_rescue_drv_file);
};
}
Kernel/Except.CPP → Kernel/KExcept.CPP
+2 -3
View File
@@ -1,6 +1,5 @@
asm {
USE64
#assert !((REG_NON_PTR_MASK|REG_VARS_MASK)&~0xFCC0)
#assert !((REGG_C_LOCAL_NON_PTR_VARS|REGG_C_LOCAL_VARS)&~0xFCC0)
_TEST_EXCEPT::
XOR RAX,RAX
MOV RAX,FS:U64 CTask.last_except[RAX]
@@ -126,7 +125,7 @@ U0 ThrowBreak(CTask *task=NULL)
{//Can be used to exit an app, but not a task.
if (task && task!=Fs) {
if (!TaskValidate(task)) return;
//TODO: Might want lock
//TODO: Might want lock
sys_focus_task=task;
LBts(sys_ctrl_alt_flags,SYSf_CTRL_ALT_C);
} else
Kernel/KExts.CPP
+19 -22
View File
@@ -6,17 +6,14 @@ var and check it before calling.
*/
import Bool DocUnlock(CDoc *doc);
import Bool Ed(U8 *link_st,I64 edf_dof_flags=0);
import I64 ExeFile(U8 *name,Bool just_load=FALSE);
import I64 ExePrint(U8 *fmt,...);
import U0 MemberLstDel(CHashClass *tempc);
extern U0 AdamErr(U8 *fmt,...);
extern U0 AdamLog(U8 *fmt,...);
extern I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free);
extern U0 BlkDevChk(CBlkDev *bd);
extern Bool BlkDevLock(CBlkDev *bd);
extern CBlkDev *BlkDevNextFree(U8 first_drv_let,I64 type);
extern Bool BlkDevUnlock(CBlkDev *bd,Bool rst=FALSE);
extern U0 BlkDevsRelease();
extern Bool BptS(U8 *addr,CTask *task=NULL,Bool live=TRUE);
extern U8 *Caller(I64 num=1);
extern U8 *CatPrint(U8 *dst,U8 *fmt,...);
extern Bool Cd(U8 *name,Bool make_dirs=FALSE);
@@ -25,18 +22,23 @@ extern U0 DbgHelp();
extern U8 *Define(U8 *name);
extern I64 DefineMatch(U8 *needle,U8 *haystack_lst_name,I64 flags=0);
extern U8 *DefineSub(I64 sub,U8 *name);
extern I64 Del(U8 *files_find_mask,Bool make_mask=FALSE,
Bool del_dir=FALSE,Bool print_msg=TRUE);
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 U0 DrvsRelease();
extern U0 DskCacheInvalidate(CDrv *dv);
extern U0 Exit();
extern I64 FAT32AllocClusters(CDrv *dv,I64 c,I64 cnt);
extern I64 FAT32AllocContiguousClusters(CDrv *dv,I64 cnt);
extern Bool FAT32DirNew(CDrv *dv,U8 *cur_dir,CDirEntry *tempdee,Bool free_old_chain);
extern Bool FAT32DirNew(CDrv *dv,U8 *cur_dir,CDirEntry *tempdee,
Bool free_old_chain);
extern U0 FAT32DrvInit(CDrv *dv);
extern Bool FAT32FileFind(CDrv *dv,I64 cur_dir_cluster,U8 *name,CDirEntry *_result,I64 fuf_flags=0);
extern CDirEntry *FAT32FilesFind(U8 *files_find_mask,I64 fuf_flags,CDirEntry *parent=NULL,I64 *_dir_size=NULL);
extern Bool FAT32FileFind(CDrv *dv,I64 cur_dir_cluster,U8 *name,
CDirEntry *_result,I64 fuf_flags=0);
extern U8 *FileExtRem(U8 *src,U8 *dst=NULL);
extern Bool FileFind(U8 *filename,CDirEntry *_de=NULL,I64 fuf_flags=0);
extern U8 *FileNameAbs(U8 *name,I64 fuf_flags=0);
@@ -45,12 +47,14 @@ extern I64 FileWrite(U8 *filename,U8 *fbuf,I64 size,CDate cdt=0,I64 attr=0);
extern I64 FlushMsgs(CTask *task=NULL);
extern I64 GetChar(I64 *scan_code=NULL,Bool echo=TRUE,Bool raw_cursor=FALSE);
extern I64 GetS(U8 *buf,I64 size,Bool allow_ext=TRUE);
extern Bool ISO1FileFind(CDrv *dv,I64 cur_dir_cluster,U8 *name,CDirEntry *_result,I64 fuf_flags=0);
extern CDirEntry *ISO1FilesFind(U8 *files_find_mask,I64 fuf_flags,CDirEntry *parent=NULL);
extern Bool ISO1FileFind(CDrv *dv,I64 cur_dir_cluster,U8 *name,
CDirEntry *_result,I64 fuf_flags=0);
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 U0 MPInt(I64 num,I64 cpu_num=1);
extern U8 *MStrPrint(U8 *fmt,...);
extern Bool MkDir(U8 *filename);
@@ -62,11 +66,12 @@ extern U0 PutChars(U64 ch);
extern U0 PutS(U8 *st); //Use $LK,"Print",A="MN:Print"$()
extern Bool RBlks(CDrv *dv,U8 *buf, I64 blk, I64 cnt);
extern I64 RedSeaAllocClusters(CDrv *dv,I64 cnt);
extern Bool RedSeaDirNew(CDrv *dv,U8 *cur_dir,CDirEntry *tempdee,Bool free_old_chain);
extern Bool RedSeaDirNew(CDrv *dv,U8 *cur_dir,CDirEntry *tempdee,
Bool free_old_chain);
extern U0 RedSeaDrvInit(CDrv *dv);
extern Bool RedSeaDrvValidate(U8 drv_let);
extern Bool RedSeaFileFind(CDrv *dv,I64 cur_dir_cluster,U8 *name,CDirEntry *_result,I64 fuf_flags=0);
extern CDirEntry *RedSeaFilesFind (U8 *files_find_mask,I64 fuf_flags,CDirEntry *parent=NULL);
extern Bool RedSeaFileFind(CDrv *dv,I64 cur_dir_cluster,U8 *name,
CDirEntry *_result,I64 fuf_flags=0);
extern U0 RedSeaFmt(U8 drv_let,Bool quick=TRUE);
extern U0 RedSeaFreeFreeLst(CDrv *dv);
extern CTask *SpawnQue(U0 (*fp_addr)(U8 *data),U8 *data=NULL,
@@ -79,7 +84,8 @@ extern U0 SrvCtrlInit(CSrvCtrl *ctrl);
extern U8 *StrPrint(U8 *dst,U8 *fmt,...);
extern U0 StrPrintPSect(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);
extern CSrvCmd *TaskMsg(CTask *_srv,CTask *master,
I64 code,I64 a1,I64 a2,I64 flags);
extern U0 TaskRstAwaitingMsg(CTask *task=NULL);
extern Bool TaskValidate(CTask *task);
extern U0 TaskWait(CTask *task=NULL);
@@ -88,12 +94,3 @@ extern U0 UserTaskCont();
extern Bool WBlks(CDrv *dv,U8 *buf, I64 blk, I64 cnt);
extern U0 XTalk(CTask *task,U8 *fmt,...);
extern U0 throw(I64 ch=0,Bool no_log=FALSE);
#exe {
OptOn(OPTf_KEEP_PRIVATE);
OptOn(OPTf_EXTERNS_TO_IMPORTS);
};
#include "/Compiler/CompilerB.HPP"
#exe {
OptOff(OPTf_EXTERNS_TO_IMPORTS);
OptOff(OPTf_KEEP_PRIVATE);
};
Kernel/KGlbls.CPP
+2 -2
View File
@@ -10,13 +10,13 @@ I64 sys_num_spawned_tasks;
CTask *sys_winmgr_task,*sys_task_being_screen_updated;
U8 *reverse_bits_table, //Table with U8 bits reversed
*set_bits_table; //Table with count of set bits in a U8
CDate local_time_offset=0;
CDate local_time_offset;
F64 *pow10_I64;
CSndGlbls snd;
CCntsGlbls cnts={1,0,2676302000,2676302,2676302000,0,0,0,FALSE};
CIPStateGlbls ip,ip_last;
CGridGlbls ip_grid;
CGridGlbls ip_grid; //See $LK,"::/Demo/Graphics/Grid.CPP.Z"$.
CMouseStateGlbls mouse,mouse_last;
CKbdStateGlbls kbd;
CKeyDevGlbls keydev;
Kernel/KHashA.CPP
BIN
View File
Binary file not shown.
Kernel/KHashB.CPP
+16 -13
View File
@@ -69,7 +69,7 @@ U0 HashDel(CHashSrcSym *temph)
if (temph->type & (HTT_FUN | HTT_EXPORT_SYS_SYM))
Free(temph->dbg_info);
if (temph->type & (HTT_FUN | HTT_CLASS))
//Assumes code not on heap, so doesn't Free.
//Assumes code not on heap, so doesn't Free.
//$LK,"MemberLstDel",A="MN:MemberLstDel"$() is an import to the Kernel module
MemberLstDel(temph);
else if (temph->type&HTT_DEFINE_STR)
@@ -79,7 +79,8 @@ U0 HashDel(CHashSrcSym *temph)
Free(temph(CHashGlblVar *)->data_addr);
LinkedLstDel(temph(CHashGlblVar *)->dim.next);
if (temph(CHashGlblVar *)->fun_ptr)
HashDel(temph(CHashGlblVar *)->fun_ptr-temph(CHashGlblVar *)->fun_ptr->ptr_stars_cnt);
HashDel(temph(CHashGlblVar *)->fun_ptr
-temph(CHashGlblVar *)->fun_ptr->ptr_stars_cnt);
}
} else if (temph->type & HTT_FILE)
Free(temph(CHashGeneric *)->user_data0);
@@ -108,8 +109,8 @@ I64 HashTablePurge(CHashTable *table)
I64 i,result=0;
CHashSrcSym *temph,*temph1,*temph2;
if (!table) return 0;
PUSHFD
CLI //Precaution
PUSHFD
CLI //Precaution
for (i=0;i<=table->mask;i++) {
temph=table->body[i];
while (temph) {
@@ -117,7 +118,8 @@ I64 HashTablePurge(CHashTable *table)
if (temph->type&(HTT_FUN|HTT_GLBL_VAR)) {
temph2=temph->next; //Older always later in chain
while (temph2) {
if ((temph2->type&HTT_EXPORT_SYS_SYM || temph2->type&HTG_TYPE_MASK==HTT_INVALID) &&
if ((temph2->type&HTT_EXPORT_SYS_SYM ||
temph2->type&HTG_TYPE_MASK==HTT_INVALID) &&
!StrCmp(temph2->str,temph->str)) {
if (temph2->type&HTG_TYPE_MASK==HTT_INVALID)
temph2->type=HTT_KEYWORD;//Won't delete HTT_INVALID
@@ -131,11 +133,12 @@ I64 HashTablePurge(CHashTable *table)
temph=temph1;
}
}
POPFD
POPFD
return result;
}
CHashGeneric *HashGenericAdd(U8 *name,I64 type,I64 u0=0,I64 u1=0,I64 u2=0,CTask *task=NULL)
CHashGeneric *HashGenericAdd(U8 *name,I64 type,
I64 u0=0,I64 u1=0,I64 u2=0,CTask *task=NULL)
{//Add any type to task hash_table, 3 user_data values.
if (!task) task=Fs;
CHashGeneric *result=CAlloc(sizeof(CHashGeneric),task);
@@ -148,18 +151,18 @@ CHashGeneric *HashGenericAdd(U8 *name,I64 type,I64 u0=0,I64 u1=0,I64 u2=0,CTask
return result;
}
U0 HashSrcFileSet(CLex *lx,CHashSrcSym *h,I64 line_num_offset=0)
{//Set $LK,"CHashSrcSym",A="MN:CHashSrcSym"$ link and help_index by cur lx pos.
CLexFile *tempf=lx->cur_lfn;
U0 HashSrcFileSet(CCmpCtrl *cc,CHashSrcSym *h,I64 line_num_offset=0)
{//Set $LK,"CHashSrcSym",A="MN:CHashSrcSym"$ link and help_index by cur cc pos.
CLexFile *tempf=cc->lex_include_stk;
I64 line_num=tempf->line_num+line_num_offset;
if (line_num<1) line_num=1;
Free(h->src_link);
h->src_link=MStrPrint("FL:%s,%d",tempf->full_name,line_num);
if (Bt(&lx->opts,OPTf_KEEP_PRIVATE))
if (Bt(&cc->opts,OPTf_KEEP_PRIVATE))
h->type|=HTF_PRIVATE;
Free(h->index);
if (lx->cur_help_index)
h->index=StrNew(lx->cur_help_index);
if (cc->cur_help_index && *cc->cur_help_index)
h->index=StrNew(cc->cur_help_index);
else
h->index=NULL;
}
Kernel/KLoad.CPP
+36 -33
View File
@@ -16,7 +16,8 @@ U0 LoadOneImport(U8 **_src,U8 *module_base,I64 ld_flags)
return;
} else {
first=FALSE;
if (!(tempex=HashFind(st_ptr,Fs->hash_table,HTG_ALL-HTT_IMPORT_SYS_SYM))) {
if (!(tempex=HashFind(st_ptr,
Fs->hash_table,HTG_ALL-HTT_IMPORT_SYS_SYM))) {
if (!(ld_flags & LDF_SILENT))
"Unresolved Reference:%s\n",st_ptr;
tempiss=CAlloc(sizeof(CHashImport));
@@ -37,14 +38,14 @@ U0 LoadOneImport(U8 **_src,U8 *module_base,I64 ld_flags)
else
i=tempex->val;
switch (etype) {
case EIT_REL_I8: *ptr2(U8 *) =i-ptr2-1; break;
case EIT_IMM_U8: *ptr2(U8 *) =i; break;
case EIT_REL_I16: *ptr2(U16 *)=i-ptr2-2; break;
case EIT_IMM_U16: *ptr2(U16 *)=i; break;
case EIT_REL_I32: *ptr2(U32 *)=i-ptr2-4; break;
case EIT_IMM_U32: *ptr2(U32 *)=i; break;
case EIT_REL_I64: *ptr2(I64 *)=i-ptr2-8; break;
case EIT_IMM_I64: *ptr2(I64 *)=i; break;
case IET_REL_I8: *ptr2(U8 *) =i-ptr2-1; break;
case IET_IMM_U8: *ptr2(U8 *) =i; break;
case IET_REL_I16: *ptr2(U16 *)=i-ptr2-2; break;
case IET_IMM_U16: *ptr2(U16 *)=i; break;
case IET_REL_I32: *ptr2(U32 *)=i-ptr2-4; break;
case IET_IMM_U32: *ptr2(U32 *)=i; break;
case IET_REL_I64: *ptr2(I64 *)=i-ptr2-8; break;
case IET_IMM_I64: *ptr2(I64 *)=i; break;
}
}
}
@@ -55,7 +56,8 @@ U0 SysSymImportsResolve(U8 *st_ptr,I64 ld_flags)
{
CHashImport *tempiss;
U8 *ptr;
while (tempiss=HashSingleTableFind(st_ptr,Fs->hash_table,HTT_IMPORT_SYS_SYM)) {
while (tempiss=HashSingleTableFind(st_ptr,
Fs->hash_table,HTT_IMPORT_SYS_SYM)) {
ptr=tempiss->module_header_entry;
LoadOneImport(&ptr,tempiss->module_base,ld_flags);
tempiss->type=HTT_INVALID;
@@ -72,25 +74,25 @@ U0 LoadPass1(U8 *src,U8 *module_base,I64 ld_flags)
st_ptr=src;
src+=StrLen(st_ptr)+1;
switch (etype) {
case EIT_REL32_EXPORT:
case EIT_IMM32_EXPORT:
case EIT_REL64_EXPORT:
case EIT_IMM64_EXPORT:
case IET_REL32_EXPORT:
case IET_IMM32_EXPORT:
case IET_REL64_EXPORT:
case IET_IMM64_EXPORT:
tempex=CAlloc(sizeof(CHashExport));
tempex->str=StrNew(st_ptr);
tempex->type=HTT_EXPORT_SYS_SYM|HTF_IMM;
if (etype==EIT_IMM32_EXPORT||etype==EIT_IMM64_EXPORT)
if (etype==IET_IMM32_EXPORT||etype==IET_IMM64_EXPORT)
tempex->val=i;
else
tempex->val=i+module_base;
HashAdd(tempex,Fs->hash_table);
SysSymImportsResolve(st_ptr,ld_flags);
break;
case EIT_REL_I0...EIT_IMM_I64:
case IET_REL_I0...IET_IMM_I64:
src=st_ptr-5;
LoadOneImport(&src,module_base,ld_flags);
break;
case EIT_ABS_ADDR:
case IET_ABS_ADDR:
if (ld_flags & LDF_NO_ABSS)
src+=i*sizeof(U32);
else {
@@ -103,10 +105,10 @@ U0 LoadPass1(U8 *src,U8 *module_base,I64 ld_flags)
break;
sub_switch_start:
case EIT_CODE_HEAP:
case IET_CODE_HEAP:
ptr3=MAlloc(*src(I32 *)++,Fs->code_heap);
break;
case EIT_ZEROED_CODE_HEAP:
case IET_ZEROED_CODE_HEAP:
ptr3=CAlloc(*src(I32 *)++,Fs->code_heap);
break;
sub_switch_end:
@@ -125,10 +127,10 @@ U0 LoadPass1(U8 *src,U8 *module_base,I64 ld_flags)
break;
sub_switch_start:
case EIT_DATA_HEAP:
case IET_DATA_HEAP:
ptr3=MAlloc(*src(I64 *)++);
break;
case EIT_ZEROED_DATA_HEAP:
case IET_ZEROED_DATA_HEAP:
ptr3=CAlloc(*src(I64 *)++);
break;
sub_switch_end:
@@ -158,18 +160,18 @@ U0 LoadPass2(U8 *src,U8 *module_base,I64)
st_ptr=src;
src+=StrLen(st_ptr)+1;
switch (etype) {
case EIT_MAIN:
case IET_MAIN:
Call(i+module_base);
break;
case EIT_ABS_ADDR:
case IET_ABS_ADDR:
src+=sizeof(U32)*i;
break;
case EIT_CODE_HEAP:
case EIT_ZEROED_CODE_HEAP:
case IET_CODE_HEAP:
case IET_ZEROED_CODE_HEAP:
src+=4+sizeof(U32)*i;
break;
case EIT_DATA_HEAP:
case EIT_ZEROED_DATA_HEAP:
case IET_DATA_HEAP:
case IET_ZEROED_DATA_HEAP:
src+=8+sizeof(U32)*i;
break;
}
@@ -189,7 +191,7 @@ CBinFile *Load(U8 *filename,I64 ld_flags=0,CBinFile *bfh_addr=INVALID_PTR)
return NULL;
}
//See $LK,"Patch Table Generation",A="FF:::/Compiler/CMain.CPP,EIT_ABS_ADDR"$
//See $LK,"Patch Table Generation",A="FF:::/Compiler/CMain.CPP,IET_ABS_ADDR"$
module_align=1<<bfh->module_align_bits;
if (!module_align || bfh->bin_signature!=BIN_SIGNATURE_VAL) {
Free(bfh);
@@ -218,7 +220,7 @@ CBinFile *Load(U8 *filename,I64 ld_flags=0,CBinFile *bfh_addr=INVALID_PTR)
MemCpy(bfh_addr,bfh,size);
Free(bfh);
lo_skip:
lo_skip:
module_base=bfh_addr(U8 *)+sizeof(CBinFile);
absname=FileNameAbs(fbuf);
@@ -237,11 +239,12 @@ lo_skip:
U0 LoadKernel()
{
HashGenericAdd(KERNEL_MODULE_NAME,HTT_MODULE|HTF_PUBLIC,sys_boot_base-sizeof(CBinFile));
HashGenericAdd(KERNEL_MODULE_NAME,HTT_MODULE|HTF_PUBLIC,
sys_boot_base-sizeof(CBinFile));
//Abs patches done here $LK,"CPatchTableAbsAddr",A="FF:D:/Kernel/KStart.CPP,CPatchTableAbsAddr"$.
//Abs patches done here $LK,"CPatchTableAbsAddr",A="FF:D:/Kernel/KStart.CPP,CPatchTableAbsAddr"$.
LoadPass1(sys_boot_patch_table_base,sys_boot_base,LDF_NO_ABSS|LDF_SILENT);
//No main routines
// LoadPass2(sys_boot_patch_table_base,sys_boot_base,0);
//No main routines
// LoadPass2(sys_boot_patch_table_base,sys_boot_base,0);
}
Kernel/KMathA.CPP
-1
View File
@@ -1,5 +1,4 @@
asm {
USE64
//************************************
_D3_NORM::
PUSH RBP
Kernel/KMisc.CPP
-45
View File
@@ -281,48 +281,3 @@ U0 ProgressBarsRst()
{
MemSet(sys_progresses,0,sizeof(sys_progresses));
}
U0 CtrlAltDel(I64)
{
LBts(sys_ctrl_alt_flags,SYSf_CTRL_ALT_DEL);
}
U0 CtrlAltC(I64)
{
LBts(sys_ctrl_alt_flags,SYSf_CTRL_ALT_C);
}
U0 CtrlAltD(I64)
{
if (!IsDbg) {
if (Fs==Gs->idle_task)
BptS(sys_winmgr_task->rip,sys_winmgr_task);
else
BptS(*keydev.ctrl_alt_let_ret_addr);
}
}
U0 CtrlAltE(I64)
{
User;
}
U0 CtrlAltF(I64)
{
VGAFlush;
}
U0 CtrlAltM(I64)
{
Mute(!IsMute);
}
U0 CtrlAltT(I64)
{
LBts(sys_ctrl_alt_flags,SYSf_CTRL_ALT_TAB);
}
U0 CtrlAltX(I64)
{
LBts(sys_ctrl_alt_flags,SYSf_CTRL_ALT_X);
}
Kernel/KStart.CPP
+11 -11
View File
@@ -28,9 +28,9 @@ SYS_RUN_LEVEL:: DU32 0;
//See $LK,"BootCdProbe",A="MN:BootCdProbe"$
#assert SYS_COMPILE_TIME+sizeof(CDate)+sizeof(CBinFile)<CD_BLK_SIZE
SYS_BOOT_BASE:: DU32 0; //Offset from start used by reboot
SYS_MEM_E801:: DU16 0,0;
SYS_MEM_E820:: DU8 MEM_NUM_E820_ENTRIES*MEM_E820_ENTRY_SIZE DUP (0);
SYS_BOOT_BASE:: DU32 0; //Offset from start used by reboot
SYS_MEM_E801:: DU16 0,0;
SYS_MEM_E820:: DU8 MEM_NUM_E820_ENTRIES*MEM_E820_ENTRY_SIZE DUP (0);
ALIGN 16,OC_NOP
SYS_GDT:: //See $LK,"CGDT",A="MN:CGDT"$
@@ -39,7 +39,7 @@ GDT_BOOT_DS: DU64 0x00CF92000000FFFF,0; //Gets patched.
GDT_BOOT_CS: DU64 0x00CF9A000000FFFF,0; //Gets patched.
GDT_CS32: DU64 0x00CF9A000000FFFF,0;
GDT_CS64: DU64 0x00209A0000000000,0; //The $LK,"Charter",A="FI:::/Doc/Charter.TXT"$ says just ring0.
GDT_CS64_RING3: DU64 0x0020FA0000000000,0; //$LK,"Ring3",A="FI:::/Demo/Lectures/Ring3.CPP"$, in case you want to play around.
GDT_CS64_RING3: DU64 0x0020FA0000000000,0; //$LK,"Ring3",A="FI:::/Demo/Lectures/Ring3.CPP"$, so you can play with.
GDT_DS: DU64 0x00CF92000000FFFF,0;
GDT_DS_RING3: DU64 0x00CFF2000000FFFF,0;
GDT_TR: DU8 MP_MAX_PROCESSORS*16 DUP(0);
@@ -57,7 +57,7 @@ BSP_16BIT_INIT::
MOV AX,(BOOT_RAM_LIMIT-BOOT_STK_SIZE)/16
MOV SS,AX
MOV SP,BOOT_STK_SIZE
PUSH EBX //Will be $LK,"SYS_BOOT_SRC",A="FF:::/Kernel/KStart.CPP,[SYS_BOOT_SRC]"$. See $LK,"BootHD",A="FF:::/Adam/Boot/BootHD.CPP,BOOT_SRC_HARDDRV"$, $LK,"BootCD",A="FF:::/Adam/Boot/BootCD.CPP,BOOT_SRC_CDROM"$ & $LK,"BootRAM",A="FF:::/Adam/Boot/Boot.CPP,BOOT_SRC_RAM"$.
PUSH EBX //Will be $LK,"SYS_BOOT_SRC",A="FF:::/Kernel/KStart.CPP,[SYS_BOOT_SRC]"$. See $LK,"BootHD",A="FF:::/Adam/Boot/BootHD.CPP,BOOT_SRC_HARDDRV"$, $LK,"BootCD",A="FF:::/Adam/Boot/BootCD.CPP,BOOT_SRC_CDROM"$ & $LK,"BootRAM",A="FF:::/Adam/Boot/Boot.CPP,BOOT_SRC_RAM"$.
MOV AX,VGAM_TEXT/16
MOV ES,AX
MOV U32 ES:[0],'O'+BLUE<<12+('S'+GREEN<<12)<<16
@@ -172,7 +172,7 @@ The assembler doesn't support far jumps so we hand code it.
To complete the switch to 32-bit mode, we have to load
the code segment with a far jump.
*/
DU8 0x66,0xEA; //JMP CGDT.boot_cs:BSP_32BIT_INIT
DU8 0x66,0xEA; //JMP CGDT.boot_cs:BSP_32BIT_INIT
DU32 BSP_32BIT_INIT;
DU16 CGDT.boot_cs;
@@ -232,7 +232,7 @@ SYS_SEMAS:: DU8 NUM_SYS_SEMAS*SEMA_STRUCT_SIZE DUP(0);
//************************************
ALIGN 16,OC_NOP
BSP_32BIT_INIT:: //Entry point for $LK,"RAMReboot",A="MN:RAMReboot"$.
PUSH U32 SYS_START_RFLAGS
PUSH U32 RFLAGG_START
POPFD
MOV EAX,SYS_START_CR0
MOV_CR0_EAX
@@ -265,7 +265,7 @@ BSP_32BIT_INIT:: //Entry point for $LK,"RAMReboot",A="MN:RAMReboot"$.
@@10: BTS U32 [SYS_RUN_LEVEL],RLf_PATCHED
CALL SYS_FIND_BIOS32_SERVICE_DIR
CALL SYS_FIND_PCIBIOS_SERVICE_DIR
CALL SYS_FIND_PCI_SERVICES
MOV U32 [SYS_HEAP_BASE],SYS_FIXED_AREA+sizeof(CSysFixedArea)
@@ -273,7 +273,8 @@ BSP_32BIT_INIT:: //Entry point for $LK,"RAMReboot",A="MN:RAMReboot"$.
PUSH U32 0 //Return from next call will be 64-bit
CALL SYS_EM64T
USE64 BTS U32 [SYS_RUN_LEVEL],RLf_64BIT
USE64
BTS U32 [SYS_RUN_LEVEL],RLf_64BIT
FNINIT
MOV RAX,SYS_FIXED_AREA+CSysFixedArea.init_fpu_mmx
@@ -301,7 +302,6 @@ USE64 BTS U32 [SYS_RUN_LEVEL],RLf_64BIT
MOV U64 CTask.code_heap[RAX],RDI
MOV U64 CTask.data_heap[RAX],RDI
MOV U32 CTask.task_signature[RAX],TASK_SIGNATURE_VAL
MOV U32 CTask.task_in_que_signature[RAX],TASK_IN_QUE_SIGNATURE_VAL
BTS U32 [SYS_RUN_LEVEL],RLf_BOOT_HEAP
@@ -369,6 +369,6 @@ USE32
MOV EBX,BOOT_SRC_RAM
MOV EAX,I32 BSP_32BIT_INIT
JMP EAX
USE64
SYS_RAM_REBOOT_END::
USE64
}
Kernel/KUtils.CPP
-1
View File
@@ -1,5 +1,4 @@
asm {
USE64
_MEMSET::
PUSH RBP
MOV RBP,RSP
Kernel/KbdMouse/InputPointer.CPP
+3 -3
View File
@@ -1,5 +1,5 @@
U0 GridInit()
{//Init input pointer grid struct.
{//Init input pointer grid struct. See $LK,"::/Demo/Graphics/Grid.CPP.Z"$.
ip_grid.x=ip_grid.y=ip_grid.z=8;
ip_grid.x_offset=ip_grid.y_offset=ip_grid.z_offset=0;
ip_grid.x_speed =ip_grid.y_speed =ip_grid.z_speed =1;
@@ -41,8 +41,8 @@ U0 IPVarsUpdate(I64 x,I64 y,I64 z,Bool l,Bool r)
}
U0 IPSet(I64 x=MAX_I64,I64 y=MAX_I64,I64 z=MAX_I64,I64 l=MAX_I64,I64 r=MAX_I64)
{//Note: Generates a message.
Bool old_preempt=Preempt(OFF);
{//Note: Generates a message. See $LK,"IPSet",A="FF:::/Demo/Games/Zing.CPP.Z,IPSet"$().
Bool old_preempt=Preempt;
if (!(0<=x<GR_WIDTH))
x=ip.pos.x;
if (!(0<=y<GR_HEIGHT))
Kernel/KbdMouse/Keyboard.CPP
+21 -34
View File
@@ -13,8 +13,10 @@ SHIFT_KEY_SCAN_DECODE_TABLE::
DU8 0,0,0,0,0,0,0,0,0,0,'-',0,0,0,'+',0;
CTRL_KEY_SCAN_DECODE_TABLE::
DU8 0,CH_ESC,"1234567890-=",CH_BACKSPACE,'\t';
DU8 CH_CTRLQ,CH_CTRLW,CH_CTRLE,CH_CTRLR,CH_CTRLT,CH_CTRLY,CH_CTRLU,CH_CTRLI,CH_CTRLO,CH_CTRLP,"[]",'\n',0,CH_CTRLA,CH_CTRLS;
DU8 CH_CTRLD,CH_CTRLF,CH_CTRLG,CH_CTRLH,CH_CTRLJ,CH_CTRLK,CH_CTRLL,";'\`",0,"\\",CH_CTRLZ,CH_CTRLX,CH_CTRLC,CH_CTRLV;
DU8 CH_CTRLQ,CH_CTRLW,CH_CTRLE,CH_CTRLR,CH_CTRLT,CH_CTRLY,CH_CTRLU,
CH_CTRLI,CH_CTRLO,CH_CTRLP,"[]",'\n',0,CH_CTRLA,CH_CTRLS;
DU8 CH_CTRLD,CH_CTRLF,CH_CTRLG,CH_CTRLH,CH_CTRLJ,CH_CTRLK,CH_CTRLL,
";'\`",0,"\\",CH_CTRLZ,CH_CTRLX,CH_CTRLC,CH_CTRLV;
DU8 CH_CTRLB,CH_CTRLN,CH_CTRLM,",./",0,'*',0,CH_SPACE,0,0,0,0,0,0;
DU8 0,0,0,0,0,0,0,0,0,0,'-',0,0,0,'+',0;
}
@@ -49,7 +51,7 @@ U0 KbdCmdFlush()
U0 KbdSetLEDs(I64 sc)
{
Bool old_preempt=Preempt(OFF);
Bool old_preempt=Preempt;
U8 v=0;
BEqu(&v,0,Bt(&sc,SCf_SCROLL));
BEqu(&v,1,Bt(&sc,SCf_NUM));
@@ -165,8 +167,10 @@ U8 scan_code_map[0x100]={
0,0,0,0,0,0,0,0,0,0,0,0,SC_ENTER,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,SC_ALT,0,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_INS,SC_DELETE,0,0,0,0,0,0,0,0,SC_GUI,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_INS,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,
};
@@ -185,8 +189,10 @@ U8 num_lock_map[0x100]={
0,0,0,0,0,0,0,0,0,0,0,0,SC_ENTER,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,SC_ALT,0,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_INS,SC_DELETE,0,0,0,0,0,0,0,0,SC_GUI,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_INS,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,
};
@@ -194,7 +200,7 @@ U8 num_lock_map[0x100]={
U8 *Char2KeyName(I64 ch,Bool include_ctrl=TRUE)
{//ASCII val to key name.
I64 i;
U8 buf[136];
U8 buf[STR_LEN];
if (ch<=CH_SPACE) {
nobound_switch (ch) {
case '\n':
@@ -230,7 +236,7 @@ U8 *Char2KeyName(I64 ch,Bool include_ctrl=TRUE)
buf[i+1]=0;
break;
}
} else if (Bt(chars_bitmap_printable,ch)) {
} else if (Bt(chars_bmp_printable,ch)) {
*buf=ch;
buf[1]=0;
} else
@@ -241,7 +247,7 @@ U8 *Char2KeyName(I64 ch,Bool include_ctrl=TRUE)
U8 *ScanCode2KeyName(I64 sc)
{//Scan code to key name.
I64 ch;
U8 buf[136],*st;
U8 buf[STR_LEN],*st;
*buf=0;
if (sc&SCF_CTRL)
CatPrint(buf,"CTRL ");
@@ -262,8 +268,8 @@ U8 *ScanCode2KeyName(I64 sc)
case SC_CURSOR_UP:CatPrint(buf,"UP"); break;
case SC_CURSOR_DOWN:CatPrint(buf,"DOWN"); break;
case SC_CURSOR_LEFT:CatPrint(buf,"LEFT"); break;
case SC_CURSOR_RIGHT:CatPrint(buf,"RIGHT"); break;
case SC_PAGE_UP: CatPrint(buf,"PAGE_UP"); break;
case SC_CURSOR_RIGHT:CatPrint(buf,"RIGHT"); break;
case SC_PAGE_UP: CatPrint(buf,"PAGE_UP"); break;
case SC_PAGE_DOWN:CatPrint(buf,"PAGE_DOWN");break;
case SC_HOME: CatPrint(buf,"HOME"); break;
case SC_END: CatPrint(buf,"END"); break;
@@ -281,9 +287,9 @@ U8 *ScanCode2KeyName(I64 sc)
case SC_F10: CatPrint(buf,"F10"); break;
case SC_F11: CatPrint(buf,"F11"); break;
case SC_F12: CatPrint(buf,"F12"); break;
case SC_GUI: CatPrint(buf,"WINDOWS"); break;
case SC_PRTSCRN1: CatPrint(buf,"PRTSCRN1"); break;
case SC_PRTSCRN2: CatPrint(buf,"PRTSCRN2"); break;
case SC_GUI: CatPrint(buf,"WINDOWS"); break;
case SC_PRTSCRN1: CatPrint(buf,"PRTSCRN1"); break;
case SC_PRTSCRN2: CatPrint(buf,"PRTSCRN2"); break;
}
}
return StrNew(buf);
@@ -398,17 +404,6 @@ interrupt U0 KbdIntHandler()
KbdPktRead;
}
U0 CtrlAltLetCBSet(U8 ch,U0 (*fp_handler)(I64 sc),U8 *desc,Bool in_irq=FALSE)
{//Set callback for <CTRL-ALT-letter>.
ch=ToUpper(ch)-'A';
if (ch<26) {
keydev.fp_ctrl_alt_let_cbs[ch]=fp_handler;
Free(keydev.ctrl_alt_let_descs[ch]);
keydev.ctrl_alt_let_descs[ch]=AStrNew(desc);
BEqu(&keydev.ctrl_alt_let_in_irq_flags,ch,in_irq);
}
}
U0 KbdInit()
{
try {
@@ -424,14 +419,6 @@ U0 KbdInit()
}
IntEntrySet(0x21,&KbdIntHandler);
OutU8(0x21,InU8(0x21)&~2);
CtrlAltLetCBSet('C',&CtrlAltC,"Sys/Break Execution",TRUE);
CtrlAltLetCBSet('D',&CtrlAltD,"Sys/Enter Debugger",TRUE);
CtrlAltLetCBSet('E',&CtrlAltE,"Sys/Spawn New User Task");
CtrlAltLetCBSet('F',&CtrlAltF,"Sys/VGA Flush",TRUE);
CtrlAltLetCBSet('M',&CtrlAltM,"Sys/Toggle Mute");
CtrlAltLetCBSet('T',&CtrlAltT,"Sys/Switch Focus to Next Task",TRUE);
CtrlAltLetCBSet('X',&CtrlAltX,"Sys/Kill Focused Task",TRUE);
}
U0 KbdHandler()
Kernel/KbdMouse/Message.CPP
+12 -12
View File
@@ -20,10 +20,10 @@ U0 InputFilterTask()
SetRFlags(old_flags);
Preempt(ON);
try
ExePrint("%s",tempc->aux_str);
ExePrint("%s",tempc->aux_str);
catch
Fs->catch_except=TRUE;
Preempt(OFF);
Preempt;
SrvCmdDel(tempc);
} else
break;
@@ -66,8 +66,8 @@ Note: This delivers messages from parent down to pop-up.
*_a2=tempc->aux2;
SrvCmdDel(tempc);
if ((result!=MSG_KEY_DOWN || !(tempc->aux2&SCF_KEY_DESC) ||
Bt(&mask,MSGF_ALLOW_KEY_DESC)) && Bt(&mask,result))
goto sm_done;
Bt(&mask,MSGF_ALLOW_KEY_DESC)) && Bt(&mask,result))
goto sm_done;
}
}
SetRFlags(old_flags);
@@ -97,9 +97,9 @@ I64 FlushMsgs(CTask *task=NULL)
I64 GetMsg(I64 *_a1=NULL,I64 *_a2=NULL,I64 mask=~1,CTask *task=NULL)
{//Wait for a message of type specified by a one in the mask.
//Throw-out all messages not in mask.
//Returns $LK,"msg_code",A="MN:MSG_CMD"$. See $LK,"::/Demo/MsgLoop.CPP"$.
//Returns $LK,"msg_code",A="MN:MSG_CMD"$. See $LK,"::/Demo/MsgLoop.CPP"$.
I64 result;
Bool old_preempt=Preempt(OFF);
Bool old_preempt=Preempt;
if (!task) task=Fs;
LBtr(&task->task_flags,TASKf_IDLE);
while (!(result=ScanMsg(_a1,_a2,mask,task))) {
@@ -114,7 +114,7 @@ I64 GetMsg(I64 *_a1=NULL,I64 *_a2=NULL,I64 mask=~1,CTask *task=NULL)
I64 ScanChar()
{//Checks for $LK,"MSG_KEY_DOWN",A="MN:MSG_KEY_DOWN"$ and returns 0 immediately if no key.
//Waits for $LK,"MSG_KEY_UP",A="MN:MSG_KEY_UP"$ of non-zero $LK,"ASCII",A="MN:CH_CTRLA"$ key and returns $LK,"ASCII",A="MN:CH_CTRLA"$ if key.
//$LK,"ScanMsg",A="MN:ScanMsg"$() throws away other message types.
//$LK,"ScanMsg",A="MN:ScanMsg"$() throws away other message types.
I64 a1a,a2a,a1b,a2b;
if (!ScanMsg(&a1a,&a2a,1<<MSG_KEY_DOWN)||!a1a)
return 0;
@@ -127,8 +127,8 @@ I64 ScanChar()
Bool ScanKey(I64 *_ch=NULL,I64 *_scan_code=NULL,Bool echo=FALSE)
{//Checks for $LK,"MSG_KEY_DOWN",A="MN:MSG_KEY_DOWN"$ and returns FALSE immediately if no key.
//Sets $LK,"ASCII",A="MN:CH_CTRLA"$ and $LK,"scan_code",A="FI:::/Doc/CharOverview.TXT"$.
//Removes key message and returns TRUE.
//$LK,"ScanMsg",A="MN:ScanMsg"$() throws away other message types.
//Removes key message and returns TRUE.
//$LK,"ScanMsg",A="MN:ScanMsg"$() throws away other message types.
I64 ch=0,sc=0;
if (ScanMsg(&ch,&sc,1<<MSG_KEY_DOWN)) {
if (_ch) *_ch=ch;
@@ -146,9 +146,9 @@ Bool ScanKey(I64 *_ch=NULL,I64 *_scan_code=NULL,Bool echo=FALSE)
I64 GetKey(I64 *_scan_code=NULL,Bool echo=FALSE,Bool raw_cursor=FALSE)
{//Waits for $LK,"MSG_KEY_DOWN",A="MN:MSG_KEY_DOWN"$ message and returns $LK,"ASCII",A="MN:CH_CTRLA"$.
//Sets $LK,"scan_code",A="FI:::/Doc/CharOverview.TXT"$.
//$LK,"ScanKey",A="MN:ScanKey"$() throws away other message types.
//$LK,"ScanKey",A="MN:ScanKey"$() throws away other message types.
I64 ch,sc;
Bool old_preempt=Preempt(OFF),cursor_on=FALSE;
Bool old_preempt=Preempt,cursor_on=FALSE;
while (!ScanKey(&ch,&sc,FALSE)) {
if (IsRaw && raw_cursor) {
if (!cursor_on && ToI64(GetTSC*5/cnts.time_stamp_freq)&1) {
@@ -161,7 +161,7 @@ I64 GetKey(I64 *_scan_code=NULL,Bool echo=FALSE,Bool raw_cursor=FALSE)
}
LBts(&Fs->task_flags,TASKf_IDLE);
if (IsDbg) {
//We don't want interrupt-driven keyboard when in debugger
//We don't want interrupt-driven keyboard when in debugger
//because that could have side-effects or crash, so we poll
//keyboard when in debugger with interrupts off.
PUSHFD
Kernel/KbdMouse/Mouse.CPP
+17 -14
View File
@@ -49,7 +49,7 @@ Bool MouseRst()
if (*_w==0x9FC0) {
_b=0x9FC00+0x30;
*_b=1; //This enables my mouse. It might be for one machine.
//USB DMA packets, set-up by BIOS to make legacy PS/2?
//USB DMA packets, set-up by BIOS to make legacy PS/2?
}
if (!present)
MemPagePresentMark(_w,FALSE);
@@ -71,7 +71,7 @@ Bool MouseRst()
while (tS<timeout);
try
KbdCmdRead;
KbdCmdRead;
catch
Fs->catch_except=TRUE;
@@ -98,7 +98,7 @@ Bool MouseRst()
KbdMouseCmdAck(0xF4); // enable Mouse
result=TRUE;
//Enable IRQ 12
//Enable IRQ 12
KbdCmdSend(KBD_CTRL,0x20);
b=KbdCmdRead;
KbdCmdSend(KBD_CTRL,0x60);
@@ -107,12 +107,12 @@ Bool MouseRst()
} catch
Fs->catch_except=TRUE;
//This is been added to override failure
//because the mouse sometimes still works.
result=TRUE;
//This is been added to override failure
//because the mouse sometimes still works.
result=TRUE;
try
KbdCmdSend(KBD_CTRL,0xAE); //Enable Keyboard
KbdCmdSend(KBD_CTRL,0xAE); //Enable Keyboard
catch
Fs->catch_except=TRUE;
if (mouse.has_wheel || mouse.has_ext_buttons)
@@ -121,7 +121,7 @@ Bool MouseRst()
mouse.pkt_size=3;
if (!result)
try
KbdCmdSend(KBD_CTRL,0xA7); //Disable Mouse
KbdCmdSend(KBD_CTRL,0xA7); //Disable Mouse
catch
Fs->catch_except=TRUE;
return result;
@@ -130,8 +130,9 @@ Bool MouseRst()
U0 MouseSpeedSet()
{
I64 dd,temp;
if ((dd=SqrI64(mouse_last.pos.x-mouse.pos.x)+SqrI64(mouse_last.pos.y-mouse.pos.y)) &&
(temp=mouse.timestamp-mouse_last.timestamp))
if ((dd=SqrI64(mouse_last.pos.x-mouse.pos.x)
+SqrI64(mouse_last.pos.y-mouse.pos.y)) &&
(temp=mouse.timestamp-mouse_last.timestamp))
mouse.speed=Sqrt(dd)*cnts.time_stamp_freq/temp;
mouse_last.timestamp=mouse.timestamp;
}
@@ -150,7 +151,8 @@ U0 MouseUpdatePost()
mouse.pos.y=mouse.prescale.y*mouse.scale.y*ip_grid.y_speed;
mouse.pos.z=mouse.prescale.z*mouse.scale.z*ip_grid.z_speed;
i=Trunc(ip.scale.x*mouse.pos.x/ip_grid.x)*ip_grid.x+ip.offset.x; //TODO ip_grid.x_offset?
i=Trunc(ip.scale.x*mouse.pos.x/ip_grid.x)*ip_grid.x+ip.offset.x;
//TODO ip_grid.x_offset?
if (i<0)
ip.offset.x-=i;
else if (i>=GR_WIDTH)
@@ -162,7 +164,8 @@ U0 MouseUpdatePost()
else if (i>=GR_HEIGHT)
ip.offset.y+=GR_HEIGHT-1-i;
if (mouse.pos.x!=mouse_last.pos.x || mouse.pos.y!=mouse_last.pos.y || mouse.pos.z!=mouse_last.pos.z) {
if (mouse.pos.x!=mouse_last.pos.x || mouse.pos.y!=mouse_last.pos.y ||
mouse.pos.z!=mouse_last.pos.z) {
mouse.evt=TRUE;
MouseSpeedSet;
} else
@@ -264,8 +267,8 @@ U0 KbdMouseHandler(Bool poll_kbd,Bool poll_mouse)
KbdMouseRst;
else {
if (poll_mouse &&
mouse.installed &&
!mouse.irqs_working) {
mouse.installed &&
!mouse.irqs_working) {
PUSHFD
CLI
while (InU8(KBD_CTRL)&1)
Kernel/Kernel.MAP
+2808 -3212
View File
File diff suppressed because it is too large. Load diff
Kernel/Kernel.PRJ
+9 -20
View File
@@ -14,7 +14,12 @@
#include "KStart"
#include "KUtils"
#include "KMathA"
#exe {OptOn(OPTf_KEEP_PRIVATE);};
#include "/Compiler/CompilerA.HPP"
#exe {OptOn(OPTf_EXTERNS_TO_IMPORTS);};
#include "/Compiler/CompilerB.HPP"
#exe {OptOff(OPTf_EXTERNS_TO_IMPORTS);};
#exe {OptOff(OPTf_KEEP_PRIVATE);};
#include "KernelB.HPP"
#include "KExts"
#include "StrA"
@@ -37,38 +42,22 @@
#include "StrScan"
#include "KDefine"
#include "Display"
#include "KeyDev"
#include "KMisc"
#include "KDbg"
#include "Except"
#include "KeyDev"
#include "KExcept"
#include "KbdMouse/InputPointer"
#include "KbdMouse/Keyboard"
#include "KbdMouse/Mouse"
#include "KbdMouse/Message"
#include "QSort"
#include "Task"
#include "SrvCmd"
#include "BIOS32"
#include "PCIBIOS"
#exe {Cd("Dsk");};
#include "DskStr"
#include "DskCache"
#include "DskATA"
#include "DskATAId"
#include "DskA"
#include "DskAddDev"
#include "DskDir"
#include "FileSysISO"
#include "FileSysRedSea"
#include "FileSysFAT"
#include "DskB"
#include "DskCFile"
#include "DskC"
#include "Dsk"
#exe {Cd("..");};
#include "MultiProc"
#include "EdLite"
#include "PSect"
#include "KEnd"
Kernel/KernelA.HPP
+397 -389
View File
File diff suppressed because it is too large. Load diff
Kernel/KernelB.HPP
+123 -66
View File
@@ -6,19 +6,32 @@ $LK,"KernelB",A="FF:::/Adam.CPP,KernelB"$ Adam.CPP
#help_index "Bit"
#help_file "::/Doc/Bit"
public _intern IC_BSF I64 Bsf(I64 bit_field_val);//Scan fwd from lowest for 1st set. -1 if not found.
public _intern IC_BSR I64 Bsr(I64 bit_field_val);//Scan rev from highest for 1st set. -1 if not found.
public _intern IC_BT Bool Bt(U8 *bit_field,I64 bit); //Bit test.
public _intern IC_BTC Bool Btc(U8 *bit_field,I64 bit); //Bit test and complement (same as xor with 1).
public _intern IC_BTR Bool Btr(U8 *bit_field,I64 bit); //Bit test and reset to zero.
public _intern IC_BTS Bool Bts(U8 *bit_field,I64 bit); //Bit test and set to one.
public _intern IC_LBTC Bool LBtc(U8 *bit_field,I64 bit); //Locked Bit test and complement (same as xor with 1).
public _intern IC_LBTR Bool LBtr(U8 *bit_field,I64 bit); //Locked Bit test and reset to zero.
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.
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.
public _intern IC_BSF I64 Bsf(
I64 bit_field_val);//Scan fwd from lowest for 1st set. -1 if not found.
public _intern IC_BSR I64 Bsr(
I64 bit_field_val);//Scan rev from highest for 1st set. -1 if not found.
public _intern IC_BT Bool Bt(
U8 *bit_field,I64 bit); //Bit test.
public _intern IC_BTC Bool Btc(
U8 *bit_field,I64 bit); //Bit test and complement (same as xor with 1).
public _intern IC_BTR Bool Btr(
U8 *bit_field,I64 bit); //Bit test and reset to zero.
public _intern IC_BTS Bool Bts(
U8 *bit_field,I64 bit); //Bit test and set to one.
public _intern IC_LBTC Bool LBtc(
U8 *bit_field,I64 bit); //Locked bit test and complement (xor with 1).
public _intern IC_LBTR Bool LBtr(
U8 *bit_field,I64 bit); //Locked bit test and reset to zero.
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.
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.
#help_index "Boot"
_extern SYS_BOOT_BASE U32 sys_boot_base;
@@ -27,14 +40,18 @@ _extern SYS_BOOT_SRC U32 sys_boot_src;
_extern SYS_RUN_LEVEL U32 sys_run_level;
#help_index "Call"
public _extern _CALL I64 Call(U8 *s); //Call addr with no args.
public _extern _CALLEXTSTR I64 CallExtStr(/*argpop*/ U8 *name,...); //Search sym table for fun name and pass it args.
public _extern _CALL I64 Call(U8 *machine_code); //Call addr with no args.
public _extern _CALLEXTSTR I64 CallExtStr(
/*argpop*/ U8 *name,...); //Search sym table for fun and pass it args.
//Can have any fixed number of arguments.
public _extern _CALLIND I64 CallInd(/*argpop*/I64 (*fp_addr)(...),...); //Call with any fixed number of arguments.
public _extern _CALLIND I64 CallInd(
/*argpop*/I64 (*fp_addr)(...),...); //Call with fixed number of args.
#help_index "Call/System Extern Num"
public _extern SYS_EXTERN_TABLE /*argpop*/ I64 (**ext)(...); //Array of fun ptrs. See $LK,"Extern Num Definitions",A="MN:EXT_NUM_ENTRIES"$
public _extern _CALLEXTNUM I64 CallExtNum(I64 num,...); //Call ext num with any fixed number of args.
public _extern SYS_EXTERN_TABLE /*argpop*/
I64 (**ext)(...); //Array of fun ptrs. See $LK,"Extern Num Definitions",A="MN:EXT_NUM_ENTRIES"$
public _extern _CALLEXTNUM
I64 CallExtNum(I64 num,...); //Call ext num with fixed number of args.
#help_index "Char/Conversion"
public _intern IC_TOUPPER I64 ToUpper(U8 ch); //Cvt char to upper case.
@@ -44,11 +61,14 @@ public _intern IC_STRLEN I64 StrLen(U8 *st); //String length.
#help_index "Data Types/Circular Queue"
#help_file "::/Doc/Que"
public _intern IC_QUE_INIT U0 QueInit(CQue *root); //Init queue root links.
public _intern IC_QUE_INS U0 QueIns(CQue *entry,CQue *pred);//Ins item into que after predecessor.
public _intern IC_QUE_INS_REV U0 QueInsRev(CQue *entry,CQue *succ);//Reversed insert into que.
public _intern IC_QUE_INIT U0 QueInit(
CQue *root); //Init queue root links.
public _intern IC_QUE_INS U0 QueIns(
CQue *entry,CQue *pred);//Insert item into que after predecessor.
public _intern IC_QUE_INS_REV U0 QueInsRev(
CQue *entry,CQue *succ);//Reversed insert into que.
//Ins item into que before successor.
public _intern IC_QUE_REM U0 QueRem(CQue *entry); //Remove Item from queue.
public _intern IC_QUE_REM U0 QueRem(CQue *entry); //Remove item from queue.
#help_index "I/O;Processor/IO Port"
public _intern IC_IN_U16 I64 InU16(I64 port); //Read U16 from I/O port.
@@ -57,12 +77,18 @@ public _intern IC_IN_U8 I64 InU8(I64 port); //Read U8 from I/O port.
public _intern IC_OUT_U16 U0 OutU16(I64 port, I64 val); //Write U16 to I/O port.
public _intern IC_OUT_U32 U0 OutU32(I64 port, I64 val); //Write U32 to I/O port.
public _intern IC_OUT_U8 U0 OutU8(I64 port, I64 val); //Write U8 to I/O port.
public _extern _REP_IN_U16 U0 RepInU16(U8 *buf,I64 cnt,I64 port); //Repeated read U16 from I/O port.
public _extern _REP_IN_U32 U0 RepInU32(U8 *buf,I64 cnt,I64 port); //Repeated read U32 from I/O port.
public _extern _REP_IN_U8 U0 RepInU8(U8 *buf,I64 cnt,I64 port); //Repeated read U8 from I/O port.
public _extern _REP_OUT_U16 U0 RepOutU16(U8 *buf,I64 cnt,I64 port); //Repeated write U16 to I/O port.
public _extern _REP_OUT_U32 U0 RepOutU32(U8 *buf,I64 cnt,I64 port); //Repeated write U32 to I/O port.
public _extern _REP_OUT_U8 U0 RepOutU8(U8 *buf,I64 cnt,I64 port); //Repeated write U8 to I/O port.
public _extern _REP_IN_U16 U0 RepInU16(
U8 *buf,I64 cnt,I64 port); //Repeated read U16 from I/O port.
public _extern _REP_IN_U32 U0 RepInU32(
U8 *buf,I64 cnt,I64 port); //Repeated read U32 from I/O port.
public _extern _REP_IN_U8 U0 RepInU8(
U8 *buf,I64 cnt,I64 port); //Repeated read U8 from I/O port.
public _extern _REP_OUT_U16 U0 RepOutU16(
U8 *buf,I64 cnt,I64 port); //Repeated write U16 to I/O port.
public _extern _REP_OUT_U32 U0 RepOutU32(
U8 *buf,I64 cnt,I64 port); //Repeated write U32 to I/O port.
public _extern _REP_OUT_U8 U0 RepOutU8(
U8 *buf,I64 cnt,I64 port); //Repeated write U8 to I/O port.
#help_index "Math"
public _intern IC_ATAN F64 ATan(F64 d); //Arc Tan (Inverse Tan).
@@ -73,25 +99,31 @@ public _intern IC_MAX_I64 I64 MaxI64(I64 n1,I64 n2); //Max of two I64s.
public _intern IC_MAX_U64 U64 MaxU64(U64 n1,U64 n2); //Max of two U64s.
public _intern IC_MIN_I64 I64 MinI64(I64 n1,I64 n2); //Min of two I64s.
public _intern IC_MIN_U64 U64 MinU64(U64 n1,U64 n2); //Min of two U64s.
public _intern IC_MOD_U64 U64 ModU64(U64 *q,U64 d); //Divide and return U64 Modulo.
public _intern IC_MOD_U64 U64 ModU64(U64 *q,U64 d); //Div and return U64 Modulo.
public _intern IC_SIGN_I64 I64 SignI64(I64 i); //Sign of I64: -1,0,1.
public _intern IC_SIN F64 Sin(F64 d); //Sine.
public _intern IC_SQR F64 Sqr(F64 d); //Square of F64.
public _intern IC_SQR_I64 I64 SqrI64(I64 i); //Square of I64.
public _intern IC_SQR_U64 U64 SqrU64(U64 i); //Square of U64.
public _intern IC_SQRT F64 Sqrt(F64 d); //Square root of F64.
public _intern IC_SWAP_I64 U0 SwapI64(I64 *n1,I64 *n2); //Swap two I64s. Not atomic.
public _intern IC_SWAP_U16 U0 SwapU16(U16 *n1,U16 *n2); //Swap two U16s. Not atomic.
public _intern IC_SWAP_U32 U0 SwapU32(U32 *n1,U32 *n2); //Swap two U32s. Not atomic.
public _intern IC_SWAP_U8 U0 SwapU8(U8 *n1,U8 *n2); //Swap two U8s. Not atomic.
public _intern IC_SWAP_I64 U0 SwapI64(
I64 *n1,I64 *n2); //Swap two I64s. Not atomic.
public _intern IC_SWAP_U16 U0 SwapU16(
U16 *n1,U16 *n2); //Swap two U16s. Not atomic.
public _intern IC_SWAP_U32 U0 SwapU32(
U32 *n1,U32 *n2); //Swap two U32s. Not atomic.
public _intern IC_SWAP_U8 U0 SwapU8(
U8 *n1,U8 *n2); //Swap two U8s. Not atomic.
public _intern IC_TAN F64 Tan(F64 d); //Tangent.
public _intern IC_TO_BOOL Bool ToBool(I64 i); //Convert to Boolean.
public _intern IC_TO_F64 F64 ToF64(I64 i); //Convert to F64.
public _intern IC_TO_I64 I64 ToI64(F64 d); //Convert to I64. Truncates.
public _extern _ARG F64 Arg(F64 x,F64 y); //Polar coordinate angle.
public _extern _CEIL F64 Ceil(F64 d); //Ceiling of F64.
public _extern _CLAMP_I64 I64 ClampI64(I64 dv,I64 lo,I64 hi); //Clamp to I64 [] range.
public _extern _CLAMP_U64 U64 ClampU64(U64 dv,U64 lo,U64 hi); //Clamp to U64 [] range.
public _extern _CLAMP_I64 I64 ClampI64(
I64 dv,I64 lo,I64 hi); //Clamp to I64 [] range.
public _extern _CLAMP_U64 U64 ClampU64(
U64 dv,U64 lo,U64 hi); //Clamp to U64 [] range.
public _extern _EXP F64 Exp(F64 d); //Exponential function.
_extern _FCLEX U0 Fclex();
_extern _FLDCW U0 Fldcw(U16 w);
@@ -109,14 +141,20 @@ public _extern _ROUND F64 Round(F64 d); //Round F64 to whole number.
public _extern _SIGN F64 Sign(F64 d); //Sign of F64: -1,0,1
public _extern _TRUNC F64 Trunc(F64 d); //Truncate F64.
#help_index "Math/CD3"
#help_index "Math/CD3;Data Types/CD3"
#help_file "::/Doc/D3"
public _extern _D3_ADD CD3 *D3Add(CD3 *d1,CD3 *d2,CD3 *sum); //d1+d2 -->sum
public _extern _D3_ADD_EQU CD3 *D3AddEqu(CD3 *sum,CD3 *d); //sum+=d
public _extern _D3_COPY CD3 *D3Copy(CD3 *dst,CD3 *src); //dst=src
public _extern _D3_CROSS CD3 *D3Cross(CD3 *d1,CD3 *d2,CD3 *prod); //d1 x d2 -->prod
public _extern _D3_DIST F64 D3Dist(CD3 *d1,CD3 *d2); //Dist between d1 & d2
public _extern _D3_DIST_SQR F64 D3DistSqr(CD3 *d1,CD3 *d2); //Dist Squared between d1 & d2
public _extern _D3_ADD CD3 *D3Add(
CD3 *d1,CD3 *d2,CD3 *sum); //d1+d2 -->sum
public _extern _D3_ADD_EQU CD3 *D3AddEqu(
CD3 *sum,CD3 *d); //sum+=d
public _extern _D3_COPY CD3 *D3Copy(
CD3 *dst,CD3 *src); //dst=src
public _extern _D3_CROSS CD3 *D3Cross(
CD3 *d1,CD3 *d2,CD3 *prod); //d1 x d2 -->prod
public _extern _D3_DIST F64 D3Dist(
CD3 *d1,CD3 *d2); //Dist between d1 & d2
public _extern _D3_DIST_SQR F64 D3DistSqr(
CD3 *d1,CD3 *d2); //Dist Squared between d1 & d2
public _extern _D3_DIV CD3 *D3Div(F64 s,CD3 *d,CD3 *quot); //1/s * d -->quot
public _extern _D3_DIV_EQU CD3 *D3DivEqu(CD3 *quot,F64 s); //quot *= 1/s
public _extern _D3_DOT F64 D3Dot(CD3 *d1,CD3 *d2); //d1 dot d2
@@ -126,25 +164,32 @@ public _extern _D3_MUL_EQU CD3 *D3MulEqu(CD3 *prod,F64 s); //prod *= s
public _extern _D3_NORM F64 D3Norm(CD3 *d); //Norm d
public _extern _D3_NORM_SQR F64 D3NormSqr(CD3 *d); //Norm Squared d
public _extern _D3_SUB CD3 *D3Sub(CD3 *d1,CD3 *d2,CD3 *diff); //d1-d2 -->diff
public _extern _D3_UNIT CD3 *D3Unit(CD3 *d); //Convert to unit vect
public _extern _D3_SUB_EQU CD3 *D3SubEqu(CD3 *diff,CD3 *d); //diff-=d
public _extern _D3_UNIT CD3 *D3Unit(CD3 *d); //Convert to unit vect
public _extern _D3_ZERO CD3 *D3Zero(CD3 *dst); //Convert to zero
#help_index "Memory"
public _extern _MEMCMP I64 MemCmp(U8 *ptr1,U8 *ptr2,I64 cnt); //Compare chunk of memory.
public _extern _MEMCPY U8 *MemCpy(U8 *dst,U8 *src,I64 cnt); //Copy chunk of memory. Only goes fwd.
public _extern _MEMSET U8 *MemSet(U8 *dst,I64 val,I64 cnt); //Set chunk of U8s to value.
public _extern _MEMSET_I64 I64 *MemSetI64(I64 *dst,I64 val,I64 I64cnt); //Set chunk of I64s to value.
public _extern _MEMSET_U16 U16 *MemSetU16(U16 *dst,I64 val,I64 U16cnt); //Set chunk of U16s to value.
public _extern _MEMSET_U32 U32 *MemSetU32(U32 *dst,I64 val,I64 U32cnt); //Set chunk of U32s to value.
public _extern _MEMSET U8 *MemSetU8(U8 *dst,I64 val,I64 U8cnt); //Set chunk of U8s to value.
public _extern _MEMCMP I64 MemCmp(
U8 *ptr1,U8 *ptr2,I64 cnt); //Compare chunk of memory.
public _extern _MEMCPY U8 *MemCpy(
U8 *dst,U8 *src,I64 cnt); //Copy chunk of memory. Only goes fwd.
public _extern _MEMSET U8 *MemSet(
U8 *dst,I64 val,I64 cnt); //Set chunk of U8s to value.
public _extern _MEMSET_I64 I64 *MemSetI64(
I64 *dst,I64 val,I64 I64cnt); //Set chunk of I64s to value.
public _extern _MEMSET_U16 U16 *MemSetU16(
U16 *dst,I64 val,I64 U16cnt); //Set chunk of U16s to value.
public _extern _MEMSET_U32 U32 *MemSetU32(
U32 *dst,I64 val,I64 U32cnt); //Set chunk of U32s to value.
public _extern _MEMSET U8 *MemSetU8(
U8 *dst,I64 val,I64 U8cnt); //Set chunk of U8s to value.
_extern SYS_HEAP_DBG_FLAG U8 sys_heap_dbg;
_extern SYS_HEAP_INIT_FLAG U8 sys_heap_init_flag;
_extern SYS_HEAP_INIT_VAL U8 sys_heap_init_val;
_extern SYS_MEM_INIT_FLAG U8 sys_mem_init_flag;
_extern SYS_MEM_INIT_VAL U8 sys_mem_init_val;
_extern SYS_VAR_INIT_VAL U8 sys_var_init_val;
_extern SYS_VAR_INIT_FLAG U8 sys_var_init_flag;
_extern SYS_VAR_INIT_VAL U8 sys_var_init_val;
#help_index "Memory/BlkPool"
public _extern SYS_CODE_BP CBlkPool *sys_code_bp; //System's BlkPool for code.
@@ -154,27 +199,34 @@ public _extern SYS_DATA_BP CBlkPool *sys_data_bp; //System's BlkPool for data.
_extern SYS_HEAP_BASE U8 *sys_heap_base;
_extern SYS_HEAP_LIMIT U8 *sys_heap_limit;
#help_index "Messages;Windows"
public _extern SYS_FOCUS_TASK CTask *sys_focus_task; //Current focus task.
#help_index "Misc"
public _extern SYS_COMPILE_TIME CDate sys_compile_time; //Date and time kernel was compiled.
_extern SYS_CTRL_ALT_FLAGS I64 sys_ctrl_alt_flags[1]; //Should be semiphores?
public _extern SYS_COMPILE_TIME
CDate sys_compile_time; //Date and time kernel was compiled.
_extern SYS_CTRL_ALT_FLAGS
I64 sys_ctrl_alt_flags[1]; //Should be semiphores?
#help_index "Misc/Progress Bars"
public _extern SYS_PROGRESS1 I64 progress1; //Current progress 1.
public _extern SYS_PROGRESS1_DESC U8 progress1_desc[PROGRESS_DESC_LEN+1]; //Progress 1 desc.
public _extern SYS_PROGRESS1_DESC
U8 progress1_desc[PROGRESS_DESC_LEN+1]; //Progress 1 desc.
public _extern SYS_PROGRESS1_MAX I64 progress1_max; //Max progress 1.
public _extern SYS_PROGRESS2 I64 progress2; //Current progress 2.
public _extern SYS_PROGRESS2_DESC U8 progress2_desc[PROGRESS_DESC_LEN+1]; //Progress 2 desc.
public _extern SYS_PROGRESS2_DESC
U8 progress2_desc[PROGRESS_DESC_LEN+1]; //Progress 2 desc.
public _extern SYS_PROGRESS2_MAX I64 progress2_max; //Max progress 2.
public _extern SYS_PROGRESS3 I64 progress3; //Current progress 3.
public _extern SYS_PROGRESS3_DESC U8 progress3_desc[PROGRESS_DESC_LEN+1]; //Progress 3 desc.
public _extern SYS_PROGRESS3_DESC
U8 progress3_desc[PROGRESS_DESC_LEN+1]; //Progress 3 desc.
public _extern SYS_PROGRESS3_MAX I64 progress3_max; //Max progress 3.
public _extern SYS_PROGRESS4 I64 progress4; //Current progress 4.
public _extern SYS_PROGRESS4_DESC U8 progress4_desc[PROGRESS_DESC_LEN+1]; //Progress 4 desc.
public _extern SYS_PROGRESS4_DESC
U8 progress4_desc[PROGRESS_DESC_LEN+1]; //Progress 4 desc.
public _extern SYS_PROGRESS4_MAX I64 progress4_max; //Max progress 4.
public _extern SYS_PROGRESSES CProgress sys_progresses[NUM_PROGRESS_BARS]; //All progress bars.
#help_index "Misc;Messages"
public _extern SYS_FOCUS_TASK CTask *sys_focus_task; //Current focus task.
public _extern SYS_PROGRESSES
CProgress sys_progresses[NUM_PROGRESS_BARS]; //All progress bars.
#help_index "MultiCore"
#help_file "::/Doc/MultiCore"
@@ -202,28 +254,33 @@ public _intern IC_SET_RAX U0 SetRAX(I64 d); //Set RAX register value.
public _intern IC_SET_RBP U0 SetRBP(U8 *d); //Set RBP register value.
public _intern IC_SET_RFLAGS U0 SetRFlags(I64 d); //Set RFlags register value.
public _intern IC_SET_RSP U0 SetRSP(U8 *d); //Set RSP register value.
public _extern _CPUID U0 CPUId(U32 rax,CRAXRBCRCXRDX *result); //Do CPUID instruction.
public _extern _CPUID U0 CPUId(
U32 rax,CRAXRBCRCXRDX *result); //Do CPUID instruction.
public _extern _LXCHG_I64 I64 LXchgI64(I64 *dst,I64 d); //Locked eXchange I64s.
public _extern _LXCHG_U16 U64 LXchgU16(U16 *dst,U16 d); //Locked eXchange U16s.
public _extern _LXCHG_U32 U64 LXchgU32(U32 *dst,U32 d); //Locked eXchange U32s.
public _extern _LXCHG_U8 U64 LXchgU8(U8 *dst,U8 d); //Locked eXchange U8s.
public _extern _SET_MSR U0 SetMSR(I64 model_specific_reg,I64 val); //Model Specific Reg See $LK,"MSRs",A="MN:IA32_EFER"$.
public _extern _SET_MSR U0 SetMSR(
I64 model_specific_reg,I64 val); //Model Specific Reg See $LK,"MSRs",A="MN:IA32_EFER"$.
public _extern _SYS_HLT U0 SysHlt(); //Loops doing HLT instruction.
public _extern _XCHG_I64 I64 XchgI64(I64 *dst,I64 d); //eXchange I64s.
public _extern _XCHG_U16 U64 XchgU16(U16 *dst,U16 d); //eXchange U16s.
public _extern _XCHG_U32 U64 XchgU32(U32 *dst,U32 d); //eXchange U32s.
public _extern _XCHG_U8 U64 XchgU8(U8 *dst,U8 d); //eXchange U8s.
public _extern SYS_CACHE_LINE_WIDTH I64 sys_cache_line_width; //CPU's Cache line width.
public _extern SYS_CACHE_LINE_WIDTH
I64 sys_cache_line_width; //CPU's Cache line width.
_extern SYS_GDT CGDT sys_gdt;
#help_index "Processor/Cache;Memory/Cache"
public _intern IC_CLFLUSH U0 CLFlush(U8 *a); //Flush cache line instruction.
#help_index "Processor/Page Tables;Memory/Page Tables"
public _intern IC_INVLPG U0 InvlPg(U8 *a); //Invalidate page at addr instruction.
public _intern IC_INVLPG
U0 InvlPg(U8 *a); //Invalidate page at addr instruction.
#help_index "Task"
public _intern IC_PREEMPT Bool Preempt(Bool val); //Turn mutli-tasking preemption OFF/ON.
public _intern IC_PREEMPT
Bool Preempt(Bool val=OFF); //Turn mutli-tasking preemption OFF/ON.
#help_index "Task;Processor"
public _intern IC_FS CTask *Fs(); //FS seg reg points to the current $LK,"CTask",A="MN:CTask"$.
Kernel/KernelC.HPP
+123 -81
View File
@@ -1,4 +1,4 @@
#help_index "AutoFile"
#help_index "AutoFile;StdIn/AutoFile"
#help_file "::/Doc/AutoFile"
#help_index "Bit"
@@ -25,15 +25,15 @@ public _extern C32_EFLAGS U32 c32_eflags;
public _extern C32_ESI U32 c32_esi;
#help_index "Char/BitMaps"
public extern U32 chars_bitmap_alpha[16],chars_bitmap_alpha_numeric[16],
chars_bitmap_alpha_numeric_no_at[16], chars_bitmap_word[16],
chars_bitmap_dec_numeric[16], chars_bitmap_hex_numeric[16],
chars_bitmap_white_space[16], chars_bitmap_non_eol_white_space[16],
chars_bitmap_zero_cr_nl_cursor[16], chars_bitmap_zero_tab_ff_cr_nl_cursor[16],
chars_bitmap_zero_tab_ff_cr_nl_cursor_dollar[16],chars_bitmap_getkey[16],
chars_bitmap_printable[16], chars_bitmap_displayable[16],
chars_bitmap_safe_dollar[16], chars_bitmap_filename[16],
chars_bitmap_non_eol[16];
public extern U32 chars_bmp_alpha[16],chars_bmp_alpha_numeric[16],
chars_bmp_alpha_numeric_no_at[16], chars_bmp_word[16],
chars_bmp_dec_numeric[16], chars_bmp_hex_numeric[16],
chars_bmp_white_space[16], chars_bmp_non_eol_white_space[16],
chars_bmp_zero_cr_nl_cursor[16], chars_bmp_zero_tab_ff_cr_nl_cursor[16],
chars_bmp_zero_tab_ff_cr_nl_cursor_dollar[16],chars_bmp_getkey[16],
chars_bmp_macro[16], chars_bmp_printable[16],
chars_bmp_displayable[16], chars_bmp_safe_dollar[16],
chars_bmp_filename[16], chars_bmp_non_eol[16];
#help_index "Char/Conversion"
public extern U8 *Char2KeyName(I64 ch,Bool include_ctrl=TRUE);
@@ -86,7 +86,7 @@ public extern U8 *AStrNew(U8 *buf);
#help_index "Char/Operations;Memory/Heap"
public extern U8 *StrNew(U8 *buf,CTask *mem_task=NULL);
#help_index "Char/Output"
#help_index "Char/Output;StdOut"
public extern U0 GetOutOfDollar();
public extern Bool IsSilent();
public extern U0 Print(U8 *fmt,...);
@@ -103,14 +103,16 @@ extern U8 *StrPrintHex(U8 *dst,I64 num;I64 width);
public extern CTextGlbls text;
#help_index "Compiler/Lex"
public extern U0 HashSrcFileSet(CLex *lx,CHashSrcSym *h,I64 line_num_offset=0);
public extern U0 HashSrcFileSet(CCmpCtrl *cc,
CHashSrcSym *h,I64 line_num_offset=0);
#help_index "Compiler;Cmd Line (Typically)"
extern U8 *Load(U8 *filename,I64 ld_flags=0,CBinFile *bfh_addr=INVALID_PTR); //INVALID_PTR means don't care what load addr.
extern U8 *Load(U8 *filename,I64 ld_flags=0,
CBinFile *bfh_addr=INVALID_PTR); //INVALID_PTR=don't care what load addr
#help_index "Compression"
public extern CArcCompress *CompressBuf(U8 *src,I64 size,CTask *mem_task=NULL);
public extern U8 *ExpandBuf(CArcCompress *r,CTask *mem_task=NULL);
public extern U8 *ExpandBuf(CArcCompress *arc,CTask *mem_task=NULL);
#help_index "Compression/Piece by Piece"
public extern U0 ArcCompressBuf(CArcCtrl *c);
@@ -162,24 +164,30 @@ public extern Bool IsSingleUser();
public extern Bool IsSysDbg();
public extern Bool SingleUser(Bool val);
public extern Bool SysDbg(Bool val);
public extern U8 *TaskCaller(CTask *task=NULL,I64 num=0,Bool saved_context=FALSE);
public extern U8 *TaskCaller(CTask *task=NULL,
I64 num=0,Bool saved_context=FALSE);
public extern I64 UnusedStk(CTask *task=NULL);
public extern CDbgGlbls dbg;
#help_index "Debugging/Debugger"
public extern Bool B(U8 *addr,CTask *task=NULL,Bool live=TRUE) //Toggle breakpoint
public extern Bool B(U8 *addr,CTask *task=NULL,Bool live=TRUE) //Toggle bpt.
public extern I64 B2(CTask *task=NULL,Bool live=TRUE);
extern CBpt *BptFind(U8 *needle_addr,CTask *haystack_task=NULL,Bool rem=FALSE);
public extern Bool BptR(U8 *addr,CTask *task=NULL,Bool live=TRUE,Bool rem=TRUE);
public extern Bool BptS(U8 *addr,CTask *task=NULL,Bool live=TRUE);
public extern Bool E(U8 *addr,I64 cnt=512,I64 edf_dof_flags=0);
public extern Bool EdLite(U8 *filename,I64 num=1,I64 edf_dof_flags=0);
extern Bool EdLiteFileLine(U8 *fl_file_line,I64 edf_dof_flags=0);
public extern Bool Fix(I64 edf_dof_flags=0);
public extern U0 FixSet(U8 *filename,I64 line);
public extern U0 G(U8 *ip=INVALID_PTR,CTask *task=NULL);
public extern U0 G2(U8 *ip=INVALID_PTR,CTask *task=NULL);
public extern Bool InDbg(Bool val);
public extern Bool IsDbg();
public extern U0 S(U8 *ip=INVALID_PTR,CTask *task=NULL);
#help_index "Debugging/Debugger;DolDoc/Cmd Line (Typically);Cmd Line (Typically);Training"
#help_index "Debugging/Debugger;DolDoc/Cmd Line (Typically);"\
"Cmd Line (Typically);Help System"
public extern Bool Man(U8 *st,I64 edf_dof_flags=0);
#help_index "Debugging/Dump"
@@ -198,7 +206,7 @@ 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"
#help_index "Debugging/PSect;Hash/System"
public extern CHash *PSectFind(U8 *addr,I64 *_offset);
#help_index "Debugging/Raw Output"
@@ -213,10 +221,6 @@ public extern U0 VGAFlush();
#help_index "Debugging;Debugging/Debugger"
public extern U0 Dbg(U8 *msg=NULL,I64 msg_num=0);
public extern Bool EdLite(U8 *filename,I64 num=1,I64 edf_dof_flags=0);
extern Bool EdLiteFileLine(U8 *fl_file_line,I64 edf_dof_flags=0);
public extern Bool Fix(I64 edf_dof_flags=0);
public extern U0 FixSet(U8 *filename,I64 line);
#help_index "Define;Char/Define"
#help_file "::/Doc/Define"
@@ -240,7 +244,8 @@ public extern CDevGlbls dev;
#help_index "DolDoc/Clipboard"
public extern CDoc *sys_clipboard_doc;
#help_index "DolDoc/Task"
#help_index "DolDoc/Task;StdOut/Task"
#help_file "::/Doc/StdOutTask"
extern CDoc *(*fp_doc_put)(CTask *task=NULL);
#help_index "Exceptions"
@@ -254,7 +259,8 @@ public extern U0 throw(I64 ch=0,Bool no_log=FALSE);
#help_index "File/CD DVD"
public extern U0 CDImageRead(U8 cd_drv_let,U8 *out_name);
public extern U0 CDImageWrite(U8 cd_drv_let,U8 *in_name=NULL,I64 media_type=MT_CD);
public extern U0 CDImageWrite(U8 cd_drv_let,
U8 *in_name=NULL,I64 media_type=MT_CD);
#help_index "File/CFile"
public extern U0 FClose(CFile *f);
@@ -266,12 +272,15 @@ public extern Bool FWBlks(CFile *f,U8 *buf,I64 blk=FFB_NEXT_BLK,I64 cnt=1);
#help_index "File/Cmd Line (Typically);Cmd Line (Typically)"
public extern Bool Cd(U8 *dirname=NULL,Bool make_dirs=FALSE);
public extern U0 ChgDsk(U8 drv_let=0);
public extern I64 Del(U8 *wild,Bool print_msg=TRUE);
public extern I64 Dir(U8 *wild="*",Bool full=FALSE);
public extern I64 Del(U8 *files_find_mask,Bool make_mask=FALSE,
Bool del_dir=FALSE,Bool print_msg=TRUE);
public extern I64 Dir(U8 *files_find_mask="*",Bool full=FALSE);
public extern Bool Drv(U8 drv_let);
public extern Bool MapDrv(U8 drv_let,CDrv *dv);
public extern Bool MkDir(U8 *filename);
#help_index "File/Cmd Line (Typically);Cmd Line (Typically);Install"
public extern Bool MapDrv(U8 drv_let,CDrv *dv);
#help_index "File/FileNames"
extern CDirEntry *Cd2DirEntry(CDirEntry *tempde,U8 *abs_name);
public extern U8 *ChgExt(U8 *filename,U8 *extension);
@@ -279,15 +288,16 @@ 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 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,U8 *files_find_mask,I64 fuf_flags=0);
public extern Bool FilesFindMatch(U8 *test_filename,
U8 *files_find_mask,I64 fuf_flags=0);
public extern Bool IsDir(U8 *dir_name);
public extern Bool IsDotC(U8 *filename);
public extern Bool IsDotZ(U8 *filename);
public extern Bool IsDrvWritable(U8 drv_let=0);
public extern U0 PutDirLink(U8 *dirname);
public extern U0 PutFileLink(U8 *filename,I64 line=0,Bool plain_text=FALSE);
public extern U0 ToFileLine(U8 *_fl_file_line,U8 **_filename,I64 *_linenum);
@@ -297,9 +307,11 @@ public extern U8 *ToggleZorNotZ(U8 *name);
public extern U8 *FileNameTempTxt();
#help_index "File/Internal"
public extern Bool DirNew(CDrv *dv,U8 *cur_dir,CDirEntry *tempde,Bool free_old_chain=TRUE);
public extern U0 FileAccessDel(CFileAccess *fa);
public extern CFileAccess *FileAccessNew(U8 *mask,Bool make_mask=FALSE,Bool make_dirs=FALSE,Bool no_mask=FALSE);
public extern U0 DirContextDel(CDirContext *dirc);
public extern CDirContext *DirContextNew(U8 *mask,
Bool make_mask=FALSE,Bool make_dirs=FALSE,Bool no_mask=FALSE);
public extern Bool DirNew(CDrv *dv,U8 *cur_dir,
CDirEntry *tempde,Bool free_old_chain=TRUE);
extern I64 FileAttr(U8 *name,I64 old_attr=0);
#help_index "File/Low Level"
@@ -310,7 +322,8 @@ public extern Bool BlkDevUnlock(CBlkDev *bd,Bool rst=FALSE);
public extern U0 BlkDevsRelease();
public extern I64 Cluster2Blk(CDrv *dv,I64 c);
public extern I64 ClusterNumNext(CDrv *dv,I64 c,I64 cnt=1);
public extern I64 ClustersAlloc(CDrv *dv,I64 c=0,I64 cnt=1,Bool contiguous=FALSE);
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);
@@ -330,8 +343,6 @@ public extern Bool RBlks(CDrv *dv,U8 *buf, I64 blk, I64 cnt);
public extern I64 RClusters(CDrv *dv,U8 *buf,I64 c,I64 cnt);
public extern I64 RClustersBlks(CDrv *dv,U8 *buf,I64 c,I64 blks);
extern U0 RedSeaFreeClusters(CDrv *dv,I64 c,I64 cnt);
extern I64 SysDel(U8 *wild,Bool make_mask); //this is dangerous
extern CDirEntry *SysFilesFind(U8 *files_find_mask,I64 fuf_flags);
public extern Bool WBlks(CDrv *dv,U8 *buf, I64 blk, I64 cnt);
public extern I64 WClusters(CDrv *dv,U8 *buf,I64 c,I64 cnt);
public extern I64 WClustersBlks(CDrv *dv,U8 *buf,I64 c,I64 blks);
@@ -344,14 +355,17 @@ public extern U0 DirTreeDel(CDirEntry *tempde);
public extern U0 DirTreeDel2(CDirEntry *tempde);
public extern Bool FileFind(U8 *filename,CDirEntry *_de=NULL,I64 fuf_flags=0);
public extern U8 *FileRead(U8 *filename,I64 *_size=NULL,I64 *_attr=NULL);
public extern I64 FileWrite(U8 *filename,U8 *fbuf,I64 size,CDate cdt=0,I64 attr=0);
public extern I64 FileWrite(U8 *filename,
U8 *fbuf,I64 size,CDate cdt=0,I64 attr=0);
#help_index "File/Program Routines;File/FileNames"
public extern CDirEntry *FilesFind(U8 *files_find_mask,I64 fuf_flags=0);
#help_index "File/System"
public extern CATARep *ATAIDDrvs(CATARep *root,I64 _sys_boot_drv,CATARep **_ata_drv,CATARep **_atapi_drv);
extern CBlkDev *ATAMount(U8 first_drv_let,I64 type,I64 base0,I64 base1,I64 unit);
public extern CATARep *ATAIDDrvs(CATARep *root,
I64 _sys_boot_drv,CATARep **_ata_drv,CATARep **_atapi_drv);
extern CBlkDev *ATAMount(U8 first_drv_let,
I64 type,I64 base0,I64 base1,I64 unit);
extern Bool ATAPIStartStop(CBlkDev *bd,F64 timeout,Bool start);
extern I64 ATAProbe(I64 base0,I64 base1,I64 unit);
extern U0 ATAReadBlks(CBlkDev *bd,U8 *buf, I64 blk, I64 cnt);
@@ -371,25 +385,16 @@ public extern CColorROPU32 Str2ColorU32(U8 *st);
#help_index "Hash"
#help_file "::/Doc/Hash"
public _extern _HASH_ADD U0 HashAdd(CHash *temph,CHashTable *table);
public _extern _HASH_ADD_AFTER U0 HashAddAfter(CHash *temph,CHash *pred,CHashTable *table); //Add hash entry after entry.
public _extern _HASH_ADD_AFTER U0 HashAddAfter(CHash *temph,
CHash *pred,CHashTable *table); //Add hash entry after entry.
public _extern _HASH_BUCKET_FIND CHash **HashBucketFind(
U8 *needle_str,CHashTable *haystack_table);
public extern U0 HashDel(CHashSrcSym *temph);
public _extern _HASH_FIND CHash *HashFind(U8 *needle_str,CHashTable *haystack_table,I64 mask,I64 instance=1);
public extern CHashGeneric *HashGenericAdd(U8 *name,I64 type,I64 val=0,I64 u8=0,I64 u16=0,CTask *task=NULL);
public extern CHashGeneric *HashPublic(U8 *st,I64 mask,Bool val=TRUE);
public _extern _HASH_REM_DEL Bool HashRemDel(CHash *temph,CHashTable *table,
I64 instance=1);//instance must match temph's
U8 *needle_str,CHashTable *haystack_table);
public _extern _HASH_FIND CHash *HashFind(U8 *needle_str,
CHashTable *haystack_table,I64 mask,I64 instance=1);
public _extern _HASH_SINGLE_TABLE_FIND CHash *HashSingleTableFind(
U8 *needle_str,CHashTable *haystack_table,I64 mask,I64 instance=1);
public _extern _HASH_STR I64 HashStr(U8 *st);
public extern U0 HashTableDel(CHashTable *table);
public extern CHashTable *HashTableNew(I64 size,CTask *mem_task=NULL);
public extern I64 HashTablePurge(CHashTable *table);
public extern I64 HashTypeNum(CHash *temph);
public extern I64 HashVal(CHash *temph);
extern U0 SysSymImportsResolve(U8 *sptr,I64 ld_flags=0);
#help_index "Hash/Frame"
#help_file "::/Doc/Frame"
@@ -398,19 +403,36 @@ public extern CHashGeneric *FramePtrAdd(U8 *name,I64 val=0,CTask *task=NULL);
public extern I64 FramePtrDel(U8 *name,CTask *task=NULL);
public extern I64 FramePtrSet(U8 *name,I64 val,CTask *task=NULL);
#help_index "Hash;Char/Lists"
#help_index "Hash/System"
public extern U0 HashDel(CHashSrcSym *temph);
public extern CHashGeneric *HashGenericAdd(U8 *name,
I64 type,I64 val=0,I64 u8=0,I64 u16=0,CTask *task=NULL);
public extern CHashGeneric *HashPublic(U8 *st,I64 mask,Bool val=TRUE);
public _extern _HASH_REM_DEL Bool HashRemDel(CHash *temph,CHashTable *table,
I64 instance=1);//instance must match temph's
public extern U0 HashTableDel(CHashTable *table);
public extern I64 HashTablePurge(CHashTable *table);
public extern I64 HashTypeNum(CHash *temph);
public extern I64 HashVal(CHash *temph);
extern U0 SysSymImportsResolve(U8 *sptr,I64 ld_flags=0);
#help_index "Hash/System;Char/Lists"
public extern I64 HashLstAdd(U8 *lst,I64 type,CHashTable *table);
#help_index "Hash;Define;Char/Define;Char/Lists"
#help_index "Hash/System;Define;Char/Define;Char/Lists"
public extern I64 HashDefineLstAdd(U8 *name,I64 type,CHashTable *table);
#help_index "Help System;Debugging/Debugger"
public extern U0 Help();
#help_index "Info;File/Cmd Line (Typically);Cmd Line (Typically);Install"
public extern U0 DrvRep();
#help_index "Input Pointer"
#help_file "::/Doc/InputPointer"
public extern U0 GridInit();
public extern U0 IPSet(I64 x=MAX_I64,I64 y=MAX_I64,I64 z=MAX_I64,I64 l=MAX_I64,I64 r=MAX_I64);
public extern U0 IPSet(I64 x=MAX_I64,I64 y=MAX_I64,I64 z=MAX_I64,
I64 l=MAX_I64,I64 r=MAX_I64);
public extern CIPStateGlbls ip;
public extern CGridGlbls ip_grid;
extern CIPStateGlbls ip_last;
@@ -429,7 +451,8 @@ extern CATARep *ATARepFind(CATARep *haystack_root,I64 needle_num);
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);
public extern U0 Fmt(U8 drv_let,Bool quick=TRUE,
Bool confirm=TRUE,I64 type=DVT_FAT32);
public extern U0 Mount(Bool repartition=FALSE);
#help_index "Install;Memory/BlkPool"
@@ -437,19 +460,23 @@ public extern I64 Scale2Mem(I64 min,I64 max,I64 limit=2*1024*1024*1024);
#help_index "Keyboard Devices/System;Char/System"
#help_file "::/Doc/KeyDev"
public extern U0 CtrlAltLetCBSet(U8 ch,U0 (*fp_handler)(I64 sc),U8 *desc,Bool in_irq=FALSE);
public extern U0 CtrlAltLetCBSet(U8 ch,U0 (*fp_handler)(I64 sc),U8 *desc,
Bool in_irq=FALSE);
public extern U0 KeyDescSet(U8 *fmt,...);
public extern CKeyDevEntry *KeyDevAdd(Bool (*fp_put_key)(I64 ch,I64 sc),Bool (*fp_puts)(U8 *st),I64 priority,Bool key_descs=FALSE);
public extern CKeyDevEntry *KeyDevAdd(Bool (*fp_put_key)(I64 ch,I64 sc),
Bool (*fp_puts)(U8 *st),I64 priority,Bool key_descs=FALSE);
public extern U0 KeyDevRem(CKeyDevEntry *tempp);
extern CKeyDevGlbls keydev;
extern CSrvCmd sys_macro_root;
extern CTask *sys_macro_util_task;
#help_index "Keyboard Devices;Char/Input"
#help_index "Keyboard Devices;Char/Input;StdIn"
extern U8 *(*fp_getstr2)(I64 flags=0); //GetStr $LK,"Flags",A="MN:GSF_SHIFT_ESC_EXIT"$
public extern Bool AreYouSure();
public extern I64 GetChar(I64 *_scan_code=NULL,Bool echo=TRUE,Bool raw_cursor=FALSE);
public extern I64 GetKey(I64 *_scan_code=NULL,Bool echo=FALSE,Bool raw_cursor=FALSE);
public extern I64 GetChar(I64 *_scan_code=NULL,Bool echo=TRUE,
Bool raw_cursor=FALSE);
public extern I64 GetKey(I64 *_scan_code=NULL,Bool echo=FALSE,
Bool raw_cursor=FALSE);
public extern I64 GetS(U8 *buf,I64 size,Bool allow_ext=TRUE);
public extern U8 *GetStr(U8 *msg=NULL,U8 *dft=NULL,I64 flags=0);
extern U0 KbdInit();
@@ -461,9 +488,9 @@ public extern U0 KbdTypeMatic(U8 delay);
extern Bool MouseDriverInstall();
public extern I64 PressAKey();
public extern I64 ScanChar();
public extern Bool ScanKey(I64 *_ch=NULL,I64 *_scan_code=NULL,Bool echo=FALSE);
public extern Bool YorN();
public extern CKbdStateGlbls kbd;
public extern Bool ScanKey(I64 *_ch=NULL,I64 *_scan_code=NULL,Bool echo=FALSE);
#help_index "Math"
public extern I64 CeilI64(I64 num,I64 to);
@@ -501,10 +528,12 @@ public extern U0 Mem512Free(CMemBlk *m,I64 pages512,CBlkPool *bp=NULL);
#help_index "Memory/Heap"
public extern U8 *CAlloc(I64 size,CTask *mem_task=NULL);
public extern U8 *CAllocAligned(I64 size,I64 alignment,CTask *mem_task=NULL,I64 misalignment=0);
public extern U8 *CAllocAligned(I64 size,I64 alignment,
CTask *mem_task=NULL,I64 misalignment=0);
public _extern _FREE U0 Free(U8 *addr);
public _extern _MALLOC U8 *MAlloc(I64 size,CTask *mem_task=NULL);
public extern U8 *MAllocAligned(I64 size,I64 alignment,CTask *mem_task=NULL,I64 misalignment=0);
public extern U8 *MAllocAligned(I64 size,I64 alignment,
CTask *mem_task=NULL,I64 misalignment=0);
public extern U8 *MAllocIdentical(U8 *src,CTask *mem_task=NULL);
public _extern _MHEAP_CTRL CHeapCtrl *MHeapCtrl(U8 *src);
public _extern _MSIZE I64 MSize(U8 *src); //size of heap object
@@ -513,7 +542,8 @@ public _extern _MSIZE2 I64 MSize2(U8 *src); //Internal size
#help_index "Memory/HeapCtrl"
public extern CHeapCtrl *HeapCtrlBPInit(CBlkPool *bp,I64 pages512);
public extern U0 HeapCtrlDel(CHeapCtrl *hc);
public extern CHeapCtrl *HeapCtrlInit(CHeapCtrl *hc=NULL,CTask *task=NULL,CBlkPool *bp);
public extern CHeapCtrl *HeapCtrlInit(CHeapCtrl *hc=NULL,
CTask *task=NULL,CBlkPool *bp);
#help_index "Memory/Page Tables"
public extern Bool MemLowPagesProtect(Bool val=TRUE);
@@ -524,16 +554,20 @@ public extern I64 *MemPageTable(U8 *a);
#help_index "Messages"
#help_file "::/Doc/Msgs"
public extern I64 FlushMsgs(CTask *task=NULL);
public extern I64 GetMsg(I64 *_a1=NULL,I64 *_a2=NULL,I64 mask=~1,CTask *task=NULL);
public extern I64 GetMsg(I64 *_a1=NULL,I64 *_a2=NULL,
I64 mask=~1,CTask *task=NULL);
extern U0 InputFilterTask();
public extern I64 ScanMsg(I64 *_a1=NULL,I64 *_a2=NULL,I64 mask=~1,CTask *task=NULL);
public extern I64 ScanMsg(I64 *_a1=NULL,I64 *_a2=NULL,
I64 mask=~1,CTask *task=NULL);
#help_index "Misc"
public extern I64 EndianI64(I64 d);
public extern U16 EndianU16(U16 d);
public extern U32 EndianU32(U32 d);
public extern U0 QSort(U8 *base,I64 num, I64 width,I64 (*fp_compare)(U8 *e1,U8 *e2));
public extern U0 QSortI64(I64 *base,I64 num, I64 (*fp_compare)(I64 e1,I64 e2));
public extern U0 QSort(U8 *base,I64 num, I64 width,
I64 (*fp_compare)(U8 *e1,U8 *e2));
public extern U0 QSortI64(I64 *base,I64 num,
I64 (*fp_compare)(I64 e1,I64 e2));
#help_index "Misc/Progress Bars"
public extern U0 ProgressBarsRst();
@@ -566,15 +600,19 @@ public extern U8 PCIReadU8(I64 bus,I64 dev,I64 fun,I64 rg);
public extern U0 PCIWriteU16(I64 bus,I64 dev,I64 fun,I64 rg,I64 val);
public extern U0 PCIWriteU32(I64 bus,I64 dev,I64 fun,I64 rg,I64 val);
public extern U0 PCIWriteU8(I64 bus,I64 dev,I64 fun,I64 rg,I64 val);
public _extern SYS_BIOS32_SERVICE_DIR U32 sys_BIOS32_service_dir;//Far call routine in the BIOS
public _extern SYS_PCI_SERVICES U32 sys_pci_services;//Far call routine in the BIOS
public _extern SYS_PCIBIOS_SERVICE_DIR
U32 sys_PCIBIOS_service_dir;//Far call routine in the BIOS
public _extern SYS_PCI_SERVICES
U32 sys_pci_services;//Far call routine in the BIOS
#help_index "PCI;Info;File/System;Devices"
public extern I64 ATARep(Bool pmt=TRUE,Bool just_ide=FALSE,CATARep **_root=NULL);
public extern I64 ATARep(Bool pmt=TRUE,
Bool just_ide=FALSE,CATARep **_root=NULL);
#help_index "Processor"
public extern U8 *IntEntryGet(I64 irq);
public extern U8 *IntEntrySet(I64 irq,U0 (*fp_new_handler)(),I64 type=IDTET_IRQ,I64 dpl=0);
public extern U8 *IntEntrySet(I64 irq,
U0 (*fp_new_handler)(),I64 type=IDTET_IRQ,I64 dpl=0);
#help_index "Snd"
public extern U0 Beep(I64 freq=500,Bool busy=FALSE);
@@ -583,6 +621,12 @@ public extern Bool Mute(Bool val);
public extern U0 Snd(F64 freq);
public extern CSndGlbls snd;
#help_index "StdIn"
#help_file "::/Doc/Streams"
#help_index "StdOut"
#help_file "::/Doc/Streams"
#help_index "Task"
public extern U0 Exit();
public extern Bool IsPreempt();
@@ -637,17 +681,17 @@ public extern CSrvCmd *TaskExe(CTask *srv,CTask *master,U8 *data,I64 flags);
public extern U0 TaskRstAwaitingMsg(CTask *task=NULL);
#help_index "Task/Srv/Exe;Compiler"
public extern I64 ExeCmdLine(CLex *lx);
public extern I64 ExeCmdLine(CCmpCtrl *cc);
public extern U0 UserTaskCont();
#help_index "Task/Srv/Exe;MultiCore"
public extern I64 GetResult(CSrvCmd *rqst=NULL);
public extern Bool ScanResult(CSrvCmd *rqst=NULL,I64 *_result=NULL);
public extern I64 JobResultGet(CSrvCmd *rqst=NULL);
public extern Bool JobResultScan(CSrvCmd *rqst=NULL,I64 *_result=NULL);
#help_index "Task/Srv/Text & Msgs"
public extern CSrvCmd *TaskText(CTask *srv,CTask *master,U8 *data,I64 flags);
#help_index "Task/Srv/Text & Msgs;AutoFile"
#help_index "Task/Srv/Text & Msgs;AutoFile;StdIn/AutoFile"
public extern U0 Auto(U8 *fmt,...);
public extern U0 AutoFile(U8 *filename);
public extern U0 AutoStr(U8 *fmt,...);
@@ -659,7 +703,8 @@ public extern U0 XTalkWait(CTask *task,U8 *fmt,...);
#help_index "Task/Srv/Text & Msgs;Messages"
public extern U0 Msg(I64 msg_code,I64 a1,I64 a2,I64 flags=0);
public extern U0 PostMsg(CTask *task,I64 msg_code,I64 a1,I64 a2,I64 flags=0);
public extern U0 SendMsg(CTask *task,I64 msg_code,I64 a1,I64 a2,I64 flags=0);
public extern U0 PostMsgWait(CTask *task,I64 msg_code,
I64 a1,I64 a2,I64 flags=0);
public extern CSrvCmd *TaskMsg(CTask *srv,CTask *master,
I64 msg_code,I64 a1,I64 a2,I64 flags);
@@ -705,7 +750,4 @@ public extern I64 SysTimerRead();//18.33333*65536Hz (SYS_TIMER_FREQ)
public extern Bool Blink(F64 Hz=2.5);
public extern F64 tS(); //From SysTimerFreq.
#help_index "Training;Debugging/Debugger"
public extern U0 Help();
#help_index ""
Kernel/KeyDev.CPP
+73 -7
View File
@@ -18,7 +18,8 @@ U0 PutKey(I64 ch=0,I64 sc=0)
}
U0 PutChars(U64 ch)
{//Output chars. Can pack multiple chars into a single U64.
{//Output chars. Up to 8 chars in a single U64.
//Don't use this. $LK,"See Print() shortcut.",A="FF:::/Doc/HolyC.TXT.Z,DemoHolyC"$
while (ch) {
PutKey(ch&255,0);
ch>>=8;
@@ -26,7 +27,8 @@ U0 PutChars(U64 ch)
}
U0 PutS(U8 *st)
{//Use $LK,"Print",A="MN:Print"$(). See $LK,"Keyboard Devices",A="HI:Keyboard Devices/System"$.
{//Use $LK,"Print",A="MN:Print"$(). See $LK,"Keyboard Devices",A="HI:Keyboard Devices/System"$.
//Don't use this. $LK,"See Print() shortcut.",A="FF:::/Doc/HolyC.TXT.Z,DemoHolyC"$
I64 ch;
U8 *ptr;
Bool cont=TRUE;
@@ -62,9 +64,10 @@ U0 KeyDescSet(U8 *fmt,...)
Yield; //Makes KeyMap work better.
}
CKeyDevEntry *KeyDevAdd(Bool (*fp_put_key)(I64 ch,I64 sc),Bool (*fp_puts)(U8 *st),I64 priority,Bool key_descs=FALSE)
CKeyDevEntry *KeyDevAdd(Bool (*fp_put_key)(I64 ch,I64 sc),
Bool (*fp_puts)(U8 *st),I64 priority,Bool key_descs=FALSE)
{//Places hook in StdOut chain. See $LK,"Keyboard Devices",A="HI:Keyboard Devices/System"$.
Bool old_preempt=Preempt(OFF);
Bool old_preempt=Preempt;
CKeyDevEntry *tempp,*tempp1=keydev.put_key_root.last;
tempp=ACAlloc(sizeof(CKeyDevEntry));
tempp->put_key=fp_put_key;
@@ -81,7 +84,7 @@ CKeyDevEntry *KeyDevAdd(Bool (*fp_put_key)(I64 ch,I64 sc),Bool (*fp_puts)(U8 *st
U0 KeyDevRem(CKeyDevEntry *tempp)
{//Remove StdOut hook and free.
Bool old_preempt=Preempt(OFF);
Bool old_preempt=Preempt;
QueRem(tempp);
Preempt(old_preempt);
Free(tempp);
@@ -111,7 +114,7 @@ Bool KDInputFilterPutKey(I64 ch,I64 scan_code)
{
Bool old_preempt;
if (Bt(&Fs->task_flags,TASKf_INPUT_FILTER_TASK)) {
old_preempt=Preempt(OFF);
old_preempt=Preempt;
Msg(MSG_KEY_DOWN,ch,scan_code);
Preempt(old_preempt);
return TRUE;
@@ -124,7 +127,7 @@ Bool KDInputFilterPutS(U8 *st)
I64 ch;
Bool old_preempt;
if (Bt(&Fs->task_flags,TASKf_INPUT_FILTER_TASK)) {
old_preempt=Preempt(OFF);
old_preempt=Preempt;
while (ch=*st++)
Msg(MSG_KEY_DOWN,ch,0);
Preempt(old_preempt);
@@ -133,6 +136,62 @@ Bool KDInputFilterPutS(U8 *st)
return FALSE;
}
U0 CtrlAltDel(I64)
{
LBts(sys_ctrl_alt_flags,SYSf_CTRL_ALT_DEL);
}
U0 CtrlAltC(I64)
{
LBts(sys_ctrl_alt_flags,SYSf_CTRL_ALT_C);
}
U0 CtrlAltD(I64)
{
if (!IsDbg) {
if (Fs==Gs->idle_task)
BptS(sys_winmgr_task->rip,sys_winmgr_task);
else
BptS(*keydev.ctrl_alt_let_ret_addr);
}
}
U0 CtrlAltE(I64)
{
User;
}
U0 CtrlAltF(I64)
{
VGAFlush;
}
U0 CtrlAltM(I64)
{
Mute(!IsMute);
}
U0 CtrlAltT(I64)
{
LBts(sys_ctrl_alt_flags,SYSf_CTRL_ALT_TAB);
}
U0 CtrlAltX(I64)
{
LBts(sys_ctrl_alt_flags,SYSf_CTRL_ALT_X);
}
U0 CtrlAltLetCBSet(U8 ch,U0 (*fp_handler)(I64 sc),U8 *desc,Bool in_irq=FALSE)
{//Set callback for <CTRL-ALT-letter>.
ch=ToUpper(ch)-'A';
if (ch<26) {
keydev.fp_ctrl_alt_let_cbs[ch]=fp_handler;
Free(keydev.ctrl_alt_let_descs[ch]);
keydev.ctrl_alt_let_descs[ch]=AStrNew(desc);
BEqu(&keydev.ctrl_alt_let_in_irq_flags,ch,in_irq);
}
}
U0 KeyDevInit()
{
keydev.fp_ctrl_alt_let_cbs =CAlloc(26*sizeof(U8 *));
@@ -142,4 +201,11 @@ U0 KeyDevInit()
QueInit(&keydev.put_key_root);
KeyDevAdd(&KDInputFilterPutKey,&KDInputFilterPutS,0x40000000,FALSE);
KeyDevAdd(&KDRawPutKey,&KDRawPutS,0x60000000,FALSE);
CtrlAltLetCBSet('C',&CtrlAltC,"Sys/Break Execution",TRUE);
CtrlAltLetCBSet('D',&CtrlAltD,"Sys/Enter Debugger",TRUE);
CtrlAltLetCBSet('E',&CtrlAltE,"Sys/Spawn New User Task");
CtrlAltLetCBSet('F',&CtrlAltF,"Sys/VGA Flush",TRUE);
CtrlAltLetCBSet('M',&CtrlAltM,"Sys/Toggle Mute");
CtrlAltLetCBSet('T',&CtrlAltT,"Sys/Switch Focus to Next Task",TRUE);
CtrlAltLetCBSet('X',&CtrlAltX,"Sys/Kill Focused Task",TRUE);
}
Kernel/MemA.CPP
+12 -11
View File
@@ -125,7 +125,8 @@ pain without MAlloc up-and-running.
#define CONSERVATIVE_16MEG_SIZE 0xF00000
#define ESTIMATED_MISC_ALLOCS 0x100000
#assert CONSERVATIVE_16MEG_SIZE-(SYS_FIXED_AREA+sizeof(CSysFixedArea))>ADAM_STK+ESTIMATED_MISC_ALLOCS
#assert CONSERVATIVE_16MEG_SIZE-
(SYS_FIXED_AREA+sizeof(CSysFixedArea))>ADAM_STK+ESTIMATED_MISC_ALLOCS
//EBX=BASE EAX=SIZE
TEST U8 [SYS_MEM_INIT_FLAG],1
@@ -162,7 +163,7 @@ U0 SysBadMAlloc(I64 *ptr)
}
I64 MemPageSize(U8 *a)
{//Size of page table at addr. Either 4K or 2Meg.
{//Size of page table at addr.Either 4K or 2Meg.
if (a<MEM_NUM_PML1*0x1000*0x200)
return 0x1000;
else
@@ -212,10 +213,10 @@ Return: NULL if out of memory.
i=Bsr(FREE_PAGE_HASH_SIZE)+1;
} else {
//We'll now round-up to a power of two.
//There is some overhead on allocations and
//we wouldn't want to round to the next
//power of two if a power of two was requested.
//So we use a little more than a power of two.
//There is some overhead on allocations and
//we wouldn't want to round to the next
//power of two if a power of two was requested.
//So we use a little more than a power of two.
num-=2;
i=Bsr(num)+1;
num=1<<i+2;
@@ -227,7 +228,7 @@ Return: NULL if out of memory.
m=&bp->mem_free_lst;
while (TRUE) {
if (!(result=m->next)) {
//We're probably out of luck, but lets search for a
//We're probably out of luck, but lets search for a
//freed larger size block... and, screw-it, return the whole thing.
do {
if (result=bp->free_page_hash2[++i]) {
@@ -279,10 +280,10 @@ U0 Mem512Free(CMemBlk *m,I64 pages512,CBlkPool *bp=NULL)
bp->free_page_hash[pages512]=m;
} else {
//We'll now round-up to a power of two.
//There is some overhead on allocations and
//we wouldn't want to round to the next
//power of two if a power of two was requested.
//So we use a little more than a power of two.
//There is some overhead on allocations and
//we wouldn't want to round to the next
//power of two if a power of two was requested.
//So we use a little more than a power of two.
pages512-=2;
i=Bsr(pages512);
m->next=bp->free_page_hash2[i];
Kernel/MemB.CPP
+7 -6
View File
@@ -1,5 +1,4 @@
asm {
USE64
//************************************
_MALLOC::
// Throws 'OutMem'
@@ -15,7 +14,7 @@ _MALLOC::
MOV RDX,U64 FS:CTask.addr[RBX]
@@05: CMP U32 CTask.task_signature[RDX],TASK_SIGNATURE_VAL
#assert CTask.task_signature==CHeapCtrl.hc_signature //location of signature matches
#assert CTask.task_signature==CHeapCtrl.hc_signature //location signature same
JNE @@10
MOV RDX,U64 CTask.data_heap[RDX]
@@ -406,21 +405,23 @@ U8 *AMAllocIdentical(U8 *src)
return MAllocIdentical(src,adam_task);
}
U8 *MAllocAligned(I64 size,I64 alignment,CTask *mem_task=NULL,I64 misalignment=0)
U8 *MAllocAligned(I64 size,I64 alignment,
CTask *mem_task=NULL,I64 misalignment=0)
{//Only powers of two alignment. This is awful.
I64 mask=alignment-1;
U8 *ptr=MAlloc(size+mask+sizeof(I64)+misalignment,mem_task),
*result=(ptr+sizeof(I64)+mask)&~mask+misalignment;
*result=(ptr+sizeof(I64)+mask)&~mask+misalignment;
result(I64 *)[-1]=ptr-result;
#assert offset(CMemUsed.size)==offset(CMemUsed.start)-sizeof(I64)
return result;
}
U8 *CAllocAligned(I64 size,I64 alignment,CTask *mem_task=NULL,I64 misalignment=0)
U8 *CAllocAligned(I64 size,I64 alignment,
CTask *mem_task=NULL,I64 misalignment=0)
{//Only powers of two alignment. This is awful.
I64 mask=alignment-1;
U8 *ptr=MAlloc(size+mask+sizeof(I64)+misalignment,mem_task),
*result=(ptr+sizeof(I64)+mask)&~mask+misalignment;
*result=(ptr+sizeof(I64)+mask)&~mask+misalignment;
result(I64 *)[-1]=ptr-result;
#assert offset(CMemUsed.size)==offset(CMemUsed.start)-sizeof(I64)
MemSet(result,0,size);
Kernel/MemC.CPP
+5 -5
View File
@@ -77,7 +77,7 @@ Bool Mem32DevIns(CMemRange *tempmr)
CMemRange *tempmr1=dev.mem32_root.next,*tempmr2;
while (tempmr1!=&dev.mem32_root) {
if (!tempmr1->type && tempmr->base>=tempmr1->base &&
tempmr->base+tempmr->size<=tempmr1->base+tempmr1->size) {
tempmr->base+tempmr->size<=tempmr1->base+tempmr1->size) {
if (tempmr->base>tempmr1->base) {
tempmr2=AMAlloc(sizeof(CMemRange));
tempmr2->type=MRT_UNUSED;
@@ -88,7 +88,7 @@ Bool Mem32DevIns(CMemRange *tempmr)
}
QueInsRev(tempmr,tempmr1);
tempmr1->size=tempmr1->base+tempmr1->size-
(tempmr->base+tempmr->size);
(tempmr->base+tempmr->size);
tempmr1->base=tempmr->base+tempmr->size;
if (!tempmr1->size) {
QueRem(tempmr1);
@@ -165,7 +165,7 @@ U0 MemPagesNotPresentMark()
U8 *Mem32DevAlloc(I64 size,I64 alignment)
{//Alloc 32-bit addr space for device. (Doesn't work.) Not used.
//For this to work the BIOS E820 map must be searched for gaps in
//the 32-bit range and the pool initialized to the gaps.
//the 32-bit range and the pool initialized to the gaps.
U8 *base,*limit;
CMemRange *tempmr,*tempmr1;
while (LBts(&sys_semas[SYS_SEMA_DEV_MEM],0))
@@ -175,7 +175,7 @@ U8 *Mem32DevAlloc(I64 size,I64 alignment)
base=(tempmr1->base+alignment-1)&~(alignment-1);
limit=base+size-1;
if (!tempmr1->type &&
limit<tempmr1->base+tempmr1->size) {
limit<tempmr1->base+tempmr1->size) {
tempmr=AMAlloc(sizeof(CMemRange));
tempmr->type=MRT_DEV;
tempmr->flags=0;
@@ -236,7 +236,7 @@ U0 Mem64DevFree(U8 *base,I64 pages2Meg)
Yield;
if (base==dev.mem64_ptr)
dev.mem64_ptr+=pages2Meg*0x200000;
//else not freed
//else not freed
LBtr(&sys_semas[SYS_SEMA_DEV_MEM],0);
}
Kernel/MultiProc.CPP
+25 -26
View File
@@ -51,7 +51,7 @@ AP_32BIT_INIT:
ADD ESI,U32 [SYS_CPU_STRUCTS]
LEA ESP,U32 CCPU.start_stk+sizeof(CCPU.start_stk)[ESI]
PUSH U32 SYS_START_RFLAGS
PUSH U32 RFLAGG_START
POPFD
PUSH U32 0 //Return from next call will be 64-bit
CALL SYS_EM64T
@@ -179,7 +179,7 @@ U0 MPWake(I64 target_cpu)
MPInt(I_WAKE,target_cpu);
if (!target_cpu)
LBtr(&adam_task->task_flags,TASKf_AWAITING_MSG);
if (Bt(&cpu_structs[target_cpu].cpu_flags,CPUf_SETH_SLEEP)) //In case went back to sleep
if (Bt(&cpu_structs[target_cpu].cpu_flags,CPUf_SETH_SLEEP))//back to sleep?
cpu_structs[target_cpu].seth_task->wake_jiffy=0;
POPFD
}
@@ -188,21 +188,21 @@ U0 MPWake(I64 target_cpu)
U0 MPAPICInit()
{//Called by adam during start-up
//and other cores during initialization
//after $LK,"BSPStartMP",A="MN:BSPStartMP"$().
//after $LK,"BSPStartMP",A="MN:BSPStartMP"$().
*LAPIC_SVR(U32 *)|=LAPICF_APIC_ENABLED;
dev.mp_apic_ids[Gs->num]=*LAPIC_APIC_ID(U32 *)>>24;
*LAPIC_LDR(U32 *)=dev.mp_apic_ids[Gs->num]<<24;
*LAPIC_DFR(U32 *)=0xF0000000;
// MemSet(LAPIC_IRR,0,0x20);
// MemSet(LAPIC_ISR,0,0x20);
// MemSet(LAPIC_TMR,0,0x20);
// MemSet(LAPIC_IRR,0,0x20);
// MemSet(LAPIC_ISR,0,0x20);
// MemSet(LAPIC_TMR,0,0x20);
SetRAX(Gs->tss->tr);
LTR AX
if (Gs->num) {
IntInit1;
SetRFlags(SYS_NORMAL_RFLAGS);
SetRFlags(RFLAGG_NORMAL);
}
}
@@ -234,7 +234,7 @@ CSrvCmd *JobQue(I64 (*fp_addr)(U8 *data),U8 *data=NULL,
I64 cmd_code=SVCT_CALL,U8 *aux_str=NULL,I64 aux1=0,I64 aux2=0)
{//Queue multicore jobs, handled by Seth tasks.
//Set flags to zero if you wish to get the result.
//See $LK,"::/Demo/MultiCore/Lock.CPP"$
//See $LK,"::/Demo/MultiCore/Lock.CPP"$
CSrvCtrl *ctrl;
CSrvCmd *tempc;
if (!(0<=target_cpu<mp_cnt))
@@ -261,14 +261,13 @@ CSrvCmd *JobQue(I64 (*fp_addr)(U8 *data),U8 *data=NULL,
return tempc;
}
CTask *SpawnQue(U0 (*fp_addr)(U8 *data),U8 *data=NULL,
U8 *task_name=NULL,
I64 target_cpu,
CTask *parent=NULL, //NULL means adam
I64 stk_size=0,I64 flags=1<<SVCf_ADD_TO_QUE)
CTask *SpawnQue(U0 (*fp_addr)(U8 *data),U8 *data=NULL,U8 *task_name=NULL,
I64 target_cpu, CTask *parent=NULL, //NULL means adam
I64 stk_size=0,I64 flags=1<<SVCf_ADD_TO_QUE)
{
CTask *result;
CSrvCmd *tempc=JobQue(fp_addr,data,target_cpu,flags,SVCT_SPAWN_TASK,task_name,parent,stk_size);
CSrvCmd *tempc=JobQue(fp_addr,data,target_cpu,
flags,SVCT_SPAWN_TASK,task_name,parent,stk_size);
CSrvCtrl *ctrl;
while (!Bt(&tempc->flags,SVCf_DONE)) {
@@ -302,7 +301,7 @@ U0 APSethInit()
U0 BSPStartMP()
{//Called by adam during $LK,"start-up",A="FF:::/Kernel/KEnd.CPP,BSPStartMP"$.
CTask *task;
U8 buf[128];
U8 buf[STR_LEN];
CAP16BitInit *mp=MP_VECT_ADDR;
CCPU *c;
I64 i,my_mp_cnt;
@@ -325,9 +324,9 @@ U0 BSPStartMP()
}
MemSet(&cpu_structs[1],0,sizeof(CCPU)*(MP_MAX_PROCESSORS-1));
//When you start-up other cores, they jump to an addr
//specified by a byte vect number, $LK,"MPN_VECT",A="MN:MPN_VECT"$ which corresponds
//to a location 4096*vect number, $LK,"MP_VECT_ADDR",A="MN:MP_VECT_ADDR"$$WW,0$.
//When you start-up other cores, they jump to an addr
//specified by a byte vect number, $LK,"MPN_VECT",A="MN:MPN_VECT"$ which corresponds
//to a location 4096*vect number, $LK,"MP_VECT_ADDR",A="MN:MP_VECT_ADDR"$$WW,0$.
MemCpy(mp,AP_16BIT_INIT,AP_16BIT_INIT_END-AP_16BIT_INIT);
MemCpy(&mp->ap_gdt_ptr,SYS_GDT_PTR,sizeof(CSysLimitBase));
mp_cnt_initial=mp_cnt=1;
@@ -354,9 +353,8 @@ U0 BSPStartMP()
for (i=1;i<my_mp_cnt;i++) {
StrPrint(buf,"Seth Task CPU#%d",i);
task=Spawn(&APSethInit,NULL,buf,,,SETH_STK,0);
task->rflags=SYS_START_RFLAGS;
//$LK,"CTask",A="MN:CTask"$ alloced off this core's seth_task's heap (Which is Adam)
task->task_in_que_signature=TASK_IN_QUE_SIGNATURE_VAL;
task->rflags=RFLAGG_START;
//$LK,"CTask",A="MN:CTask"$ alloced off this core's seth_task's heap (Which is Adam)
CPUStructInit(i,&cpu_structs[i],task);
WBINVD //Not sure why this is needed. Might just need delay.
}
@@ -382,17 +380,18 @@ U0 BSPInit()
dbg.mp_crash=ACAlloc(sizeof(CMPCrash));
//Must be in code heap because init code uses 32 bit addr of cpu_struct
adam_task->gs=cpu_structs=CAlloc(sizeof(CCPU)*MP_MAX_PROCESSORS,Fs->code_heap);
//Must be in code heap because init code uses 32 bit addr of cpu_struct
adam_task->gs=cpu_structs=
CAlloc(sizeof(CCPU)*MP_MAX_PROCESSORS,Fs->code_heap);
adam_task->time_slice_start=GetTSC;
CPUStructInit(0,cpu_structs,adam_task);
asm {//RAX has GS
IMPORT SET_GS_BASE;
CALL SET_GS_BASE
IMPORT SET_GS_BASE;
CALL SET_GS_BASE
}
if (Bt(&ee.rdx,9)) {
//Unnecessary?
// SetMSR(IA32_LAPIC_BASE,LAPIC_BASE+0x900);
// SetMSR(IA32_LAPIC_BASE,LAPIC_BASE+0x900);
MPAPICInit;
}
}
Kernel/BIOS32.CPP → Kernel/PCIBIOS.CPP
+13 -13
View File
@@ -1,10 +1,10 @@
asm {
USE32
SYS_BIOS32_SERVICE_DIR:: DU32 0;
SYS_PCIBIOS_SERVICE_DIR:: DU32 0;
SYS_PCI_SERVICES:: DU32 0;
SYS_FIND_BIOS32_SERVICE_DIR::
SYS_FIND_PCIBIOS_SERVICE_DIR::
MOV ESI,0xE0000
MOV ECX,(0x100000-0xE0000)/4
@@05: CMP U32 [ESI],'_32_'
@@ -24,26 +24,26 @@ SYS_FIND_BIOS32_SERVICE_DIR::
POP ECX
TEST AL,AL
JNZ @@20
MOV U32 [SYS_BIOS32_SERVICE_DIR],ESI
MOV U32 [SYS_PCIBIOS_SERVICE_DIR],ESI
MOV ESI,U32 4[ESI]
MOV U32 [SYS_BIOS32_SERVICE_CALL],ESI
MOV U32 [SYS_PCIBIOS_SERVICE_CALL],ESI
RET
@@20: ADD ESI,4
LOOP @@05
MOV U32 [SYS_BIOS32_SERVICE_DIR],0
MOV U32 [SYS_PCIBIOS_SERVICE_DIR],0
RET
SYS_FIND_PCI_SERVICES::
MOV ESI,U32 [SYS_BIOS32_SERVICE_DIR]
MOV ESI,U32 [SYS_PCIBIOS_SERVICE_DIR]
TEST ESI,ESI
JNZ @@05
MOV U32 [SYS_PCI_SERVICES],0
RET
@@05: MOV EAX,'$$PCI'
XOR EBX,EBX
DU8 0x9A; //CALL CGDT.cs32:BIOS32_SERVICE
SYS_BIOS32_SERVICE_CALL:: DU32 0;
DU8 0x9A; //CALL CGDT.cs32:PCIBIOS_SERVICE
SYS_PCIBIOS_SERVICE_CALL:: DU32 0;
DU16 CGDT.cs32;
TEST AL,AL
JNZ @@05
@@ -158,7 +158,7 @@ _extern C32_EDI U32 c32_edi;
_extern C32_EFLAGS U32 c32_eflags;
_extern SYS_PCI_SERVICES U32 sys_pci_services;
_extern _FAR_CALL32 Bool FarCall32(U0 (*fp_addr)()); //Not reentrant used to call BIOS32. Takes 250uS.
_extern _FAR_CALL32 Bool FarCall32(U0 (*fp_addr)());//Not reentrant.For PCIBIOS.
U8 PCIReadU8(I64 bus,I64 dev,I64 fun,I64 rg)
{//Read U8 in PCI configspace at bus,dev,fun,reg.
@@ -209,9 +209,9 @@ U32 PCIReadU32(I64 bus,I64 dev,I64 fun,I64 rg)
c32_ebx=bus<<8+dev<<3+fun;
c32_edi=rg;
if (FarCall32(sys_pci_services))
result=c32_ecx;
else
result=0xFFFFFFFF;
result=c32_ecx;
else
result=0xFFFFFFFF;
LBtr(&sys_semas[SYS_SEMA_FAR_CALL32],0);
POPFD
return result;
@@ -268,7 +268,7 @@ I64 PCIClassFind(I64 class_code,I64 n)
class_code is low three bytes
n is index starting at zero
Return: -1 not found
else bus,dev,fun.
else bus,dev,fun.
*/
I64 result;
PUSHFD
Kernel/PSect.CPP
+21 -21
View File
@@ -3,7 +3,7 @@ I64 HasLower(U8 *src)
I64 ch;
while (ch=*src++)
if ('a'<=ch<='z')
return TRUE;
return TRUE;
return FALSE;
}
@@ -64,22 +64,22 @@ U0 PSectCacheAdd(CHash *temps,U8 *addr)
Bool old_preempt;
CPSectCache *temppc;
if (temps && temps->type&HTT_FUN &&
(dbg_info=temps(CHashFun *)->dbg_info)) {
old_preempt=Preempt(OFF);
(dbg_info=temps(CHashFun *)->dbg_info)) {
old_preempt=Preempt;
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;
Preempt(old_preempt);
}
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;
Preempt(old_preempt);
}
}
U8 *PSectCacheFind(U8 *addr,I64 *_offset)
@@ -94,7 +94,7 @@ U8 *PSectCacheFind(U8 *addr,I64 *_offset)
timeout=tS+8.0;
for (i=0;i<PSECT_CACHE_SIZE;i++,temppc++)
if (temppc->base<=addr<temppc->limit &&
temppc->time_stamp>timeout) {
temppc->time_stamp>timeout) {
*_offset=addr-temppc->base;
return temppc->str;
}
@@ -156,7 +156,7 @@ I64 SrcLineNum(U8 *addr,I64 cnt=1)
if (dbg_info=temph->dbg_info) {
num_lines=dbg_info->max_line-dbg_info->min_line+1;
body=dbg_info->body;
//find first nonzero
first_line=0;
while (!body[first_line]) {
@@ -170,15 +170,15 @@ I64 SrcLineNum(U8 *addr,I64 cnt=1)
while (!body[last_line] && last_line>first_line)
last_line--;
//interpolate to guess line num
//interpolate to guess line num
cur_line=ClampI64(ToF64(addr-body[first_line])*(last_line-first_line+1)/
(body[last_line]-body[first_line]+1),first_line,last_line);
(body[last_line]-body[first_line]+1),first_line,last_line);
//retreat while too high
while ((!body[cur_line] || body[cur_line]>=addr) && cur_line>first_line)
cur_line--;
//advance while to low
//advance while to low
while ((!body[cur_line] || body[cur_line]<addr) && cur_line<last_line)
cur_line++;
Kernel/QSort.CPP
+66 -193
View File
@@ -7,224 +7,97 @@ For assending ints : return e1-e2;
Maybe, look at $LK,"::/Demo/MultiCore/RadixSort.CPP"$.
*/
I64 i,*less,*greater,pivot;
I64 i,*left,*right,pivot;
if (num>1) {
left =base;
right=base+num-1;
pivot=base[num/2];
do {
less=base;
greater=base+num;
pivot=base[num/2];
while (less<greater) {
if ((*fp_compare)(*less,pivot)<=0)
less++;
else {
greater--;
SwapI64(less,greater);
}
}
i=less-base;
if (i==num) {//All less or equal to pivot
//Point greater to first less
do greater--;
while (--i && !(*fp_compare)(*greater,pivot));
if (i) {
less=base+num/2; //Pivot was not moved, point to it
if (less<greater)
SwapI64(less,greater);
num=i;
} else //All equal
break;
} else if (i<num/2) {
QSortI64(base,i,fp_compare);
num-=i;
base=greater;
} else {
QSortI64(greater,num-i,fp_compare);
num=i;
}
} while (num>1);
while ((*fp_compare)(*left,pivot)<0)
left++;
while ((*fp_compare)(*right,pivot)>0)
right--;
if (left<=right)
SwapI64(left++,right--);
} while (left<=right);
i=right+1-base;
if (1<i<num)
QSortI64(base,i,fp_compare);
i=base+num-left;
if (1<i<num)
QSortI64(left,i,fp_compare);
}
}
U0 QSort2a(U8 **_base,I64 num,I64 (*fp_compare)(U8 **_e1,U8 **_e2))
{//Not public. For case of width==size(U8 *)==8.
U0 QSort2a(U8 **base,I64 num,I64 (*fp_compare)(U8 **_e1,U8 **_e2))
{//Not public.For case of width==size(U8 *)==8.
//fp_compare() passes by ref.
I64 i;
U8 **_less,**_greater,*pivot;
U8 **left,**right,*pivot;
left =base;
right=base+num-1;
pivot=base[num/2];
do {
_less=_base;
_greater=_base+num;
pivot=_base[num/2];
while (_less<_greater) {
if ((*fp_compare)(_less,&pivot)<=0)
_less++;
else {
_greater--;
SwapI64(_less,_greater);
}
}
i=_less-_base;
if (i==num) {//All less or equal to pivot
//Point greater to first less
do _greater--;
while (--i && !(*fp_compare)(_greater,&pivot));
if (i) {
_less=_base+num/2; //Pivot was not moved, point to it
if (_less<_greater)
SwapI64(_less,_greater);
num=i;
} else //All equal
break;
} else if (i<num/2) {
if (i>1)
QSort2a(_base,i,fp_compare);
num-=i;
_base=_greater;
} else {
if (num-i>1)
QSort2a(_greater,num-i,fp_compare);
num=i;
}
} while (num>1);
while ((*fp_compare)(left,&pivot)<0)
left++;
while ((*fp_compare)(right,&pivot)>0)
right--;
if (left<=right)
SwapI64(left++,right--);
} while (left<=right);
i=right+1-base;
if (1<i<num)
QSort2a(base,i,fp_compare);
i=base+num-left;
if (1<i<num)
QSort2a(left,i,fp_compare);
}
U0 QSort2b(U8 *base,I64 num, I64 width, I64 (*fp_compare)(U8 *e1,U8 *e2),U8 *temp)
U0 QSort2b(U8 *base,I64 num, I64 width,
I64 (*fp_compare)(U8 *e1,U8 *e2),U8 *temp)
{//Not public
I64 i;
U8 *less,*greater,*pivot;
pivot=temp+width;
U8 *left,*right,*pivot=temp+width;
left =base;
right=base+(num-1)*width;
MemCpy(pivot,base+num/2*width,width);
do {
less=base;
greater=base+num*width;
MemCpy(pivot,base+num/2*width,width);
while (less<greater) {
if ((*fp_compare)(less,pivot)<=0)
less+=width;
else {
greater-=width;
MemCpy(temp,greater,width);
MemCpy(greater,less,width);
MemCpy(less,temp,width);
while ((*fp_compare)(left,pivot)<0)
left+=width;
while ((*fp_compare)(right,pivot)>0)
right-=width;
if (left<=right) {
if (left!=right) {
MemCpy(temp,right,width);
MemCpy(right,left,width);
MemCpy(left,temp,width);
}
left+=width;
right-=width;
}
i=(less-base)/width;
if (i==num) {//All less or equal to pivot
//Point greater to first less
do greater-=width;
while (--i && !(*fp_compare)(greater,pivot));
if (i) {
less=base+num/2*width; //Pivot was not moved, point to it
if (less<greater) {
MemCpy(temp,greater,width);
MemCpy(greater,less,width);
MemCpy(less,temp,width);
}
num=i;
} else //All equal
break;
} else if (i<num/2) {
if (i>1)
QSort2b(base,i,width,fp_compare,temp);
num-=i;
base=greater;
} else {
if (num-i>1)
QSort2b(greater,num-i,width,fp_compare,temp);
num=i;
}
} while (num>1);
} while (left<=right);
i=1+(right-base)/width;
if (1<i<num)
QSort2b(base,i,width,fp_compare,temp);
i=num+(base-left)/width;
if (1<i<num)
QSort2b(left,i,width,fp_compare,temp);
}
U0 QSort(U8 *base,I64 num, I64 width, I64 (*fp_compare)(U8 *e1,U8 *e2))
{/*Quick Sort: fp_compare() passes by ref.
For assending strings: return StrCmp(*e1,*e2);
For assending ints : return *e1-*e2;
Don't return e1-e2 if numbers can overflow, return -1,0 or 1.
Don't return e1-e2 if numbers can overflow, return -1,0 or 1.
Maybe, look at $LK,"::/Demo/MultiCore/RadixSort.CPP"$.
*/
I64 i;
U8 *less,*greater,*temp,*pivot;
U8 *temp;
if (width && num>1) {
if (width==sizeof(U8 *)) { //assign instead of MemCpy for width 8
do {
less=base;
greater=base+num*sizeof(U8 *);
pivot(U8 *)=base(U8 **)[num/2];
while (less<greater) {
if ((*fp_compare)(less,&pivot)<=0)
less+=sizeof(U8 *);
else {
greater-=sizeof(U8 *);
SwapI64(less,greater);
}
}
i=(less-base)/sizeof(U8 *);
if (i==num) {//All less or equal to pivot
//Point greater to first less
do greater-=sizeof(U8 *);
while (--i && !(*fp_compare)(greater,&pivot));
if (i) {
less=base+num/2*sizeof(U8 *); //Pivot was not moved, point to it
if (less<greater)
SwapI64(less,greater);
num=i;
} else //All equal
break;
} else if (i<num/2) {
if (i>1)
QSort2a(base,i,fp_compare);
num-=i;
base=greater;
} else {
if (num-i>1)
QSort2a(greater,num-i,fp_compare);
num=i;
}
} while (num>1);
} else {
if (width==sizeof(U8 *)) //assign instead of MemCpy for width 8
QSort2a(base,num,fp_compare);
else {
temp=MAlloc(width*2);
pivot=temp+width;
do {
less=base;
greater=base+num*width;
MemCpy(pivot,base+num/2*width,width);
while (less<greater) {
if ((*fp_compare)(less,pivot)<=0)
less+=width;
else {
greater-=width;
MemCpy(temp,greater,width);
MemCpy(greater,less,width);
MemCpy(less,temp,width);
}
}
i=(less-base)/width;
if (i==num) {//All less or equal to pivot
//Point greater to first less
do greater-=width;
while (--i && !(*fp_compare)(greater,pivot));
if (i) {
less=base+num/2*width; //Pivot was not moved, point to it
if (less<greater) {
MemCpy(temp,greater,width);
MemCpy(greater,less,width);
MemCpy(less,temp,width);
}
num=i;
} else //All equal
break;
} else if (i<num/2) {
if (i>1)
QSort2b(base,i,width,fp_compare,temp);
num-=i;
base=greater;
} else {
if (num-i>1)
QSort2b(greater,num-i,width,fp_compare,temp);
num=i;
}
} while (num>1);
QSort2b(base,num,width,fp_compare,temp);
Free(temp);
}
}
Kernel/Sched.CPP
+3 -7
View File
@@ -42,7 +42,6 @@ requests to spawn tasks. See $LK,"APSethTask",A="MN:APSethTask"$().
$HL,1$*/
asm {
USE64
//************************************
TASK_CONTEXT_SAVE::
//OUT: RSI=FS
@@ -206,15 +205,14 @@ RESTORE_RSI_TASK_WITH_KEY_CHECK:
RESTORE_RSI_TASK_NO_KEY_CHECK:
@@20: BT U64 CTask.task_flags[RSI],TASKf_KILL_TASK
JC I32 END_RSI_TASK
TEST U64 CTask.task_flags[RSI],1<<TASKf_AWAITING_MSG|1<<TASKf_SUSPENDED
TEST U64 CTask.task_flags[RSI],
1<<TASKf_AWAITING_MSG|1<<TASKf_SUSPENDED
JNZ @@25
MOV RAX,U64 [&cnts.jiffies]
CMP U64 CTask.wake_jiffy[RSI],RAX
JG @@25 //Jmp if not ready, yet.
CMP U32 CTask.task_in_que_signature[RSI],TASK_IN_QUE_SIGNATURE_VAL
JNE SWAP_IN_SETH_TASK_IF_READY
MOV RAX,RSI
CALL SET_FS_BASE
JMP I32 _TASK_CONTEXT_RESTORE
@@ -237,7 +235,7 @@ SYS_IDLE_PT::
SWAP_IN_SETH_TASK_IF_READY:
XOR RAX,RAX
MOV RSI,GS:CCPU.seth_task[RAX]
JMP I32 RESTORE_RSI_TASK_WITH_KEY_CHECK
JMP RESTORE_RSI_TASK_WITH_KEY_CHECK
HANDLE_SWAP_KEY_EVENT:
MOV RAX,RSI
@@ -357,7 +355,6 @@ U0 TaskQueIns(CTask *task,CTask *pred=NULL)
last->next_task=pred->last_task=task;
task->last_task=last;
task->next_task=pred;
task->task_in_que_signature=TASK_IN_QUE_SIGNATURE_VAL;
POPFD
}
@@ -367,7 +364,6 @@ U0 TaskQueRem(CTask *task)
CTask *next,*last;
PUSHFD
CLI
task->task_in_que_signature=0;
next=task->next_task;
last=task->last_task;
last->next_task=next;
Kernel/SrvCmd.CPP
+29 -28
View File
@@ -40,7 +40,7 @@ CSrvCmd *TaskExe(CTask *srv,CTask *master,U8 *data,I64 flags)
{//Queues a request to compile and execute src code text.
CSrvCmd *result;
if (!data || !TaskValidate(srv) || master && !TaskValidate(master) ||
srv->popup_task && !Bt(&srv->task_flags,TASKf_FILTER_INPUT))
srv->popup_task && !Bt(&srv->task_flags,TASKf_FILTER_INPUT))
return NULL;
result=ACAlloc(sizeof(CSrvCmd));
result->master_task=master;
@@ -74,10 +74,10 @@ CSrvCmd *TaskExe(CTask *srv,CTask *master,U8 *data,I64 flags)
CSrvCmd *TaskText(CTask *srv,CTask *master,U8 *data,I64 flags)
{//Post StdIn text to servant task. Tell who the master task is.
CSrvCmd *result;
Bool old_preempt=Preempt(OFF);
Bool old_preempt=Preempt;
CTask *task;
if (!data || !TaskValidate(srv) || master && !TaskValidate(master) ||
srv->popup_task && !Bt(&srv->task_flags,TASKf_FILTER_INPUT)) {
srv->popup_task && !Bt(&srv->task_flags,TASKf_FILTER_INPUT)) {
Preempt(old_preempt);
return NULL;
}
@@ -125,7 +125,7 @@ CSrvCmd *TaskMsg(CTask *_srv,CTask *master,I64 msg_code,I64 a1,I64 a2,I64 flags)
CSrvCmd *tempc1,*tempc;
CTask *srv=_srv;
if (!TaskValidate(srv) || master && !TaskValidate(master)||
srv->popup_task && !Bt(&srv->task_flags,TASKf_FILTER_INPUT))
srv->popup_task && !Bt(&srv->task_flags,TASKf_FILTER_INPUT))
return NULL;
tempc=ACAlloc(sizeof(CSrvCmd));
tempc->master_task=master;
@@ -136,14 +136,14 @@ 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_util_task && msg_code==MSG_KEY_DOWN) {
tempc1=AMAllocIdentical(tempc);
CLI
QueIns(tempc1,sys_macro_root.last);
}
CLI
while (Bt(&srv->task_flags,TASKf_FILTER_INPUT) &&
!Bt(&flags,SVCf_DONT_FILTER))
!Bt(&flags,SVCf_DONT_FILTER))
srv=srv->next_input_filter_task;
tempc->ctrl=&srv->srv_ctrl;
while (LBts(&srv->srv_ctrl.flags,SVCRf_LOCKED))
@@ -163,7 +163,7 @@ CSrvCmd *TaskMsg(CTask *_srv,CTask *master,I64 msg_code,I64 a1,I64 a2,I64 flags)
return tempc;
}
Bool ScanResult(CSrvCmd *rqst=NULL,I64 *_result=NULL)
Bool JobResultScan(CSrvCmd *rqst=NULL,I64 *_result=NULL)
{//Check rqst complete, return with or without.
CSrvCtrl *ctrl;
CSrvCmd *tempc,*tempc1;
@@ -198,7 +198,7 @@ Bool ScanResult(CSrvCmd *rqst=NULL,I64 *_result=NULL)
return FALSE;
}
I64 GetResult(CSrvCmd *rqst=NULL)
I64 JobResultGet(CSrvCmd *rqst=NULL)
{//See $LK,"::/Demo/MultiCore/Lock.CPP"$
I64 result;
CSrvCmd *tempc1;
@@ -216,7 +216,7 @@ I64 GetResult(CSrvCmd *rqst=NULL)
}
LBtr(&Fs->task_flags,TASKf_IDLE);
//Could get taken by someone else.
ScanResult(rqst,&result);
JobResultScan(rqst,&result);
return result;
}
@@ -232,7 +232,7 @@ U0 TaskWait(CTask *task=NULL)
task1=task->last_input_filter_task;
tempc1=&task1->srv_ctrl.next_waiting;
if (task1==Fs || !TaskValidate(task1) ||
tempc1==tempc1->next && Bt(&task1->task_flags,TASKf_IDLE))
tempc1==tempc1->next && Bt(&task1->task_flags,TASKf_IDLE))
break;
Yield;
}
@@ -241,25 +241,24 @@ U0 TaskWait(CTask *task=NULL)
}
U0 PostMsg(CTask *task,I64 msg_code,I64 a1,I64 a2,I64 flags=0)
{//Post a message and return immediately. See $LK,"msg_code",A="MN:MSG_CMD"$.
{//Post message to a task and return immediately. See $LK,"msg_code",A="MN:MSG_CMD"$.
if (TaskValidate(task)) {
if (Bt(&task->task_flags,TASKf_INPUT_FILTER_TASK))
TaskMsg(task->last_input_filter_task,NULL,msg_code,a1,a2,
flags|1<<SVCf_DONT_FILTER);
flags|1<<SVCf_DONT_FILTER);
else
TaskMsg(task,NULL,msg_code,a1,a2,flags);
}
}
U0 SendMsg(CTask *task,I64 msg_code,I64 a1,I64 a2,I64 flags=0)
{//Post a message to a task and wait until it is delivered
//and the task becomes idle. See $LK,"msg_code",A="MN:MSG_CMD"$.
U0 PostMsgWait(CTask *task,I64 msg_code,I64 a1,I64 a2,I64 flags=0)
{//Post message to a task and wait until task is idle.See $LK,"msg_code",A="MN:MSG_CMD"$.
PostMsg(task,msg_code,a1,a2,flags);
TaskWait(task);
}
U0 Msg(I64 msg_code,I64 a1,I64 a2,I64 flags=0)
{//Post a message to the current task and return immediately.
{//Post message to current task and return immediately.
//See $LK,"msg_code",A="MN:MSG_CMD"$.
PostMsg(Fs,msg_code,a1,a2,flags);
}
@@ -285,9 +284,11 @@ I64 SrvCmdRun(CSrvCmd *tempc,I64 old_flags)
tempc->servant_cpu_num=Gs->num;
LBtr(&ctrl->flags,SVCRf_LOCKED);
if (tempc->aux_str)
tempc->spawned_task=Spawn(tempc->addr,tempc->fun_arg,tempc->aux_str,,tempc->aux1,tempc->aux2,tempc->flags);
tempc->spawned_task=Spawn(tempc->addr,tempc->fun_arg,
tempc->aux_str,,tempc->aux1,tempc->aux2,tempc->flags);
else
tempc->spawned_task=Spawn(tempc->addr,tempc->fun_arg,"Unnamed",,tempc->aux1,tempc->aux2,tempc->flags);
tempc->spawned_task=Spawn(tempc->addr,tempc->fun_arg,
"Unnamed",,tempc->aux1,tempc->aux2,tempc->flags);
break;
case SVCT_CALL:
QueRem(tempc);
@@ -297,7 +298,7 @@ I64 SrvCmdRun(CSrvCmd *tempc,I64 old_flags)
SetRFlags(old_flags);
LBtr(&Fs->task_flags,TASKf_IDLE);
try
tempc->result=(*tempc->addr)(tempc->fun_arg);
tempc->result=(*tempc->addr)(tempc->fun_arg);
catch
Fs->catch_except=TRUE;
SetRFlags(old_flags);
@@ -310,7 +311,7 @@ I64 SrvCmdRun(CSrvCmd *tempc,I64 old_flags)
SetRFlags(old_flags);
LBtr(&Fs->task_flags,TASKf_IDLE);
try
tempc->result=ExePrint("%s",tempc->aux_str);
tempc->result=ExePrint("%s",tempc->aux_str);
catch
Fs->catch_except=TRUE;
SetRFlags(old_flags);
@@ -385,7 +386,7 @@ I64 PopUp(U8 *buf,CTask *parent=NULL,CTask **_pu_task=NULL)
{//Execute code text in PopUp win task.
I64 result;
CSrvCmd *tempc;
Bool old_preempt=Preempt(OFF);
Bool old_preempt=Preempt;
CTask *task=Spawn(&SrvCmdLine,NULL,"Servant",,parent);
if (!parent) {
TaskExe(task,parent,buf,1<<SVCf_EXIT_ON_COMPLETE|1<<SVCf_FREE_ON_COMPLETE);
@@ -396,7 +397,7 @@ I64 PopUp(U8 *buf,CTask *parent=NULL,CTask **_pu_task=NULL)
Fs->popup_task=task;
tempc=TaskExe(task,parent,buf,1<<SVCf_WAKE_MASTER|1<<SVCf_FOCUS_MASTER);
if (_pu_task) *_pu_task=task;
ScanResult(tempc,&result);
JobResultScan(tempc,&result);
Fs->popup_task=NULL;
Kill(task);
if (_pu_task) *_pu_task=NULL;
@@ -418,7 +419,7 @@ I64 Adam(U8 *fmt,...)
{//Sends text to the adam task which gets compiled and run.
I64 result;
U8 *buf=StrPrintJoin(NULL,fmt,argc,argv);
Bool old_preempt=Preempt(OFF);
Bool old_preempt=Preempt;
CSrvCmd *tempc;
if (Fs==adam_task) {
tempc=TaskExe(adam_task,Fs,buf,0);
@@ -428,7 +429,7 @@ I64 Adam(U8 *fmt,...)
tempc=TaskExe(adam_task,Fs,buf,1<<SVCf_WAKE_MASTER);
}
Preempt(old_preempt);
ScanResult(tempc,&result);
JobResultScan(tempc,&result);
Free(buf);
return result;
}
@@ -446,7 +447,7 @@ U0 AdamLog(U8 *fmt,...)
U0 AdamErr(U8 *fmt,...)
{//Sends text to the adam task which gets displayed as red and blinking.
U8 *buf=StrPrintJoin(NULL,fmt,argc,argv),
*st=MStrPrint(ST_ERR_ST "%s",buf);
*st=MStrPrint(ST_ERR_ST "%s",buf);
if (Fs==adam_task)
"%s",st;
else if (!IsSingleUser)
@@ -458,7 +459,7 @@ U0 AdamErr(U8 *fmt,...)
U0 XTalk(CTask *task,U8 *fmt,...)
{//Sends text to other task. See $LK,"::/Misc/OSTestSuite.CPP"$.
U8 *buf=StrPrintJoin(NULL,fmt,argc,argv),*st=AStrNew(buf),
*st2=MStrPrint("\"%%s\",%d;Free(%d);",st,st);
*st2=MStrPrint("\"%%s\",%d;Free(%d);",st,st);
TaskText(task,NULL,st2,0);
Free(st2);
Free(buf);
@@ -467,7 +468,7 @@ U0 XTalk(CTask *task,U8 *fmt,...)
U0 XTalkWait(CTask *task,U8 *fmt,...)
{//Send text to other task and wait for it to idle.
U8 *buf=StrPrintJoin(NULL,fmt,argc,argv),*st=AStrNew(buf),
*st2=MStrPrint("\"%%s\",%d;Free(%d);",st,st);
*st2=MStrPrint("\"%%s\",%d;Free(%d);",st,st);
TaskText(task,NULL,st2,0);
Free(st2);
Free(buf);
@@ -488,7 +489,7 @@ U0 AutoFile(U8 *filename)
{//Send AutoFile code file to self.
U8 *name=DftExt(filename,"AUT.Z");
AutoStr("Cd(\"%C:%s\");;#include \"%s\"",
Drv2Let(Fs->cur_dv),Fs->cur_dir,name);
Drv2Let(Fs->cur_dv),Fs->cur_dir,name);
Free(name);
}
Kernel/StrA.CPP
+95 -76
View File
@@ -18,7 +18,6 @@ U0 PutHex(I64 num,I64 width)
}
asm {
USE64
// IN: RAX=NUM TO PRINT
PUT_HEX_U64::
PUSH_C_REGS
@@ -306,76 +305,99 @@ _STRIMATCH::
POP RBP
RET1 16
}
_extern _STRCMP I64 StrCmp(U8 *st1,U8 *st2); //Compare two strings.
_extern _STRICMP I64 StrICmp(U8 *st1,U8 *st2); //Compare two strings, ignoring case.
_extern _STRNCMP I64 StrNCmp(U8 *st1,U8 *st2,I64 n); //Compare N bytes in two strings.
_extern _STRNICMP I64 StrNICmp(U8 *st1,U8 *st2,I64 n); //Compare N bytes in two strings, ignoring case.
_extern _STRMATCH U8 *StrMatch(U8 *needle,U8 *haystack_str); //Scan for string in string.
_extern _STRIMATCH U8 *StrIMatch(U8 *needle,U8 *haystack_str); //Scan for string in string, ignoring case.
_extern _STRCPY U0 StrCpy(U8 *dst,U8 *src); //Copy string.
_extern _STRCMP I64 StrCmp(
U8 *st1,U8 *st2); //Compare two strings.
_extern _STRICMP I64 StrICmp(
U8 *st1,U8 *st2); //Compare two strings, ignoring case.
_extern _STRNCMP I64 StrNCmp(
U8 *st1,U8 *st2,I64 n); //Compare N bytes in two strings.
_extern _STRNICMP I64 StrNICmp(
U8 *st1,U8 *st2,I64 n); //Compare N bytes in two strings, ignoring case.
_extern _STRMATCH U8 *StrMatch(
U8 *needle,U8 *haystack_str); //Scan for string in string.
_extern _STRIMATCH U8 *StrIMatch(
U8 *needle,U8 *haystack_str);//Scan for string in string, ignoring case.
_extern _STRCPY U0 StrCpy(
U8 *dst,U8 *src); //Copy string.
//These bitmaps go to 0-511 so that $LK,"Lex",A="MN:Lex"$() can use them with $LK,"Token Codes",A="MN:TK_EOF"$.
U32
chars_bmp_alpha[16]=
{0x0000000,0x00000000,0x87FFFFFF,0x07FFFFFE,
0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,
0,0,0,0,0,0,0,0},
U32 chars_bitmap_alpha[16]=
{0x0000000,0x00000000,0x87FFFFFF,0x07FFFFFE,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,
0,0,0,0,0,0,0,0},
chars_bmp_alpha_numeric[16]=
{0x0000000,0x03FF0000,0x87FFFFFF,0x07FFFFFE,
0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,
0,0,0,0,0,0,0,0},
chars_bitmap_alpha_numeric[16]=
{0x0000000,0x03FF0000,0x87FFFFFF,0x07FFFFFE,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,
0,0,0,0,0,0,0,0},
chars_bmp_alpha_numeric_no_at[16]=
{0x0000000,0x03FF0000,0x87FFFFFE,0x07FFFFFE,
0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,
0,0,0,0,0,0,0,0},
chars_bitmap_alpha_numeric_no_at[16]=
{0x0000000,0x03FF0000,0x87FFFFFE,0x07FFFFFE,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,
0,0,0,0,0,0,0,0},
chars_bmp_word[16]=
{0x0000000,0x03FF0080,0x87FFFFFE,0x07FFFFFE,
0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,
0,0,0,0,0,0,0,0},
chars_bitmap_word[16]=
{0x0000000,0x03FF0080,0x87FFFFFE,0x07FFFFFE,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,
0,0,0,0,0,0,0,0},
chars_bmp_filename[16]=
{0x0000000,0x03FF73FB,0xEFFFFFFF,0x6FFFFFFF,
0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,
0,0,0,0,0,0,0,0},
chars_bitmap_filename[16]=
{0x0000000,0x03FF73FB,0xEFFFFFFF,0x2FFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,
0,0,0,0,0,0,0,0},
chars_bmp_dec_numeric[16]=
{0x0000000,0x03FF0000,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
chars_bitmap_dec_numeric[16]=
{0x0000000,0x03FF0000,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
chars_bmp_hex_numeric[16]=
{0x0000000,0x03FF0000,0x7E,0x7E,0,0,0,0,0,0,0,0,0,0,0,0},
chars_bitmap_hex_numeric[16]=
{0x0000000,0x03FF0000,0x7E,0x7E,0,0,0,0,0,0,0,0,0,0,0,0},
chars_bmp_white_space[16]=
{0x80003600,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
chars_bitmap_white_space[16]=
{0x80003600,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
chars_bmp_non_eol_white_space[16]=
{0x80001200,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
chars_bitmap_non_eol_white_space[16]=
{0x80001200,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
chars_bmp_zero_cr_nl_cursor[16]=
{0x00002421,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
chars_bitmap_zero_cr_nl_cursor[16]=
{0x00002421,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
chars_bmp_zero_tab_ff_cr_nl_cursor[16]=
{0x00003621,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
chars_bitmap_zero_tab_ff_cr_nl_cursor[16]=
{0x00003621,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
chars_bmp_zero_tab_ff_cr_nl_cursor_dollar[16]=
{0x00003621,0x10,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
chars_bitmap_zero_tab_ff_cr_nl_cursor_dollar[16]=
{0x00003621,0x10,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
chars_bmp_getkey[16]=
{0x80002600,0xFFFFFFFF,0xFFFFFFFF,0x7FFFFFFF,
0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,
0,0,0,0,0,0,0,0},
chars_bitmap_getkey[16]=
{0x80002600,0xFFFFFFFF,0xFFFFFFFF,0x7FFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,
0,0,0,0,0,0,0,0},
chars_bmp_macro[16]=
{0x80002600,0xFFFFFFDF,0xFFFFFFFF,0x7FFFFFFF,
0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,
0,0,0,0,0,0,0,0},
chars_bitmap_printable[16]=
{0x80003600,0xFFFFFFFF,0xFFFFFFFF,0x7FFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,
0,0,0,0,0,0,0,0},
chars_bmp_printable[16]=
{0x80003600,0xFFFFFFFF,0xFFFFFFFF,0x7FFFFFFF,
0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,
0,0,0,0,0,0,0,0},
chars_bitmap_displayable[16]=
{0x80000000,0xFFFFFFFF,0xFFFFFFFF,0x7FFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,
0,0,0,0,0,0,0,0},
chars_bmp_displayable[16]=
{0x80000000,0xFFFFFFFF,0xFFFFFFFF,0x7FFFFFFF,
0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,
0,0,0,0,0,0,0,0},
chars_bitmap_safe_dollar[16]=
{0x80000000,0xFFFFFFEF,0xFFFFFFFF,0x7FFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,
0,0,0,0,0,0,0,0},//same but no dollar sign
chars_bmp_safe_dollar[16]=
{0x80000000,0xFFFFFFEF,0xFFFFFFFF,0x7FFFFFFF,
0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,
0,0,0,0,0,0,0,0},//same but no dollar sign
chars_bitmap_non_eol[16]=
{0xFFFFDBFE,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,
0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF};
chars_bmp_non_eol[16]=
{0xFFFFDBFE,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,
0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,
0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,
0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF};
U8 *LstSub(I64 sub, U8 *lst)
{//Point to lst entry.
@@ -399,7 +421,7 @@ U8 *LstSub(I64 sub, U8 *lst)
I64 LstMatch(U8 *needle, U8 *haystack_lst,I64 flags=0)
{//-2 if Ambiguous
// -1 if not found
// Not efficient. Use hash tables for efficiency.
// Not efficient. Use hash tables for efficiency.
I64 n,sub=0,result=-1;
U8 *ptr;
Bool exact_match=FALSE;
@@ -505,14 +527,14 @@ U8 *StrUtil(U8 *_src,I64 flags)
I64 ch;
if (flags & SUF_REM_LEADING)
while (Bt(chars_bitmap_white_space,*src))
while (Bt(chars_bmp_white_space,*src))
src++;
while (ch=*src++)
if (Bt(chars_bitmap_white_space,ch)) {
if (Bt(chars_bmp_white_space,ch)) {
if (!(flags & SUF_REM_SPACES)) {
if (flags & SUF_SINGLE_SPACE) {
*dst++ = CH_SPACE;
while ((ch=*src++) && Bt(chars_bitmap_white_space,ch));
while ((ch=*src++) && Bt(chars_bmp_white_space,ch));
src--;
} else
*dst++ = ch;
@@ -522,7 +544,7 @@ U8 *StrUtil(U8 *_src,I64 flags)
*dst=0;
if (flags & SUF_REM_TRAILING)
while (dst!=_src && (!*dst || Bt(chars_bitmap_white_space,*dst)))
while (dst!=_src && (!*dst || Bt(chars_bmp_white_space,*dst)))
*dst-- =0;
if (flags & SUF_TO_UPPER)
for (dst=_src;*dst;dst++) {
@@ -539,7 +561,7 @@ U8 *StrUtil(U8 *_src,I64 flags)
if (flags & SUF_SAFE_DOLLAR)
for (dst=_src;*dst;dst++) {
ch=*dst;
if (!Bt(chars_bitmap_safe_dollar,*dst))
if (!Bt(chars_bmp_safe_dollar,*dst))
*dst='.';
}
if (flags & SUF_S2T)
@@ -610,25 +632,22 @@ U8 *StrFind(U8 *needle,U8 *haystack_str,I64 flags=0)
haystack_str=StrIMatch(needle,haystack_str);
else
haystack_str=StrMatch(needle,haystack_str);
if (haystack_str && flags & SFF_WHOLE_LABELS_BEFORE) {
if (haystack_str!=saved_haystack_str) {
if (Bt(chars_bitmap_alpha_numeric,*(haystack_str-1))) {
haystack_str++;
if (*haystack_str)
cont=TRUE;
else
haystack_str=NULL;
}
}
if (haystack_str && flags & SFF_WHOLE_LABELS_BEFORE &&
haystack_str!=saved_haystack_str &&
Bt(chars_bmp_alpha_numeric,*(haystack_str-1))) {
haystack_str++;
if (*haystack_str)
cont=TRUE;
else
haystack_str=NULL;
}
if (haystack_str && flags & SFF_WHOLE_LABELS_AFTER) {
if (Bt(chars_bitmap_alpha_numeric,*(haystack_str+plen))) {
haystack_str++;
if (*haystack_str)
cont=TRUE;
else
haystack_str=NULL;
}
if (haystack_str && flags & SFF_WHOLE_LABELS_AFTER &&
Bt(chars_bmp_alpha_numeric,*(haystack_str+plen))) {
haystack_str++;
if (*haystack_str)
cont=TRUE;
else
haystack_str=NULL;
}
} while (cont);
return haystack_str;
Kernel/StrB.CPP
+4 -2
View File
@@ -140,7 +140,8 @@ ScanFlags(&flags,"R\0L\0Dump\0Scan\0","+Dump-R"); //Sets Bit#2, Clears Bit#0.
src++;
if (*src) {
ptr=buf;
while (*src && *src!='+' && *src!='-' && *src!=CH_SPACE && *src!=CH_SHIFT_SPACE)
while (*src && *src!='+' && *src!='-' &&
*src!=CH_SPACE && *src!=CH_SHIFT_SPACE)
*ptr++=*src++;
*ptr=0;
i=LstMatch(buf,lst);
@@ -155,7 +156,8 @@ ScanFlags(&flags,"R\0L\0Dump\0Scan\0","+Dump-R"); //Sets Bit#2, Clears Bit#0.
src++;
if (*src) {
ptr=buf;
while (*src && *src!='+' && *src!='-' && *src!=CH_SPACE && *src!=CH_SHIFT_SPACE)
while (*src && *src!='+' && *src!='-' &&
*src!=CH_SPACE && *src!=CH_SHIFT_SPACE)
*ptr++=*src++;
*ptr=0;
i=LstMatch(buf,lst);
Kernel/StrPrint.CPP
+47 -44
View File
@@ -69,7 +69,7 @@ U8 *MPrintQ(U8 *ptr,I64 flags)
{
U8 **_buf,*buf,**_dst,*dst,buf2[8],*ptr2;
I64 ch;
buf=MAlloc(128);
buf=MAlloc(STR_LEN);
_buf=&buf;
dst=buf;
_dst=&dst;
@@ -128,7 +128,7 @@ U8 *MPrintq(U8 *ptr,I64 flags)
{
U8 **_buf,*buf,**_dst,*dst;
I64 i,ch,ch1;
buf=MAlloc(128);
buf=MAlloc(STR_LEN);
_buf=&buf;
dst=buf;
_dst=&dst;
@@ -173,7 +173,7 @@ U8 *MPrintq(U8 *ptr,I64 flags)
ptr++;
while (TRUE) {
ch1=ToUpper(*ptr++);
if (Bt(chars_bitmap_hex_numeric,ch1)) {
if (Bt(chars_bmp_hex_numeric,ch1)) {
if (ch1<='9')
i=i<<4+ch1-'0';
else
@@ -207,15 +207,15 @@ U8 *MPrintq(U8 *ptr,I64 flags)
return buf;
}
U8 *sys_pos_powers_lets=" KMGTPEZY",
*sys_neg_powers_lets=" mænpfazy",
*sys_pos_powers_lst="kilo\0mega\0giga\0tera\0peta\0exa\0zetta\0yotta\0",
*sys_neg_powers_lst="milli\0micro\0nano\0pico\0femto\0atto\0zepto\0yocto\0";
U8 *sys_pos_pows_lets=" KMGTPEZY",
*sys_neg_pows_lets=" mænpfazy",
*sys_pos_pows_lst="kilo\0mega\0giga\0tera\0peta\0exa\0zetta\0yotta\0",
*sys_neg_pows_lst="milli\0micro\0nano\0pico\0femto\0atto\0zepto\0yocto\0";
#define TEMP_BUF_LEN 256
#define SLOP 8
U8 *StrPrintJoin(U8 *dst,U8 *src,I64 argc,I64 *argv)
U8 *StrPrintJoin(U8 *dst,U8 *fmt,I64 argc,I64 *argv)
{/*$LK,"Print(\"\") Fmt Strings",A="FI:::/Doc/Print.TXT"$
In float formatting, do not exceed 18-digits
before or after the decimal point
@@ -230,45 +230,45 @@ to avoid this.
F64 d,d1;
U8 *ptr,**_buf,*buf,**_dst,temp_buf[TEMP_BUF_LEN],temp_buf2[TEMP_BUF_LEN*2];
if (!src)
if (!fmt)
throw('StrPrint');
if (dst) {
_buf=NULL;
buf=dst;
} else {
buf=MAlloc(128);
buf=MAlloc(STR_LEN);
_buf=&buf;
dst=buf;
}
_dst=&dst;
while (ch = *src++) {
while (ch = *fmt++) {
if (ch=='%') {
flags=0;
if (*src=='-') {
if (*fmt=='-') {
flags|=SPF_LEFT_JUSTIFY;
src++;
fmt++;
}
if (*src=='0') {
if (*fmt=='0') {
flags|=SPF_PAD_ZERO;
src++;
fmt++;
}
len=0;
while ('0'<=*src<='9')
len=len*10+ *src++ -'0';
if (*src=='*') {
src++;
while ('0'<=*fmt<='9')
len=len*10+ *fmt++ -'0';
if (*fmt=='*') {
fmt++;
if (cur_arg>=argc)
throw('StrPrint');
len=argv[cur_arg++];
}
dec_len=0;
if (*src=='.') {
src++;
while ('0'<=*src<='9')
dec_len=dec_len*10+ *src++ -'0';
if (*src=='*') {
src++;
if (*fmt=='.') {
fmt++;
while ('0'<=*fmt<='9')
dec_len=dec_len*10+ *fmt++ -'0';
if (*fmt=='*') {
fmt++;
if (cur_arg>=argc)
throw('StrPrint');
dec_len=argv[cur_arg++];
@@ -278,7 +278,7 @@ to avoid this.
aux_fmt_num=0;
while (TRUE) {
switch (*src) {
switch (*fmt) {
sub_switch_start:
case '$$':
flags|=SPF_DOLLAR;
@@ -295,28 +295,28 @@ to avoid this.
case 'l': //harmless
break;
sub_switch_end:
src++;
fmt++;
break;
case 'h':
src++;
fmt++;
flags|=SPF_AUX_FMT_NUM;
if (*src=='?') {
src++;
if (*fmt=='?') {
fmt++;
flags|=SPF_QUESTION;
} else {
if (*src=='*') {
src++;
if (*fmt=='*') {
fmt++;
if (cur_arg>=argc)
throw('StrPrint');
aux_fmt_num=argv[cur_arg++];
} else {
if (*src=='-') {
src++;
if (*fmt=='-') {
fmt++;
flags|=SPF_NEG_AUX_FMT_NUM;
}
while ('0'<=*src<='9')
aux_fmt_num=aux_fmt_num*10+ *src++ -'0';
while ('0'<=*fmt<='9')
aux_fmt_num=aux_fmt_num*10+ *fmt++ -'0';
if (flags&SPF_NEG_AUX_FMT_NUM)
aux_fmt_num=-aux_fmt_num;
}
@@ -327,9 +327,9 @@ to avoid this.
}
}
sp_arg:
sp_arg:
k=0;
switch (*src++) {
switch (*fmt++) {
sub_switch_start:
case 'F':
if (cur_arg>=argc)
@@ -430,7 +430,8 @@ sp_arg:
else
StrPrintPSect(temp_buf,argv[cur_arg],0);
if (!IsRaw || !_buf) {
StrPrint(temp_buf2,"$$LK,\"%s\",A=\"AD:0x%X\"$$",temp_buf,argv[cur_arg]);
StrPrint(temp_buf2,"$$LK,\"%s\",A=\"AD:0x%X\"$$",
temp_buf,argv[cur_arg]);
OutStr(temp_buf2,_buf,_dst,len,flags);
} else
OutStr(temp_buf,_buf,_dst,len,flags);
@@ -474,7 +475,8 @@ sp_out_comma_num:
if (flags&SPF_PAD_ZERO) {
if (flags&SPF_NEG)
SPutChar(_dst,'-',_buf);
comma_cnt=(len-k-i+comma_fmt_cnt-comma_cnt+1)%(comma_fmt_cnt+1)+1;
comma_cnt=(len-k-i+comma_fmt_cnt-comma_cnt+1)
%(comma_fmt_cnt+1)+1;
for (;i<len-k;i++) {
if (!--comma_cnt) {
SPutChar(_dst,',',_buf);
@@ -557,7 +559,7 @@ sp_out_inf:
break;
}
sp_out_f:
sp_out_f:
if (dec_len<0)
dec_len=0;
n=Log10(d);
@@ -743,9 +745,9 @@ sp_out_eng: //Engineering notation
i=aux_fmt_num/3;
}
if (i<0)
temp_buf[k++]=sys_neg_powers_lets[-i];
temp_buf[k++]=sys_neg_pows_lets[-i];
else if (i>0)
temp_buf[k++]=sys_pos_powers_lets[i];
temp_buf[k++]=sys_pos_pows_lets[i];
else if (len!=0)
temp_buf[k++]=CH_SPACE;
if (!(flags&SPF_DECIMAL)) {
@@ -895,8 +897,9 @@ U8 *CatPrint(U8 *_dst,U8 *fmt,...)
U0 Print(U8 *fmt,...)
{//$LK,"Print(\"\") Fmt Strings",A="FI:::/Doc/Print.TXT"$. See $LK,"StrPrintJoin",A="MN:StrPrintJoin"$().
//Don't use this. $LK,"See Print() shortcut.",A="FF:::/Doc/HolyC.TXT.Z,DemoHolyC"$
U8 *buf=StrPrintJoin(NULL,fmt,argc,argv);
PutS(buf);
PutS(buf);//Don't use PutS(). $LK,"See Print() shortcut.",A="FF:::/Doc/HolyC.TXT.Z,DemoHolyC"$
Free(buf);
}
Kernel/StrScan.CPP
+13 -13
View File
@@ -1,14 +1,14 @@
I64 Str2I64(U8 *st,I64 radix=10,U8 **_end_ptr=NULL)
{//String to I64. Similar to strtoul().
//Allows radix change with "0x20" "0b1010" "0d123" "0o18".
//Be careful of Str2I64("0b101",16)-->0xB101.
//Be careful of Str2I64("0b101",16)-->0xB101.
Bool neg=FALSE;
I64 ch,result=0;
if (!st || !(2<=radix<=36)) {
if (_end_ptr) *_end_ptr=st;
return 0;
}
while (Bt(chars_bitmap_white_space,*st))
while (Bt(chars_bmp_white_space,*st))
st++;
while (TRUE)
switch (*st) {
@@ -66,7 +66,7 @@ to avoid this.
Bool neg=FALSE,neg_e=FALSE;
ch=*src++;
while (Bt(chars_bitmap_white_space,ch))
while (Bt(chars_bmp_white_space,ch))
ch=*src++;
if (ch=='-') {
neg=TRUE;
@@ -84,7 +84,7 @@ to avoid this.
}
i=0;
while (TRUE) {
if (Bt(chars_bitmap_dec_numeric,ch))
if (Bt(chars_bmp_dec_numeric,ch))
i=i*10+ch-'0';
else {
if (ch=='.' || ch=='e' || ch=='E')
@@ -98,7 +98,7 @@ to avoid this.
ch=*src++;
k=0;
while (TRUE) {
if (Bt(chars_bitmap_dec_numeric,ch)) {
if (Bt(chars_bmp_dec_numeric,ch)) {
i=i*10+ch-'0';
k++;
} else {
@@ -116,7 +116,7 @@ to avoid this.
}
j=0;
while (TRUE) {
if (Bt(chars_bitmap_dec_numeric,ch))
if (Bt(chars_bmp_dec_numeric,ch))
j=j*10+ch-'0';
else {
if (neg_e)
@@ -138,10 +138,10 @@ a2f_end:
CDate Str2Date(U8 *_src)
{/*"*+nnnn", "*-nnnn", "mm/dd", "mm/dd/yy"
It also supports some funs
SM() start of mon
EM() end of mon
SY() start of year
EY() end of year
SM() start of mon
EM() end of mon
SY() start of year
EY() end of year
Full expressions are not implimented
but you can do stuff like SM(*-7)+3
and it will return the 3rd day after
@@ -151,10 +151,10 @@ today.
CDate result=0;
CDateStruct ds,ds_now;
U8 *src=MStrUtil(_src,SUF_REM_SPACES|SUF_TO_UPPER),
*v=StrNew(src),
*ptr=src;
*v=StrNew(src),
*ptr=src;
Bool start_mon=FALSE,end_mon=FALSE,
start_year=FALSE,end_year=FALSE;
start_year=FALSE,end_year=FALSE;
MemSet(&ds,0,sizeof(CDateStruct));
if (!StrNCmp(ptr,"SM(",3)) {
Kernel/Task.CPP
+91 -88
View File
@@ -19,7 +19,7 @@ U0 Exit()
Bool TaskValidate(CTask *task)
{//return TRUE if task looks valid.
if (!(0<task<=MAX_I32) || task->addr!=task ||
task->task_signature(I64)!=TASK_COMBINED_SIGNATURE_VAL)
task->task_signature!=TASK_SIGNATURE_VAL)
return FALSE;
else
return TRUE;
@@ -28,7 +28,7 @@ Bool TaskValidate(CTask *task)
Bool Kill(CTask *task,Bool wait=TRUE)
{//Terminate other task.
I64 i;
Bool old_preempt=Preempt(OFF);
Bool old_preempt=Preempt;
if (TaskValidate(task) && task!=sys_winmgr_task) {
for (i=0;i<mp_cnt;i++)
if (task==cpu_structs[i].seth_task)
@@ -79,7 +79,8 @@ CTaskStk *TaskStkNew(I64 stk_size,CTask *task)
}
#exe {OptOn(OPTf_NO_REG_VAR);};
argpop I64 CallStkGrow(I64 stk_size_threshold,I64 stk_size,/*argpop*/I64 (*fp_addr)(...),...)
argpop I64 CallStkGrow(I64 stk_size_threshold,I64 stk_size,
/*argpop*/I64 (*fp_addr)(...),...)
{//Grow stk in call with any fixed num of args.
//See $LK,"::/Demo/StkGrow.CPP"$.
CTaskStk *temps,*temps2,**_stk;
@@ -87,15 +88,15 @@ argpop I64 CallStkGrow(I64 stk_size_threshold,I64 stk_size,/*argpop*/I64 (*fp_ad
if (UnusedStk>=stk_size_threshold) {
asm {
LEAVE
POP RAX //return addr
ADD RSP,16 //pop threshold,stk_size
POP RBX // *f
ADD RSP,8 //pop ARGC
PUSH RAX
JMP RBX //CALL fp_addr()
};
asm {
LEAVE
POP RAX //return addr
ADD RSP,16 //pop threshold,stk_size
POP RBX // *f
ADD RSP,8 //pop ARGC
PUSH RAX
JMP RBX //CALL fp_addr()
};
} else {
@@ -107,43 +108,43 @@ asm {
*--rsp2=*--rsp;
_stk=&Fs->stk;
temps->stk_ptr=rsp=GetRSP;
asm {
IMPORT _FREE; //We are in a function, not at glbl scope.
//The compiler treats these in isolation.
asm {
IMPORT _FREE; //We are in a function, not at glbl scope.
//The compiler treats these in isolation.
PUSHFD
POP RDX //flags
CLI
MOV RBX,U64 &temps2[RBP]
MOV RAX,&_stk[RBP]
MOV U64 [RAX],RBX //Fs->stk=temps2
MOV RSP,U64 &rsp2[RBP]
PUSH RDX
POPFD
PUSHFD
POP RDX //flags
CLI
MOV RBX,U64 &temps2[RBP]
MOV RAX,&_stk[RBP]
MOV U64 [RAX],RBX //Fs->stk=temps2
MOV RSP,U64 &rsp2[RBP]
PUSH RDX
POPFD
CALL U64 &fp_addr[RBP]
MOV U64 &result[RBP],RAX
CALL U64 &fp_addr[RBP]
MOV U64 &result[RBP],RAX
PUSHFD
POP RDX //flags
CLI
MOV RBX,U64 &temps[RBP]
MOV RAX,&_stk[RBP]
MOV U64 [RAX],RBX //Fs->stk=temps
MOV RSP,U64 &rsp[RBP]
PUSH RDX
POPFD
PUSHFD
POP RDX //flags
CLI
MOV RBX,U64 &temps[RBP]
MOV RAX,&_stk[RBP]
MOV U64 [RAX],RBX //Fs->stk=temps
MOV RSP,U64 &rsp[RBP]
PUSH RDX
POPFD
PUSH U64 &temps2[RBP]
CALL _FREE
PUSH U64 &temps2[RBP]
CALL _FREE
MOV RDX,U64 &old_stk[RBP]
MOV RBX,U64 8[RBP]
MOV RAX,U64 &result[RBP]
MOV RBP,U64 [RBP]
MOV RSP,RDX
JMP RBX //return
};
MOV RDX,U64 &old_stk[RBP]
MOV RBX,U64 8[RBP]
MOV RAX,U64 &result[RBP]
MOV RBP,U64 [RBP]
MOV RSP,RDX
JMP RBX //return
};
}
return 0; //dummy to get rid of warning
}
@@ -159,16 +160,16 @@ I64 TaskInit(CTask *task,I64 stk_size)
QueInit(&task->data_heap->next_mem_blk);
task->addr=task->next_task=task->last_task=
task->next_input_filter_task=task->last_input_filter_task=
task;
task->next_input_filter_task=task->last_input_filter_task=
task;
task->task_num=sys_num_spawned_tasks++;
task->rflags=SYS_NORMAL_RFLAGS;
task->rflags=RFLAGG_NORMAL;
task->win_inhibit=WIG_TASK_DFT;
task->next_child_task=task->last_child_task=
(&task->next_child_task)(U8 *)-offset(CTask.next_sibling_task);
(&task->next_child_task)(U8 *)-offset(CTask.next_sibling_task);
SrvCtrlInit(&task->srv_ctrl);
QueInit(&task->next_lex);
@@ -177,7 +178,8 @@ I64 TaskInit(CTask *task,I64 stk_size)
QueInit(&task->next_ode);
task->fpu_mmx=MAllocAligned(sizeof(CFPU),0x10,task);
MemCpy(task->fpu_mmx,SYS_FIXED_AREA+offset(CSysFixedArea.init_fpu_mmx),sizeof(CFPU));
MemCpy(task->fpu_mmx,
SYS_FIXED_AREA+offset(CSysFixedArea.init_fpu_mmx),sizeof(CFPU));
task->hash_table=HashTableNew(TASK_HASH_SIZE,task);
@@ -195,7 +197,7 @@ I64 TaskInit(CTask *task,I64 stk_size)
task->win_top =13;
task->win_bottom =text.rows-2;
if (dsk.boot_drv_let) //Beware Adam $LK,"TaskInit",A="FF:::/Kernel/KStart.CPP,TaskInit"$. Okay, I guess, until $LK,"ChgDsk",A="FF:::/Kernel/KEnd.CPP,ChgDsk"$().
if (dsk.boot_drv_let) //Beware Adam $LK,"TaskInit",A="FF:::/Kernel/KStart.CPP,TaskInit"$. I guess ok until $LK,"ChgDsk",A="FF:::/Kernel/KEnd.CPP,ChgDsk"$().
task->cur_dv=dsk.let_to_drv[ToUpper(dsk.boot_drv_let)-'A'];
task->cur_dir=StrNew("/Home",task);
@@ -204,18 +206,18 @@ I64 TaskInit(CTask *task,I64 stk_size)
return task;
}
CTask *Spawn(U0 (*fp_start_addr)(U8 *data),U8 *data=NULL,
U8 *task_name=NULL,
I64 target_cpu=-1, //-1 means current CPU. See $LK,"multi-core",A="FI:::/Demo/MultiCore/LoadTest.CPP"$.
CTask *parent=NULL, //NULL means adam
I64 stk_size=0, //0=default
I64 flags=1<<SVCf_ADD_TO_QUE)
CTask *Spawn(U0 (*fp_start_addr)(U8 *data),U8 *data=NULL,U8 *task_name=NULL,
I64 target_cpu=-1, //-1 for current CPU. See $LK,"multi-core",A="FI:::/Demo/MultiCore/LoadTest.CPP"$.
CTask *parent=NULL, //NULL means adam
I64 stk_size=0, //0=default
I64 flags=1<<SVCf_ADD_TO_QUE)
{//Create task on core running at address.
//Alloc $LK,"CTask",A="MN:CTask"$ structure from code heap so addr will be short.
//Could be alloced off of data heap.
//Could be alloced off of data heap.
CTask *task;
if (target_cpu>=0)
return SpawnQue(fp_start_addr,data,task_name,target_cpu,parent,stk_size,flags);
return SpawnQue(fp_start_addr,data,task_name,target_cpu,
parent,stk_size,flags);
task=CAlloc(sizeof(CTask),adam_task->code_heap);
task->task_signature=TASK_SIGNATURE_VAL;
if (!task_name) task_name="Unnamed Task";
@@ -264,23 +266,23 @@ U0 TaskDerivedValsUpdate(CTask *task=NULL,Bool update_z_buf=TRUE)
POPFD
}
I64 ExeCmdLine(CLex *lx)
{//Terminal JIT-compile-and-execute loop for CLex.
I64 ExeCmdLine(CCmpCtrl *cc)
{//Terminal JIT-compile-and-execute loop for CCmpCtrl.
I64 result=0,type,old_title_src=Fs->title_src;
U8 *ptr,*ptr2,*ptr3,*ex,*old_task_title=StrNew(Fs->task_title);
U8 *ptr,*ptr2,*ptr3,*machine_code,*old_task_title=StrNew(Fs->task_title);
F64 t0;
CDocEntry *doc_e;
CDoc *doc;
if (Fs->title_src!=TTS_LOCKED_CONST)
Fs->title_src=TTS_CUR_LEX;
while (lx->token &&
(lx->token!='}' || !(lx->flags & LF_EXE_BLK)) ) {
while (cc->token &&
(cc->token!='}' || !(cc->flags & CCF_EXE_BLK)) ) {
if (Fs->title_src==TTS_CUR_LEX) {
ptr2=&Fs->task_title;
ptr3=ptr2+TASK_TITLE_LEN;
if (lx->cur_lfn->flags & LFSF_DOC) {
doc_e=lx->cur_lfn->cur_entry;
doc=lx->cur_lfn->doc;
if (cc->lex_include_stk->flags & LFSF_DOC) {
doc_e=cc->lex_include_stk->cur_entry;
doc=cc->lex_include_stk->doc;
while (doc_e!=doc && ptr2<ptr3) {
switch (doc_e->type_u8) {
case DOCT_TEXT:
@@ -297,21 +299,22 @@ I64 ExeCmdLine(CLex *lx)
}
if (ptr2<ptr3) *ptr2=0;
} else
if ((ptr=lx->cur_lfn->line_start) && *ptr)
if ((ptr=cc->lex_include_stk->line_start) && *ptr)
MemCpy(ptr2,ptr,TASK_TITLE_LEN);
}
lx->flags&=~LF_HAS_MISC_DATA;
ex=LexStatement2Bin(lx,&type);
if (ex!=INVALID_PTR) {
if (!(lx->flags&LF_JUST_LOAD)) {
cc->flags&=~CCF_HAS_MISC_DATA;
machine_code=LexStatement2Bin(cc,&type);
if (machine_code!=INVALID_PTR) {
if (!(cc->flags&CCF_JUST_LOAD)) {
t0=tS;
result=Call(ex);
result=Call(machine_code);
Fs->answer=result;
Fs->answer_type=type;
Fs->answer_time=tS-t0;
Fs->new_answer=TRUE;
}
if (!(lx->flags&LF_HAS_MISC_DATA))
Free(ex);
if (!(cc->flags&CCF_HAS_MISC_DATA))
Free(machine_code);
}
}
if (Fs->title_src!=TTS_LOCKED_CONST) {
@@ -319,8 +322,8 @@ I64 ExeCmdLine(CLex *lx)
StrCpy(Fs->task_title,old_task_title);
}
Free(old_task_title);
if (lx->flags&LF_JUST_LOAD) {
if (lx->error_cnt)
if (cc->flags&CCF_JUST_LOAD) {
if (cc->error_cnt)
return FALSE;
else
return TRUE;
@@ -330,18 +333,18 @@ I64 ExeCmdLine(CLex *lx)
U0 UserTaskCont()
{//Terminal key-input-execute loop.
CLex *lx;
CCmpCtrl *cc;
CDoc *doc;
Bool cont=TRUE;
do {
lx=LexNew(,LF_PMT);
QueIns(lx,Fs->last_lex);
cc=CmpCtrlNew(,CCF_PMT);
QueIns(cc,Fs->last_lex);
try {
Lex(lx);
ExeCmdLine(lx);
cont=Bt(&lx->flags,Lf_PMT);
QueRem(lx);
LexDel(lx);
Lex(cc);
ExeCmdLine(cc);
cont=Bt(&cc->flags,CCf_PMT);
QueRem(cc);
CmpCtrlDel(cc);
} catch {
if ((doc=Fs->put_doc) && doc->doc_signature==DOC_SIGNATURE_VAL)
DocUnlock(doc);
@@ -459,7 +462,7 @@ I64 TaskEnd()
(*fp_set_std_palette)();
}
//QueRem
//QueRem
task->task_signature(I64)=0;
tempt =task->next_input_filter_task;
@@ -484,9 +487,9 @@ I64 TaskEnd()
} else
TaskFinishOff(task); //dangerous (stk in use)
//Never happens--winmgr exists except during boot and no tasks die during boot
//currently, though this has been different and might be different in future.
//Would have to be multicore task getting this task's memory
//because IRQs are off, so no tasks on this core run.
//currently, though this has been different and might be different in
//future. Would have to be multicore task getting this task's memory
//because IRQs are off, so no tasks on this core run.
return tempt;
}