mirror of
https://github.com/Zeal-Operating-System/ZealOS.git
synced 2025-04-18 05:38:36 +01:00
Cpy -> Copy, Cmp -> Compare, Mem -> Memory
This commit is contained in:
parent
38e3210ec0
commit
2633ccc3c4
174 changed files with 676 additions and 677 deletions
src
0000Boot
Apps
Budget
GrModels
Psalmody
Span
TimeClock
ToTheFront
X-Caliber
Compiler
Asm.HCAsmInit.HCBackFA.HCCHash.HCCMain.HCCMisc.HCCompiler.BINLex.HCLexLib.HCOptPass3.HCOptPass789A.HCParseExp.HCParseLib.HCParseStatement.HCParseVar.HCUAsm.HC
Demo
AcctExample
DolDoc
Games
Graphics
Lectures
MagicPairs.HCMultiCore
PhoneNumWords.HCProgress.HCSound
SuggestSpelling.HCToHtmlToTXTDemo
WebLogDemo
WordSearch.HCDoc
HomeKeyPlugIns.HCKernel.BIN.CKernel
BlkDev
DiskATA.HCDiskBlk.HCDiskCDDVD.HCDiskCFile.HCDiskCache.HCDiskCopy.HCDiskDirA.HCDiskDirB.HCDiskDirContext.HCDiskFile.HCDiskFind.HCDiskStrA.HCDiskStrB.HCFileSysFAT.HCFileSysRedSea.HC
Compress.HCDisplay.HCEdLite.HCFunSeg.HCKConfig.HCKDebug.HCKDefine.HCKHashB.HCKLoad.HCKMain.HCKTask.HCKUtils.HCKernel.MAPKernel.PRJKernelB.HHKernelC.HHKeyDev.HC
Binary file not shown.
|
@ -67,7 +67,7 @@ U8 *BgtPopUpAcct(U8 *header=NULL,U8 *default=NULL)
|
|||
while (tmph) {
|
||||
doc_e=DocPrint(doc,"$$FG,%d$$$$MU-UL,\"%s\",LE=0x%X$$\n",
|
||||
tmph->user_data1,tmph->str,tmph->str);
|
||||
if (default && !StrCmp(default,tmph->str))
|
||||
if (default && !StrCompare(default,tmph->str))
|
||||
doc_default=doc_e;
|
||||
tmph=tmph->next;
|
||||
}
|
||||
|
|
|
@ -10,7 +10,7 @@ U0 BgtEntryDel2(CBgtEntry *tmpb)
|
|||
CBgtEntry *BgtEntryCopy(CBgtEntry *tmpb,Bool periodic_copy)
|
||||
{
|
||||
CBgtEntry *res=MAlloc(sizeof(CBgtEntry));
|
||||
MemCpy(res,tmpb,sizeof(CBgtEntry));
|
||||
MemCopy(res,tmpb,sizeof(CBgtEntry));
|
||||
if (periodic_copy) {
|
||||
res->credit=StrNew(tmpb->credit);
|
||||
res->debit =StrNew(tmpb->debit);
|
||||
|
@ -48,24 +48,24 @@ CBgtEntry *BgtEntryPrompt(CBgtEntry *default=NULL)
|
|||
CBgtEntry *tmpb;
|
||||
U8 *st;
|
||||
MemSet(&b,0,sizeof(CBgtEntryForm));
|
||||
StrCpy(&b.date,"*");
|
||||
StrCopy(&b.date,"*");
|
||||
if (default) {
|
||||
StrPrint(b.date,"%D",default->date);
|
||||
b.amount=default->amount;
|
||||
StrCpy(b.credit,default->credit);
|
||||
StrCpy(b.debit ,default->debit);
|
||||
StrCpy(b.desc ,default->desc);
|
||||
StrCopy(b.credit,default->credit);
|
||||
StrCopy(b.debit ,default->debit);
|
||||
StrCopy(b.desc ,default->desc);
|
||||
}
|
||||
while (TRUE)
|
||||
if (PopUpForm(&b)) {
|
||||
if (!*b.credit) {
|
||||
st=BgtPopUpAcct("Credit Acct\n\n");
|
||||
if (st!=DOCM_CANCEL)
|
||||
StrCpy(b.credit,st);
|
||||
StrCopy(b.credit,st);
|
||||
} else if (!*b.debit) {
|
||||
st=BgtPopUpAcct("Debit Acct\n\n");
|
||||
if (st!=DOCM_CANCEL)
|
||||
StrCpy(b.debit,st);
|
||||
StrCopy(b.debit,st);
|
||||
} else {
|
||||
tmpb=CAlloc(sizeof(CBgtEntry));
|
||||
tmpb->date =Str2Date(b.date);
|
||||
|
|
|
@ -18,7 +18,7 @@ U0 BgtDataRead()
|
|||
count=*ptr(I64 *)++;
|
||||
for (i=0;i<count;i++) {
|
||||
tmpb=CAlloc(sizeof(CBgtEntry));
|
||||
MemCpy(&tmpb->start,ptr,BE_SIZE);
|
||||
MemCopy(&tmpb->start,ptr,BE_SIZE);
|
||||
tmpb->credit=StrNew(s[tmpb->credit_idx]);
|
||||
tmpb->debit =StrNew(s[tmpb->debit_idx]);
|
||||
tmpb->desc =StrNew(s[tmpb->desc_idx]);
|
||||
|
@ -29,9 +29,9 @@ U0 BgtDataRead()
|
|||
count=*ptr(I64 *)++;
|
||||
for (i=0;i<count;i++) {
|
||||
tmpt=CAlloc(sizeof(CBgtTemplate));
|
||||
MemCpy(&tmpt->start,ptr,BT_SIZE);
|
||||
MemCopy(&tmpt->start,ptr,BT_SIZE);
|
||||
ptr+=BT_SIZE;
|
||||
MemCpy(&tmpt->b.start,ptr,BE_SIZE);
|
||||
MemCopy(&tmpt->b.start,ptr,BE_SIZE);
|
||||
ptr+=BE_SIZE;
|
||||
tmpt->b.credit=StrNew(s[tmpt->b.credit_idx]);
|
||||
tmpt->b.debit =StrNew(s[tmpt->b.debit_idx]);
|
||||
|
@ -90,24 +90,24 @@ U0 BgtDataWrite()
|
|||
size=sizeof(I64)*2+count1*BE_SIZE+count2*(BT_SIZE+BE_SIZE);
|
||||
buf=ptr=MAlloc(size);
|
||||
|
||||
MemCpy(ptr,&count1,sizeof(I64));
|
||||
MemCopy(ptr,&count1,sizeof(I64));
|
||||
ptr+=sizeof(I64);
|
||||
tmpb=b_head.next;
|
||||
while (tmpb!=&b_head) {
|
||||
if (tmpb->type!=BE_TEMPLATE_COPY) {
|
||||
MemCpy(ptr,&tmpb->start,BE_SIZE);
|
||||
MemCopy(ptr,&tmpb->start,BE_SIZE);
|
||||
ptr+=BE_SIZE;
|
||||
}
|
||||
tmpb=tmpb->next;
|
||||
}
|
||||
|
||||
MemCpy(ptr,&count2,sizeof(I64));
|
||||
MemCopy(ptr,&count2,sizeof(I64));
|
||||
ptr+=sizeof(I64);
|
||||
tmpt=t_head.next;
|
||||
while (tmpt!=&t_head) {
|
||||
MemCpy(ptr,&tmpt->start,BT_SIZE);
|
||||
MemCopy(ptr,&tmpt->start,BT_SIZE);
|
||||
ptr+=BT_SIZE;
|
||||
MemCpy(ptr,&tmpt->b.start,BE_SIZE);
|
||||
MemCopy(ptr,&tmpt->b.start,BE_SIZE);
|
||||
ptr+=BE_SIZE;
|
||||
tmpt=tmpt->next;
|
||||
}
|
||||
|
|
|
@ -57,7 +57,7 @@ Bool BgtPutKey(CDoc *doc,U8 *,I64 ch,I64 sc)
|
|||
return TRUE;
|
||||
case 'v':
|
||||
if ((st=BgtPopUpAcct("View Acct\n\n",view_acct))>=0) {
|
||||
StrCpy(view_acct,st);
|
||||
StrCopy(view_acct,st);
|
||||
BgtRegen;
|
||||
}
|
||||
return TRUE;
|
||||
|
@ -110,9 +110,9 @@ U0 BgtRegen()
|
|||
doc=DocNew;
|
||||
doc->flags|=DOCF_FORM;
|
||||
while (tmpb!=&b_head) {
|
||||
if (!StrCmp(view_acct,tmpb->credit))
|
||||
if (!StrCompare(view_acct,tmpb->credit))
|
||||
balance-=tmpb->amount;
|
||||
if (!StrCmp(view_acct,tmpb->debit))
|
||||
if (!StrCompare(view_acct,tmpb->debit))
|
||||
balance+=tmpb->amount;
|
||||
c=BgtAcctColor(tmpb->credit);
|
||||
if (c!=color) {
|
||||
|
@ -201,7 +201,7 @@ U0 Budget(U8 *dirname="~/Budget")
|
|||
" ViewAcct(,'v');"
|
||||
"}"
|
||||
);
|
||||
StrCpy(view_acct,"BANK");
|
||||
StrCopy(view_acct,"BANK");
|
||||
DocMax;
|
||||
old_put =Fs->put_doc;
|
||||
old_display =Fs->display_doc;
|
||||
|
|
|
@ -156,23 +156,23 @@ CBgtTemplate *BgtTemplatePrompt(CBgtTemplate *default_t=NULL,CBgtEntry *default_
|
|||
CBgtEntry *tmpb;
|
||||
MemSet(&t,0,sizeof(CBgtTemplate));
|
||||
if (default_t) {
|
||||
MemCpy(&t.start,&default_t->start,BT_SIZE);
|
||||
MemCopy(&t.start,&default_t->start,BT_SIZE);
|
||||
default_b=&default_t->b;
|
||||
} else {
|
||||
t.type=BT_INTERVAL;
|
||||
if (default_b)
|
||||
StrPrint(&t.start_date,"%D",default_b->date);
|
||||
else
|
||||
StrCpy(&t.start_date,"[");
|
||||
StrCpy(&t.end_date,"]");
|
||||
StrCopy(&t.start_date,"[");
|
||||
StrCopy(&t.end_date,"]");
|
||||
}
|
||||
while (TRUE)
|
||||
if (PopUpForm(&t) && ((t.type==BT_INTERVAL && t.period>0) ||
|
||||
t.type>BT_INTERVAL)) {
|
||||
if (tmpb=BgtEntryPrompt(default_b)) {
|
||||
tmpt=CAlloc(sizeof(CBgtTemplate));
|
||||
MemCpy(&tmpt->start,&t.start,BT_SIZE);
|
||||
MemCpy(&tmpt->b,tmpb,sizeof(CBgtEntry));
|
||||
MemCopy(&tmpt->start,&t.start,BT_SIZE);
|
||||
MemCopy(&tmpt->b,tmpb,sizeof(CBgtEntry));
|
||||
Free(tmpb);
|
||||
return tmpt;
|
||||
}
|
||||
|
|
|
@ -65,9 +65,9 @@ U8 *Ball2CSprite()
|
|||
*dst++ =SPT_MESH;
|
||||
*dst(I32 *)++ =b->vertex_count;
|
||||
*dst(I32 *)++ =b->tri_count;
|
||||
MemCpy(dst,&b->v,b->vertex_count*sizeof(CD3I32));
|
||||
MemCopy(dst,&b->v,b->vertex_count*sizeof(CD3I32));
|
||||
dst+=b->vertex_count*sizeof(CD3I32);
|
||||
MemCpy(dst,&b->t,b->tri_count*sizeof(CMeshTri));
|
||||
MemCopy(dst,&b->t,b->tri_count*sizeof(CMeshTri));
|
||||
dst+=b->tri_count*sizeof(CMeshTri);
|
||||
*dst++ =SPT_END;
|
||||
return res;
|
||||
|
@ -85,7 +85,7 @@ public U8 *BallGen()
|
|||
while (TRUE) {
|
||||
if (!DocForm(&bd1))
|
||||
return NULL;
|
||||
MemCpy(&bd2,&bd1,sizeof(BallDefineStruct));
|
||||
MemCopy(&bd2,&bd1,sizeof(BallDefineStruct));
|
||||
BDCorrect(&bd2);
|
||||
|
||||
c=PopUpColorLighting;
|
||||
|
|
|
@ -219,9 +219,9 @@ U8 *Man2CSprite()
|
|||
*dst++ =SPT_MESH;
|
||||
*dst(I32 *)++ =m->vertex_count;
|
||||
*dst(I32 *)++ =m->tri_count;
|
||||
MemCpy(dst,&m->v,m->vertex_count*sizeof(CD3I32));
|
||||
MemCopy(dst,&m->v,m->vertex_count*sizeof(CD3I32));
|
||||
dst+=m->vertex_count*sizeof(CD3I32);
|
||||
MemCpy(dst,&m->t,m->tri_count*sizeof(CMeshTri));
|
||||
MemCopy(dst,&m->t,m->tri_count*sizeof(CMeshTri));
|
||||
dst+=m->tri_count*sizeof(CMeshTri);
|
||||
*dst++ =SPT_END;
|
||||
return res;
|
||||
|
@ -237,7 +237,7 @@ public U8 *ManGen()
|
|||
while (TRUE) {
|
||||
if (!DocForm(&md1))
|
||||
return NULL;
|
||||
MemCpy(&md2,&md1,sizeof(ManDefineStruct));
|
||||
MemCopy(&md2,&md1,sizeof(ManDefineStruct));
|
||||
MDCorrect(&md2);
|
||||
|
||||
c1=PopUpColorLighting("$$BK,1$$Shirt$$BK,0$$\n");
|
||||
|
|
|
@ -3,7 +3,7 @@ CTask *JukeReward(U8 *message)
|
|||
U8 *buf;
|
||||
CDoc *doc;
|
||||
CTask *res=Spawn(&SrvCmdLine,NULL,"Reward",,Fs);
|
||||
StrCpy(res->task_title,"Reward");
|
||||
StrCopy(res->task_title,"Reward");
|
||||
res->title_src=TTS_LOCKED_CONST;
|
||||
|
||||
doc=DocNew(,res);
|
||||
|
@ -28,7 +28,7 @@ CTask *JukeReward(U8 *message)
|
|||
CTask *SingleSong(U8 *message,U8 *name)
|
||||
{
|
||||
CTask *task=Spawn(&SrvCmdLine,NULL,name,,Fs);
|
||||
StrCpy(task->task_title,name);
|
||||
StrCopy(task->task_title,name);
|
||||
task->title_src=TTS_LOCKED_CONST;
|
||||
TaskExe(task,Fs,";",1<<JOBf_WAKE_MASTER|1<<JOBf_FREE_ON_COMPLETE);
|
||||
WinHorz(task->win_left,task->win_left+50,task);
|
||||
|
|
|
@ -50,7 +50,7 @@ U0 JukeSongPuppet(CTask *juke_task,I64 passes,I64 song_num,U8 *name)
|
|||
found=FALSE;
|
||||
task=Fs->next_task;
|
||||
while (task!=Fs) {
|
||||
if (!StrCmp(task->task_title,name)) {
|
||||
if (!StrCompare(task->task_title,name)) {
|
||||
found=TRUE;
|
||||
break;
|
||||
}
|
||||
|
|
|
@ -207,7 +207,7 @@ U0 PsmLoadSong(U8 *filename,I64 *psm_octave,F64 *psm_duration)
|
|||
psm.incomplete_entry->checked=FALSE;
|
||||
while (Lex(cc)) {
|
||||
if (cc->token==TK_IDENT)
|
||||
if (!StrCmp(cc->cur_str,"Play")) {
|
||||
if (!StrCompare(cc->cur_str,"Play")) {
|
||||
if (Lex(cc)=='(')
|
||||
if (Lex(cc)==TK_STR) {
|
||||
tmpn=psm.head.last;
|
||||
|
@ -226,14 +226,14 @@ U0 PsmLoadSong(U8 *filename,I64 *psm_octave,F64 *psm_duration)
|
|||
}
|
||||
}
|
||||
}
|
||||
} else if (!StrCmp(cc->cur_str,"music") &&
|
||||
} else if (!StrCompare(cc->cur_str,"music") &&
|
||||
Lex(cc)=='.' && Lex(cc)==TK_IDENT) {
|
||||
if (!StrCmp(cc->cur_str,"tempo")) {
|
||||
if (!StrCompare(cc->cur_str,"tempo")) {
|
||||
if (Lex(cc)=='=' && Lex(cc)==TK_F64) {
|
||||
music.tempo=cc->cur_f64-0.0005;
|
||||
tempo_state.tempo=Round(TEMPO_RANGE*(music.tempo-0.5)/4.4);
|
||||
}
|
||||
} else if (!StrCmp(cc->cur_str,"stacatto_factor")) {
|
||||
} else if (!StrCompare(cc->cur_str,"stacatto_factor")) {
|
||||
if (Lex(cc)=='=' && Lex(cc)==TK_F64) {
|
||||
music.stacatto_factor=cc->cur_f64-0.0005;
|
||||
tempo_state.stacatto=
|
||||
|
@ -307,7 +307,7 @@ U8 *PsmCvtSong()
|
|||
dst=st;
|
||||
tmpn=psm.head.next;
|
||||
while (tmpn!=&psm.head) {
|
||||
StrCpy(dst,tmpn->ascii);
|
||||
StrCopy(dst,tmpn->ascii);
|
||||
dst+=StrLen(tmpn->ascii);
|
||||
tmpn=tmpn->next;
|
||||
}
|
||||
|
|
|
@ -44,19 +44,19 @@ U8 *SpanSave(CMathODE *ode,I64 *_size=NULL)
|
|||
count=sizeof(SpanHeader)+h.num_masses*M_SIZE+h.num_springs*S_SIZE;
|
||||
|
||||
ptr=res=MAlloc(count);
|
||||
MemCpy(ptr,&h,sizeof(SpanHeader));
|
||||
MemCopy(ptr,&h,sizeof(SpanHeader));
|
||||
ptr+=sizeof(SpanHeader);
|
||||
|
||||
tmpm=ode->next_mass;
|
||||
while (tmpm!=&ode->next_mass) {
|
||||
MemCpy(ptr,&tmpm->start,M_SIZE);
|
||||
MemCopy(ptr,&tmpm->start,M_SIZE);
|
||||
ptr+=M_SIZE;
|
||||
tmpm=tmpm->next;
|
||||
}
|
||||
|
||||
tmps=ode->next_spring;
|
||||
while (tmps!=&ode->next_spring) {
|
||||
MemCpy(ptr,&tmps->start,S_SIZE);
|
||||
MemCopy(ptr,&tmps->start,S_SIZE);
|
||||
ptr+=S_SIZE;
|
||||
tmps=tmps->next;
|
||||
}
|
||||
|
@ -91,19 +91,19 @@ U0 SpanLoad(CMathODE *ode,U8 *src)
|
|||
|
||||
if (!src) return;
|
||||
|
||||
MemCpy(&h,src,sizeof(SpanHeader));
|
||||
MemCopy(&h,src,sizeof(SpanHeader));
|
||||
src+=sizeof(SpanHeader);
|
||||
|
||||
for (i=0;i<h.num_masses;i++) {
|
||||
tmpm=CAlloc(sizeof(MyMass));
|
||||
MemCpy(&tmpm->start,src,M_SIZE);
|
||||
MemCopy(&tmpm->start,src,M_SIZE);
|
||||
src+=M_SIZE;
|
||||
QueueInsert(tmpm,ode->last_mass);
|
||||
}
|
||||
|
||||
for (i=0;i<h.num_springs;i++) {
|
||||
tmps=CAlloc(sizeof(MySpring));
|
||||
MemCpy(&tmps->start,src,S_SIZE);
|
||||
MemCopy(&tmps->start,src,S_SIZE);
|
||||
src+=S_SIZE;
|
||||
QueueInsert(tmps,ode->last_spring);
|
||||
tmps->end1=MassFindNum(ode,tmps->end1_num);
|
||||
|
|
|
@ -51,7 +51,7 @@ U0 TimeFileWrite(TimeEntry *header)
|
|||
while (tmpt!=header) {
|
||||
*ptr++=tmpt->type;
|
||||
*ptr(CDate *)++=tmpt->datetime;
|
||||
StrCpy(ptr,tmpt->desc);
|
||||
StrCopy(ptr,tmpt->desc);
|
||||
ptr+=StrLen(tmpt->desc)+1;
|
||||
tmpt=tmpt->next;
|
||||
}
|
||||
|
|
|
@ -180,7 +180,7 @@ U0 ToTheFront()
|
|||
if (res=='GameOver') {
|
||||
while (TRUE) {
|
||||
message_off_timeout=0;
|
||||
StrCpy(message_buf,"Game Over");
|
||||
StrCopy(message_buf,"Game Over");
|
||||
Sound;
|
||||
ch=GetChar(,FALSE);
|
||||
if (ch=='\n') {
|
||||
|
|
|
@ -148,9 +148,9 @@ U0 MissileNew(Ship *tmpsp,I64 n)
|
|||
D3Copy(&tmpmi->p_back.x,&tmpmi->p_front.x);
|
||||
|
||||
if (n&1)
|
||||
StrCpy(tmpmi->label,"L");
|
||||
StrCopy(tmpmi->label,"L");
|
||||
else
|
||||
StrCpy(tmpmi->label,"R");
|
||||
StrCopy(tmpmi->label,"R");
|
||||
tmpmi->owner=tmpsp;
|
||||
tmpmi->tons=0.5;
|
||||
tmpmi->p_front.mass=0.1;
|
||||
|
|
|
@ -489,7 +489,7 @@ Bool ParseAsmInst(CCompCtrl *cc,CHashOpcode *tmpo,I64 argcount)
|
|||
if (tmpa1->imm_or_off_present && tmpa1->indirect &&
|
||||
tmpa1->reg1==REG_NONE) {
|
||||
cur.ModrM=cur.ModrM+5;
|
||||
MemCpy(&cur.disp.num,&tmpa1->num,sizeof(CAsmNum));
|
||||
MemCopy(&cur.disp.num,&tmpa1->num,sizeof(CAsmNum));
|
||||
cur.disp.U8_count=4;
|
||||
if (aotc->seg_size==64)
|
||||
cur.disp.imm_flag=FALSE;
|
||||
|
@ -518,7 +518,7 @@ Bool ParseAsmInst(CCompCtrl *cc,CHashOpcode *tmpo,I64 argcount)
|
|||
cur.REX|=2;
|
||||
if (tmpa1->reg1>=20) //RBPu8,RSPu8,RSIu8,RDIu8?
|
||||
cur.has_REX=TRUE;
|
||||
MemCpy(&cur.disp.num,&tmpa1->num,sizeof(CAsmNum));
|
||||
MemCopy(&cur.disp.num,&tmpa1->num,sizeof(CAsmNum));
|
||||
cur.disp.U8_count=4;
|
||||
} else {
|
||||
cur.SIB|=(tmpa1->reg1&7)<<3+tmpa1->reg2&7;
|
||||
|
@ -540,7 +540,7 @@ Bool ParseAsmInst(CCompCtrl *cc,CHashOpcode *tmpo,I64 argcount)
|
|||
}
|
||||
if (!ModrM_complete) {
|
||||
if (tmpa1->imm_or_off_present) {
|
||||
MemCpy(&cur.disp.num,&tmpa1->num,sizeof(CAsmNum));
|
||||
MemCopy(&cur.disp.num,&tmpa1->num,sizeof(CAsmNum));
|
||||
if (!cur.disp.num.machine_code &&
|
||||
I8_MIN<=cur.disp.num.i<=I8_MAX) {
|
||||
cur.ModrM|=0x40;
|
||||
|
@ -567,7 +567,7 @@ Bool ParseAsmInst(CCompCtrl *cc,CHashOpcode *tmpo,I64 argcount)
|
|||
ARGT_UIMM8<=arg1<=ARGT_UIMM64) {
|
||||
if (arg1==ARGT_IMM64 || arg2==ARGT_UIMM64)
|
||||
cur.REX|=8;
|
||||
MemCpy(&cur.imm.num,&tmpa1->num,sizeof(CAsmNum));
|
||||
MemCopy(&cur.imm.num,&tmpa1->num,sizeof(CAsmNum));
|
||||
}
|
||||
} else if (argcount==2) {
|
||||
if (best.U8_count!=255 && !found_second_possible && !best.is_default) {
|
||||
|
@ -657,7 +657,7 @@ Bool ParseAsmInst(CCompCtrl *cc,CHashOpcode *tmpo,I64 argcount)
|
|||
cur.REX|=2;
|
||||
if (tmpa1->reg1>=20) //RBPu8,RSPu8,RSIu8,RDIu8?
|
||||
cur.has_REX=TRUE;
|
||||
MemCpy(&cur.disp.num,&tmpa1->num,sizeof(CAsmNum));
|
||||
MemCopy(&cur.disp.num,&tmpa1->num,sizeof(CAsmNum));
|
||||
cur.disp.U8_count=4;
|
||||
} else {
|
||||
cur.SIB|=(tmpa1->reg1&7)<<3+tmpa1->reg2&7;
|
||||
|
@ -681,13 +681,13 @@ Bool ParseAsmInst(CCompCtrl *cc,CHashOpcode *tmpo,I64 argcount)
|
|||
if (tmpa1->imm_or_off_present &&
|
||||
tmpa1->indirect && tmpa1->reg1==REG_NONE) {
|
||||
cur.ModrM=cur.ModrM&0xF8+5;
|
||||
MemCpy(&cur.disp.num,&tmpa1->num,sizeof(CAsmNum));
|
||||
MemCopy(&cur.disp.num,&tmpa1->num,sizeof(CAsmNum));
|
||||
cur.disp.U8_count=4;
|
||||
if (aotc->seg_size==64)
|
||||
cur.disp.imm_flag=FALSE;
|
||||
} else {
|
||||
if (tmpa1->imm_or_off_present) {
|
||||
MemCpy(&cur.disp.num,&tmpa1->num,sizeof(CAsmNum));
|
||||
MemCopy(&cur.disp.num,&tmpa1->num,sizeof(CAsmNum));
|
||||
if (!cur.disp.num.machine_code &&
|
||||
I8_MIN<=cur.disp.num.i<=I8_MAX) {
|
||||
cur.ModrM|=0x40;
|
||||
|
@ -711,14 +711,14 @@ Bool ParseAsmInst(CCompCtrl *cc,CHashOpcode *tmpo,I64 argcount)
|
|||
}
|
||||
}
|
||||
} else if (ARGT_MOFFS8<=arg1<=ARGT_MOFFS64) {
|
||||
MemCpy(&cur.disp.num,&tmpa1->num,sizeof(CAsmNum));
|
||||
MemCopy(&cur.disp.num,&tmpa1->num,sizeof(CAsmNum));
|
||||
if (aotc->seg_size==16)
|
||||
cur.disp.U8_count=2;
|
||||
else
|
||||
cur.disp.U8_count=4;
|
||||
cur.has_addr_prefix=FALSE;
|
||||
} else if (ARGT_MOFFS8<=arg2<=ARGT_MOFFS64) {
|
||||
MemCpy(&cur.disp.num,&tmpa2->num,sizeof(CAsmNum));
|
||||
MemCopy(&cur.disp.num,&tmpa2->num,sizeof(CAsmNum));
|
||||
if (aotc->seg_size==16)
|
||||
cur.disp.U8_count=2;
|
||||
else
|
||||
|
@ -726,7 +726,7 @@ Bool ParseAsmInst(CCompCtrl *cc,CHashOpcode *tmpo,I64 argcount)
|
|||
cur.has_addr_prefix=FALSE;
|
||||
} else if (ARGT_IMM8<=arg1<=ARGT_IMM64 ||
|
||||
ARGT_UIMM8<=arg1<=ARGT_UIMM64) {
|
||||
MemCpy(&cur.imm.num,&tmpa1->num,sizeof(CAsmNum));
|
||||
MemCopy(&cur.imm.num,&tmpa1->num,sizeof(CAsmNum));
|
||||
if (arg1==ARGT_IMM8 || arg1==ARGT_UIMM8) cur.imm.U8_count=1;
|
||||
else if (arg1==ARGT_IMM16 || arg1==ARGT_UIMM16) cur.imm.U8_count=2;
|
||||
else if (arg1==ARGT_IMM32 || arg1==ARGT_UIMM32) cur.imm.U8_count=4;
|
||||
|
@ -737,7 +737,7 @@ Bool ParseAsmInst(CCompCtrl *cc,CHashOpcode *tmpo,I64 argcount)
|
|||
}
|
||||
if (ARGT_IMM8<=arg2<=ARGT_IMM64 ||
|
||||
ARGT_UIMM8<=arg2<=ARGT_UIMM64) {
|
||||
MemCpy(&cur.imm.num,&tmpa2->num,sizeof(CAsmNum));
|
||||
MemCopy(&cur.imm.num,&tmpa2->num,sizeof(CAsmNum));
|
||||
if (arg2==ARGT_IMM8 || arg2==ARGT_UIMM8) cur.imm.U8_count=1;
|
||||
else if (arg2==ARGT_IMM16 || arg2==ARGT_UIMM16) cur.imm.U8_count=2;
|
||||
else if (arg2==ARGT_IMM32 || arg2==ARGT_UIMM32) {
|
||||
|
@ -762,7 +762,7 @@ Bool ParseAsmInst(CCompCtrl *cc,CHashOpcode *tmpo,I64 argcount)
|
|||
if (cur.U8_count<best.U8_count &&
|
||||
!(tmpins->flags & IEF_DONT_SWITCH_MODES &&
|
||||
(cur.has_addr_prefix || cur.has_operand_prefix)))
|
||||
MemCpy(&best,&cur,sizeof(CAsmIns));
|
||||
MemCopy(&best,&cur,sizeof(CAsmIns));
|
||||
}
|
||||
}
|
||||
if (best.U8_count<255) {
|
||||
|
|
|
@ -23,9 +23,9 @@ U0 AsmPrsInsFlags(CCompCtrl *cc,CInst *tmpins)
|
|||
if (Lex(cc)==TK_I64 && cc->cur_i64<8)
|
||||
tmpins->slash_val=cc->cur_i64;
|
||||
else if (cc->token==TK_IDENT) {
|
||||
if (!StrCmp(cc->cur_str,"R"))
|
||||
if (!StrCompare(cc->cur_str,"R"))
|
||||
tmpins->slash_val=SV_R_REG;
|
||||
else if (!StrCmp(cc->cur_str,"I"))
|
||||
else if (!StrCompare(cc->cur_str,"I"))
|
||||
tmpins->slash_val=SV_I_REG;
|
||||
else
|
||||
return;
|
||||
|
@ -153,7 +153,7 @@ U0 AsmHashLoad()
|
|||
}
|
||||
size=offset(CHashOpcode.ins)+sizeof(CInst)*tmpo_max->inst_entry_count;
|
||||
tmpo=MAlloc(size);
|
||||
MemCpy(tmpo,tmpo_max,size);
|
||||
MemCopy(tmpo,tmpo_max,size);
|
||||
tmpo->use_count=0;
|
||||
if (HashFind(tmpo->str,cmp.asm_hash,HTT_OPCODE))
|
||||
LexExcept(cc,"Duplicate OPCODE entry ");
|
||||
|
|
|
@ -114,7 +114,7 @@ U0 ICCopyTemplate(CCompCtrl *cc,CIntermediateCode *tmpi,I64 op,
|
|||
}
|
||||
}
|
||||
}
|
||||
MemCpy(&tmpi->ic_body[tmpi->ic_count],ptr,i);
|
||||
MemCopy(&tmpi->ic_body[tmpi->ic_count],ptr,i);
|
||||
if (!off_the_record)
|
||||
CompNoteFloatOp(cc,tmpi,dont_pushable,dont_popable,pos);
|
||||
tmpi->ic_count+=i;
|
||||
|
@ -567,7 +567,7 @@ U0 ICFModEqu(CCompCtrl *cc,CIntermediateCode *tmpi,I64 rip)
|
|||
ICFCvt2(cc,tmpi,REG_RDX,MDF_REG+RT_I64,REG_RDX,0,FALSE,rip);
|
||||
}
|
||||
//TODO: unpushable,unpop? Not sure
|
||||
ICCopyTemplate(cc,tmpi,CMP_TEMPLATE_MOD,FALSE,FALSE,FALSE,CN_INST);
|
||||
ICCopyTemplate(cc,tmpi,CMP_TEMPLATE_MOD,FALSE,FALSE,FALSE,CN_INST);
|
||||
if (tmpi->arg1_type_pointed_to!=RT_F64)
|
||||
ICFCvt2(cc,tmpi,REG_RAX,MDF_REG+RT_I64,REG_RAX,0,TRUE,rip);
|
||||
ICMov(tmpi,tmpi->arg1.type&MDG_MASK+tmpi->arg1_type_pointed_to,
|
||||
|
|
|
@ -18,7 +18,7 @@ I64 HashEntrySize(CHashSrcSym *tmph)
|
|||
case HTt_FILE:
|
||||
return MSize(tmph(CHashGeneric *)->user_data0);
|
||||
case HTt_MODULE:
|
||||
if (StrCmp(tmph->str,KERNEL_MODULE_NAME))
|
||||
if (StrCompare(tmph->str,KERNEL_MODULE_NAME))
|
||||
return MSize(tmph(CHashGeneric *)->user_data0);
|
||||
else {
|
||||
bfh=mem_boot_base-sizeof(CBinFile);
|
||||
|
@ -64,7 +64,7 @@ I64 HashEntrySize2(CHashSrcSym *tmph)
|
|||
} else if (tmph->type & HTT_FILE)
|
||||
res+=MSize2(tmph(CHashGeneric *)->user_data0);
|
||||
else if (tmph->type & HTT_MODULE &&
|
||||
StrCmp(tmph->str,KERNEL_MODULE_NAME))
|
||||
StrCompare(tmph->str,KERNEL_MODULE_NAME))
|
||||
res+=MSize2(tmph(CHashGeneric *)->user_data0);
|
||||
return res;
|
||||
}
|
||||
|
@ -116,7 +116,7 @@ U0 MapFileWrite(CHashTable *h,U8 *map_name,U8 drv_let)
|
|||
tmpb=CAlloc(sizeof(CDocBin));
|
||||
tmpb->size=size;
|
||||
tmpb->data=MAlloc(size);
|
||||
MemCpy(tmpb->data,dbg_info,size);
|
||||
MemCopy(tmpb->data,dbg_info,size);
|
||||
tmpb->num=doc->cur_bin_num++;
|
||||
tmpb->use_count=1;
|
||||
QueueInsert(tmpb,doc->bin_head.last);
|
||||
|
|
|
@ -57,7 +57,7 @@ CAOT *CompJoin(CCompCtrl *cc,I64 comp_flags,U8 *map_name=NULL,U8 mapfile_drive_l
|
|||
aotc->max_align_bits=0;
|
||||
aotc->org=INVALID_PTR;
|
||||
|
||||
MemCpy(htc,&cc->htc,sizeof(CLexHashTableContext));
|
||||
MemCopy(htc,&cc->htc,sizeof(CLexHashTableContext));
|
||||
if (cc->htc.fun)
|
||||
cc->htc.glbl_hash_table=HashTableNew(128);
|
||||
else
|
||||
|
@ -133,7 +133,7 @@ CAOT *CompJoin(CCompCtrl *cc,I64 comp_flags,U8 *map_name=NULL,U8 mapfile_drive_l
|
|||
i=l;
|
||||
if (i>AOT_BIN_BLK_SIZE)
|
||||
i=AOT_BIN_BLK_SIZE;
|
||||
MemCpy(res->buf+j,tmpbin->body,i);
|
||||
MemCopy(res->buf+j,tmpbin->body,i);
|
||||
j+=i;
|
||||
l-=i;
|
||||
tmpbin=tmpbin->next;
|
||||
|
@ -146,7 +146,7 @@ CAOT *CompJoin(CCompCtrl *cc,I64 comp_flags,U8 *map_name=NULL,U8 mapfile_drive_l
|
|||
res->org=aotc->org;
|
||||
}
|
||||
cc->aot=parent;
|
||||
MemCpy(&cc->htc,htc,sizeof(CLexHashTableContext));
|
||||
MemCopy(&cc->htc,htc,sizeof(CLexHashTableContext));
|
||||
Free(htc);
|
||||
Free(aotc);
|
||||
cc->aotc=old_aot;
|
||||
|
@ -471,7 +471,7 @@ I64 Comp(U8 *filename,U8 *map_name=NULL,U8 *out_name=NULL,U8 mapfile_drive_let=0
|
|||
*ptr(U32 *)++=count;
|
||||
if (tmphg->str) {
|
||||
i=StrLen(tmphg->str);
|
||||
MemCpy(ptr,tmphg->str,i+1);
|
||||
MemCopy(ptr,tmphg->str,i+1);
|
||||
Free(tmphg->str);
|
||||
ptr+=i+1;
|
||||
} else
|
||||
|
@ -499,7 +499,7 @@ I64 Comp(U8 *filename,U8 *map_name=NULL,U8 *out_name=NULL,U8 mapfile_drive_let=0
|
|||
*ptr(U32 *)++=tmpie->rip;
|
||||
if (tmpie->str) {
|
||||
i=StrLen(tmpie->str);
|
||||
MemCpy(ptr,tmpie->str,i+1);
|
||||
MemCopy(ptr,tmpie->str,i+1);
|
||||
Free(tmpie->str);
|
||||
ptr+=i+1;
|
||||
} else
|
||||
|
@ -521,7 +521,7 @@ I64 Comp(U8 *filename,U8 *map_name=NULL,U8 *out_name=NULL,U8 mapfile_drive_let=0
|
|||
*ptr(U32 *)++=tmpie->rip;
|
||||
if (tmpie->str) {
|
||||
i=StrLen(tmpie->str);
|
||||
MemCpy(ptr,tmpie->str,i+1);
|
||||
MemCopy(ptr,tmpie->str,i+1);
|
||||
Free(tmpie->str);
|
||||
ptr+=i+1;
|
||||
} else
|
||||
|
@ -545,8 +545,8 @@ I64 Comp(U8 *filename,U8 *map_name=NULL,U8 *out_name=NULL,U8 mapfile_drive_let=0
|
|||
bfh->module_align_bits=tmpaot->max_align_bits;
|
||||
bfh->patch_table_offset=sizeof(CBinFile)+aot_U8s;
|
||||
bfh->file_size=size;
|
||||
MemCpy(bfh(U8 *)+sizeof(CBinFile),tmpaot->buf,aot_U8s);
|
||||
MemCpy(bfh(U8 *)+sizeof(CBinFile)+aot_U8s,patch_table,
|
||||
MemCopy(bfh(U8 *)+sizeof(CBinFile),tmpaot->buf,aot_U8s);
|
||||
MemCopy(bfh(U8 *)+sizeof(CBinFile)+aot_U8s,patch_table,
|
||||
size-aot_U8s-sizeof(CBinFile));
|
||||
Free(fbuf2);
|
||||
if (out_name)
|
||||
|
@ -582,7 +582,7 @@ I64 ExePutS(U8 *buf,U8 *filename=NULL,
|
|||
if (htc) {
|
||||
cc->flags=cc->flags &~CCF_ASM_EXPRESSIONS |
|
||||
htc->old_flags&CCF_ASM_EXPRESSIONS;
|
||||
MemCpy(&cc->htc,htc,sizeof(CLexHashTableContext));
|
||||
MemCopy(&cc->htc,htc,sizeof(CLexHashTableContext));
|
||||
}
|
||||
}
|
||||
QueueInsert(cc,Fs->last_cc);
|
||||
|
|
|
@ -154,7 +154,7 @@ U8 *CmdLinePrompt()
|
|||
|
||||
i=StrLen(st);
|
||||
res=MAlloc(i+1+2);
|
||||
MemCpy(res,st,i+1);
|
||||
MemCopy(res,st,i+1);
|
||||
i--;
|
||||
while (i>=0 && Bt(char_bmp_white_space,res[i]))
|
||||
i--;
|
||||
|
|
Binary file not shown.
|
@ -164,7 +164,7 @@ lgc_start2:
|
|||
if (doc_e->bin_data) {
|
||||
ptr=MAlloc(doc_e->bin_data->size);
|
||||
if (doc_e->bin_data->data)
|
||||
MemCpy(ptr,doc_e->bin_data->data,doc_e->bin_data->size);
|
||||
MemCopy(ptr,doc_e->bin_data->data,doc_e->bin_data->size);
|
||||
cc->cur_str=ptr;
|
||||
cc->cur_str_len=doc_e->bin_data->size;
|
||||
}
|
||||
|
@ -225,7 +225,7 @@ lgc_start2:
|
|||
if (cc->flags & CCF_PROMPT) {
|
||||
Free(tmpf->buf);
|
||||
ptr=CmdLinePrompt;
|
||||
if (StrCmp(ptr,"\n") && !cc->prompt_line++ && !StrCmp(ptr,"?\n") &&
|
||||
if (StrCompare(ptr,"\n") && !cc->prompt_line++ && !StrCompare(ptr,"?\n") &&
|
||||
cc->flags & CCF_QUESTION_HELP) {
|
||||
Free(ptr);
|
||||
ptr=StrNew("Help;;\n");
|
||||
|
@ -613,19 +613,19 @@ lex_float_start:
|
|||
j=LexInStr(cc,buf,STR_LEN,&str_done);
|
||||
buf3=MAlloc(i+j);
|
||||
if (buf2) {
|
||||
MemCpy(buf3,buf2,i);
|
||||
MemCopy(buf3,buf2,i);
|
||||
Free(buf2);
|
||||
buf2=buf3;
|
||||
MemCpy(buf2+i,buf,j);
|
||||
MemCopy(buf2+i,buf,j);
|
||||
} else {
|
||||
buf2=buf3;
|
||||
MemCpy(buf2,buf,j);
|
||||
MemCopy(buf2,buf,j);
|
||||
}
|
||||
i+=j;
|
||||
} while (!str_done);
|
||||
Free(cc->cur_str);
|
||||
cc->cur_str=MAlloc(i);
|
||||
MemCpy(cc->cur_str,buf2,i);
|
||||
MemCopy(cc->cur_str,buf2,i);
|
||||
Free(buf2);
|
||||
cc->cur_str_len=i;
|
||||
cc->flags&=~CCF_IN_QUOTES;
|
||||
|
@ -773,13 +773,13 @@ lex_float_start:
|
|||
buf[j++]=0;
|
||||
buf3=MAlloc(i+j);
|
||||
if (buf2) {
|
||||
MemCpy(buf3,buf2,i);
|
||||
MemCopy(buf3,buf2,i);
|
||||
Free(buf2);
|
||||
buf2=buf3;
|
||||
MemCpy(buf2+i,buf,j);
|
||||
MemCopy(buf2+i,buf,j);
|
||||
} else {
|
||||
buf2=buf3;
|
||||
MemCpy(buf2,buf,j);
|
||||
MemCopy(buf2,buf,j);
|
||||
}
|
||||
i+=j-1;
|
||||
j=0;
|
||||
|
@ -790,13 +790,13 @@ lex_float_start:
|
|||
buf[j++]=0;
|
||||
buf3=MAlloc(i+j);
|
||||
if (buf2) {
|
||||
MemCpy(buf3,buf2,i);
|
||||
MemCopy(buf3,buf2,i);
|
||||
Free(buf2);
|
||||
buf2=buf3;
|
||||
MemCpy(buf2+i,buf,j);
|
||||
MemCopy(buf2+i,buf,j);
|
||||
} else {
|
||||
buf2=buf3;
|
||||
MemCpy(buf2,buf,j);
|
||||
MemCopy(buf2,buf,j);
|
||||
}
|
||||
tmph(CHashDefineStr *)->data=buf2;
|
||||
tmph(CHashDefineStr *)->count=-1;
|
||||
|
|
|
@ -29,7 +29,7 @@ U0 LexPopRestore(CCompCtrl *cc)
|
|||
cc->flags|=CCF_USE_LAST_U16;
|
||||
else
|
||||
cc->flags&=~CCF_USE_LAST_U16;
|
||||
MemCpy(cc->lex_include_stack(U8 *)+sizeof(U8 *),tmpf(U8 *)+sizeof(U8 *),
|
||||
MemCopy(cc->lex_include_stack(U8 *)+sizeof(U8 *),tmpf(U8 *)+sizeof(U8 *),
|
||||
sizeof(CLexFile)-sizeof(U8 *));
|
||||
cc->lex_prs_stack=tmpf->next;
|
||||
Free(tmpf);
|
||||
|
@ -46,7 +46,7 @@ I64 MemberMetaData(U8 *needle_str,CMemberList *haystack_member_list)
|
|||
{//Find meta data name, return meta data val. See $LK,"::/Demo/ClassMeta.HC"$.
|
||||
CMemberListMeta *meta=haystack_member_list->meta;
|
||||
while (meta) {
|
||||
if (!StrCmp(meta->str,needle_str))
|
||||
if (!StrCompare(meta->str,needle_str))
|
||||
return meta->user_data;
|
||||
meta=meta->next;
|
||||
}
|
||||
|
@ -57,7 +57,7 @@ CMemberListMeta *MemberMetaFind(U8 *needle_str,CMemberList *haystack_member_list
|
|||
{//Find meta data name, return meta data struct. See $LK,"::/Demo/ClassMeta.HC"$.
|
||||
CMemberListMeta *meta=haystack_member_list->meta;
|
||||
while (meta) {
|
||||
if (!StrCmp(meta->str,needle_str))
|
||||
if (!StrCompare(meta->str,needle_str))
|
||||
return meta;
|
||||
meta=meta->next;
|
||||
}
|
||||
|
@ -71,7 +71,7 @@ CMemberList *MemberFind(U8 *needle_str,CHashClass *haystack_class)
|
|||
do {
|
||||
tmpm=haystack_class->member_list_and_root;
|
||||
while (tmpm) {
|
||||
if (!(i=StrCmp(tmpm->str,needle_str))) {
|
||||
if (!(i=StrCompare(tmpm->str,needle_str))) {
|
||||
tmpm->use_count++;
|
||||
return tmpm;
|
||||
}
|
||||
|
@ -105,12 +105,12 @@ U0 MemberAdd(CCompCtrl *cc,CMemberList *tmpm,CHashClass *tmpc,I64 mode)
|
|||
U8 *st=tmpm->str;
|
||||
CMemberList **tmpm1,*tmpm2;
|
||||
|
||||
if (MemberFind(st,tmpc) && StrCmp(st,"pad") &&
|
||||
StrCmp(st,"reserved") && StrCmp(st,"_anon_"))
|
||||
if (MemberFind(st,tmpc) && StrCompare(st,"pad") &&
|
||||
StrCompare(st,"reserved") && StrCompare(st,"_anon_"))
|
||||
LexExcept(cc,"Duplicate member at ");
|
||||
tmpm1=&tmpc->member_list_and_root;
|
||||
while (tmpm2=*tmpm1) {
|
||||
if (StrCmp(tmpm2->str,st)<=0)
|
||||
if (StrCompare(tmpm2->str,st)<=0)
|
||||
tmpm1=&tmpm2->left;
|
||||
else
|
||||
tmpm1=&tmpm2->right;
|
||||
|
@ -157,7 +157,7 @@ CMemberList *MemberListNew(I64 _reg)
|
|||
Bool MemberListCmp(CMemberList *tmpm1,CMemberList *tmpm2,I64 count=I64_MAX)
|
||||
{
|
||||
while (tmpm1 && tmpm2 && count--) {
|
||||
if (StrCmp(tmpm1->str,tmpm2->str) ||
|
||||
if (StrCompare(tmpm1->str,tmpm2->str) ||
|
||||
tmpm1->member_class!=tmpm2->member_class ||
|
||||
tmpm1->member_class_base!=tmpm2->member_class_base)
|
||||
return FALSE;
|
||||
|
@ -166,7 +166,7 @@ Bool MemberListCmp(CMemberList *tmpm1,CMemberList *tmpm2,I64 count=I64_MAX)
|
|||
tmpm2->flags&(MLF_DEFAULT_AVAILABLE|MLF_STR_DEFAULT_AVAILABLE))
|
||||
return FALSE;
|
||||
if (tmpm1->flags&MLF_STR_DEFAULT_AVAILABLE) {
|
||||
if (StrCmp(tmpm1->default_val,tmpm2->default_val))
|
||||
if (StrCompare(tmpm1->default_val,tmpm2->default_val))
|
||||
return FALSE;
|
||||
} else if (tmpm1->default_val!=tmpm2->default_val)
|
||||
return FALSE;
|
||||
|
@ -264,8 +264,8 @@ U8 *LexExtStr(CCompCtrl *cc,I64 *_size=NULL,Bool lex_next=TRUE)
|
|||
len=len1+len2-1;
|
||||
st=MAlloc(len);
|
||||
if (len1>1)
|
||||
MemCpy(st,st1,len1-1);
|
||||
MemCpy(st+len1-1,st2,len2);
|
||||
MemCopy(st,st1,len1-1);
|
||||
MemCopy(st+len1-1,st2,len2);
|
||||
Free(st1);
|
||||
Free(st2);
|
||||
}
|
||||
|
|
|
@ -287,7 +287,7 @@ U0 OptPass3(CCompCtrl *cc,COptReg *reg_offsets)
|
|||
if ((tmpi1->ic_code==IC_IMM_I64 ||
|
||||
tmpi1->ic_code==IC_IMM_F64) && !tmpi1->ic_data) {
|
||||
OptFree(tmpi1);
|
||||
MemCpy(&tmpi->arg1,&tmpi->arg2,sizeof(CICArg));
|
||||
MemCopy(&tmpi->arg1,&tmpi->arg2,sizeof(CICArg));
|
||||
tmpi->arg2.type=MDF_NULL;
|
||||
if (code==IC_BR_EQU_EQU)
|
||||
code=tmpi->ic_code=IC_BR_ZERO;
|
||||
|
@ -588,7 +588,7 @@ R12 and R13 as non-pointer register variables, such as index variables i,j,k.
|
|||
tmpm=mv[i].m;
|
||||
//if not just flagged as reg var
|
||||
if (mv[i].offset_start && (!mv[i].m->dim.next||
|
||||
tmpm->offset>0 && StrCmp(tmpm->str,"argv"))) {
|
||||
tmpm->offset>0 && StrCompare(tmpm->str,"argv"))) {
|
||||
while (l<cmp.num_reg_vars &&
|
||||
Bts(&cc->htc.fun->used_reg_mask,cmp.to_reg_vars_map[l]))
|
||||
l++;
|
||||
|
|
|
@ -59,7 +59,7 @@ cc->pass==10 is final pass, code is placed into buf.
|
|||
~(ICF_PREV_DELETED|ICF_DONT_RESTORE)|ICF_CODE_FINAL;
|
||||
if (cc->pass==7)
|
||||
cc->dont_push_float=Btr(&tmpi->ic_flags,ICf_DONT_PUSH_FLOAT0);
|
||||
MemCpy(saved_arg1_arg2_r,&tmpi->arg1,3*sizeof(CICArg));
|
||||
MemCopy(saved_arg1_arg2_r,&tmpi->arg1,3*sizeof(CICArg));
|
||||
tmpi->ic_count=0;
|
||||
tmpi->ic_last_start=-1;
|
||||
if (tmpi->arg2.type.mode) {
|
||||
|
@ -307,7 +307,7 @@ cc->pass==10 is final pass, code is placed into buf.
|
|||
tmpaot=tmpi->ic_data;
|
||||
tmpi->ic_count+=tmpaot->aot_U8s;
|
||||
if (buf) {
|
||||
MemCpy(buf+rip,tmpaot->buf,tmpaot->aot_U8s);
|
||||
MemCopy(buf+rip,tmpaot->buf,tmpaot->aot_U8s);
|
||||
Free(tmpaot->buf);
|
||||
tmpaot->buf=buf;
|
||||
tmpaot->rip=rip;
|
||||
|
@ -1070,7 +1070,7 @@ cc->pass==10 is final pass, code is placed into buf.
|
|||
tmpi->ic_flags&=~ICF_DEL_PREV_INS;
|
||||
}
|
||||
if (count && buf)
|
||||
MemCpy(buf+rip,tmpi->ic_body,count);
|
||||
MemCopy(buf+rip,tmpi->ic_body,count);
|
||||
op789A_skip_copy:
|
||||
if (dbg_info && cc->min_line<=tmpi->ic_line<=cc->max_line) {
|
||||
i=tmpi->ic_line-cc->min_line;
|
||||
|
@ -1087,7 +1087,7 @@ op789A_skip_copy:
|
|||
"$$FG$$";
|
||||
}
|
||||
if (!(tmpi->ic_flags&(ICF_CODE_FINAL|ICF_DONT_RESTORE)))
|
||||
MemCpy(&tmpi->arg1,saved_arg1_arg2_r,3*sizeof(CICArg));
|
||||
MemCopy(&tmpi->arg1,saved_arg1_arg2_r,3*sizeof(CICArg));
|
||||
rip+=count;
|
||||
if (tmpi->ic_count>=IC_BODY_SIZE && tmpi->ic_code!=IC_ASM)
|
||||
throw('Compiler');
|
||||
|
@ -1101,7 +1101,7 @@ op789A_next:
|
|||
case CMT_STR_CONST:
|
||||
lb->addr=rip;
|
||||
if (buf)
|
||||
MemCpy(buf+rip,lb->str,lb->st_len);
|
||||
MemCopy(buf+rip,lb->str,lb->st_len);
|
||||
rip+=lb->st_len;
|
||||
break;
|
||||
case CMT_JMP_TABLE:
|
||||
|
@ -1136,7 +1136,7 @@ op789A_next:
|
|||
case CMT_FLOAT_CONSTS:
|
||||
lb->addr=rip;
|
||||
if (buf)
|
||||
MemCpy(buf+lb->addr,lb->float_consts,lb->num_consts*sizeof(F64));
|
||||
MemCopy(buf+lb->addr,lb->float_consts,lb->num_consts*sizeof(F64));
|
||||
rip+=lb->num_consts*sizeof(F64);
|
||||
break;
|
||||
}
|
||||
|
|
|
@ -793,7 +793,7 @@ I64 ParseUnaryTerm(CCompCtrl *cc,CPrsStack *ps,CMemberList **_local_var,
|
|||
return PE_MAYBE_MODIFIERS;
|
||||
} else {
|
||||
if (tmpm->dim.next && tmpm->offset>0 &&
|
||||
StrCmp(tmpm->str,"argv")) {
|
||||
StrCompare(tmpm->str,"argv")) {
|
||||
tmpc++;
|
||||
cc->flags&=~CCF_ARRAY;
|
||||
}
|
||||
|
|
|
@ -107,14 +107,14 @@ U0 COCInit(CCompCtrl *cc)
|
|||
U0 COCPush(CCompCtrl *cc)
|
||||
{
|
||||
CCodeCtrl *tmpcbh=MAlloc(sizeof(CCodeCtrl));
|
||||
MemCpy(tmpcbh,&cc->coc,sizeof(CCodeCtrl));
|
||||
MemCopy(tmpcbh,&cc->coc,sizeof(CCodeCtrl));
|
||||
cc->coc.coc_next=tmpcbh;
|
||||
}
|
||||
|
||||
CCompCtrl *COCPopNoFree(CCompCtrl *cc)
|
||||
{
|
||||
CCodeCtrl *tmpcbh=cc->coc.coc_next;
|
||||
MemCpy(&cc->coc,tmpcbh,sizeof(CCodeCtrl));
|
||||
MemCopy(&cc->coc,tmpcbh,sizeof(CCodeCtrl));
|
||||
return tmpcbh;
|
||||
}
|
||||
|
||||
|
@ -154,7 +154,7 @@ CCodeMisc *COCGoToLabelFind(CCompCtrl *cc,U8 *name)
|
|||
CCodeMisc *cm=cc->coc.coc_next_misc;
|
||||
while (cm!=&cc->coc.coc_next_misc) {
|
||||
if ((cm->type==CMT_GOTO_LABEL||cm->type==CMT_ASM_LABEL) &&
|
||||
!StrCmp(cm->str,name))
|
||||
!StrCompare(cm->str,name))
|
||||
return cm;
|
||||
cm=cm->next;
|
||||
}
|
||||
|
|
|
@ -193,7 +193,7 @@ U0 ParseFun(CCompCtrl *cc,CHashClass *tmp_return,U8 *name,I64 fsp_flags)
|
|||
tmpm=cc->htc.fun->member_list_and_root;
|
||||
while (tmpm) {
|
||||
if (tmpm->flags & MLF_NO_UNUSED_WARN) {
|
||||
if (tmpm->use_count>1&&StrCmp(tmpm->str,"_anon_"))
|
||||
if (tmpm->use_count>1&&StrCompare(tmpm->str,"_anon_"))
|
||||
PrintWarn("Unneeded no_warn\n $$LK,\"FL:%s,%d\"$$'%s' in '%s'\n",
|
||||
cc->lex_include_stack->full_name,cc->lex_include_stack->line_num,
|
||||
tmpm->str,cc->htc.fun->str);
|
||||
|
@ -811,7 +811,7 @@ U0 ParseStreamBlk(CCompCtrl *cc)
|
|||
COCPush(cc);
|
||||
QueueInit(&cc->coc.coc_next_misc);
|
||||
|
||||
MemCpy(htc,&cc->htc,sizeof(CLexHashTableContext));
|
||||
MemCopy(htc,&cc->htc,sizeof(CLexHashTableContext));
|
||||
htc->old_flags=cc->flags;
|
||||
cc->htc.next=htc;
|
||||
cc->htc.fun=cc->htc.local_var_list=NULL;
|
||||
|
@ -825,7 +825,7 @@ U0 ParseStreamBlk(CCompCtrl *cc)
|
|||
while (cc->token && cc->token!='}')
|
||||
ExeCmdLine(cc);
|
||||
|
||||
MemCpy(&cc->htc,htc,sizeof(CLexHashTableContext));
|
||||
MemCopy(&cc->htc,htc,sizeof(CLexHashTableContext));
|
||||
cc->flags=cc->flags&~CCF_EXE_BLK |
|
||||
htc->old_flags & (CCF_ASM_EXPRESSIONS|CCF_EXE_BLK|CCF_AOT_COMPILE);
|
||||
Free(htc);
|
||||
|
|
|
@ -104,7 +104,7 @@ U0 ParseVarInit(CCompCtrl *cc,U8 **_dst,CHashClass *tmpc,CArrayDim *tmpad,
|
|||
else if (type!=RT_F64 &&
|
||||
tmpc->raw_type==RT_F64)
|
||||
r(F64)=r;
|
||||
MemCpy(dst,&r,tmpc->size);
|
||||
MemCopy(dst,&r,tmpc->size);
|
||||
}
|
||||
}
|
||||
dst+=tmpc->size;
|
||||
|
@ -142,10 +142,10 @@ U0 ParseVarInit2(CCompCtrl *cc,U8 **_dst,CHashClass *tmpc,
|
|||
*_base=MAlloc(i);
|
||||
else
|
||||
*_base=MAlloc(i,Fs->code_heap);
|
||||
MemCpy(*_base,st,i);
|
||||
MemCopy(*_base,st,i);
|
||||
*_dst=*_base+i;
|
||||
} else {
|
||||
MemCpy(*_dst,st,tmpad1->count);
|
||||
MemCopy(*_dst,st,tmpad1->count);
|
||||
*_dst+=tmpad1->count;
|
||||
}
|
||||
Free(st);
|
||||
|
@ -181,7 +181,7 @@ U0 ParseVarInit2(CCompCtrl *cc,U8 **_dst,CHashClass *tmpc,
|
|||
tmpvi=head.next;
|
||||
while (tmpvi!=&head) {
|
||||
tmpvi1=tmpvi->next;
|
||||
MemCpy(_b,&tmpvi->base,j);
|
||||
MemCopy(_b,&tmpvi->base,j);
|
||||
_b+=j;
|
||||
Free(tmpvi);
|
||||
tmpvi=tmpvi1;
|
||||
|
|
|
@ -644,7 +644,7 @@ U0 Ui(U8 *buf,U8 **_rip,I64 seg_size=64,I64 *_jmp_dst=NULL,Bool just_ins=FALSE)
|
|||
bin_data_area2[(i-6)<<1+1]=CH_SPACE;
|
||||
}
|
||||
}
|
||||
StrCpy(buf,line1);
|
||||
StrCopy(buf,line1);
|
||||
if (!just_ins && rip-(*_rip)(I64)>6)
|
||||
CatPrint(buf,line2);
|
||||
*_rip=rip;
|
||||
|
|
|
@ -202,7 +202,7 @@ Bool MyPutKey(I64 ch,I64 sc)
|
|||
ClipDel;
|
||||
st1=FileNameAbs(BIBLE_FILENAME);
|
||||
st2=FileNameAbs(DocPut->filename.name);
|
||||
if (!StrCmp(st1,st2)) {
|
||||
if (!StrCompare(st1,st2)) {
|
||||
Free(st1);
|
||||
st1=BibleLine2Verse(DocPut->cur_entry->y+1,',');
|
||||
DocPrint(sys_clip_doc,"$$LK,\"BF:%s\"$$",st1);
|
||||
|
|
Binary file not shown.
|
@ -287,7 +287,7 @@ $FG,5$$TX+CX,"Committee Needed"$$FG$
|
|||
|
||||
* Should Messages in PopUp queue get fwded to parent when task dies?
|
||||
|
||||
* Import Intel datasheets so we can use links in $LK,"Code",A="FI:::/Kernel/Mem/PageTables.HC"$ for documentation. I tried a PDF-to-text convertor and it wasn't acceptible.
|
||||
* Import Intel datasheets so we can use links in $LK,"Code",A="FI:::/Kernel/Memory/PageTables.HC"$ for documentation. I tried a PDF-to-text convertor and it wasn't acceptible.
|
||||
|
||||
* Switch stmt with sparse cases? Maybe, ban sparse switch statements.
|
||||
|
||||
|
|
|
@ -11,7 +11,7 @@ ins_reg.host_os=2;
|
|||
ins_reg.host_vm=2;
|
||||
|
||||
#define INS_REG_PERSONAL_INITIALS "TAD"
|
||||
StrCpy(ins_reg.initials,"TAD");
|
||||
StrCopy(ins_reg.initials,"TAD");
|
||||
HashPublic("INS_REG_PERSONAL_INITIALS",HTT_DEFINE_STR);
|
||||
|
||||
#define INS_REG_MACHINE_NUM 0
|
||||
|
|
|
@ -283,7 +283,7 @@ U0 TOSProgress(U8 *st)
|
|||
progress4_t0=tos_progress_t0;
|
||||
StrPrint(buf,"%d. %s",++progress4,st);
|
||||
"$$PURPLE$$$$TX+CX,\"%s\"$$$$FG$$\n",buf;
|
||||
StrCpy(progress3_desc,buf);
|
||||
StrCopy(progress3_desc,buf);
|
||||
tos_progress=progress4;
|
||||
}
|
||||
|
||||
|
|
|
@ -50,7 +50,7 @@ U0 DataDemo()
|
|||
doc_e=DocPrint(doc,"$$DA-TRM+RD+UD,RT=I16,A=\"%%7d\"$$\n");
|
||||
doc_e->data=&i;
|
||||
|
||||
StrCpy(buf,"Terry");
|
||||
StrCopy(buf,"Terry");
|
||||
doc_e=DocPrint(doc,"$$DA-P+RD+UD,LEN=7,A=\"Str:%%s\"$$\n");
|
||||
doc_e->data=buf;
|
||||
|
||||
|
|
|
@ -22,7 +22,7 @@ U0 FormDemo()
|
|||
fds.num3=0x1234;
|
||||
fds.num4=-567;
|
||||
fds.type=1;
|
||||
StrCpy(&fds.name,"John");
|
||||
StrCopy(&fds.name,"John");
|
||||
fds.address1=StrNew("1234 Pine St.");
|
||||
fds.address2=NULL; //Init to NULL if empty.
|
||||
fds.datetime=Now;
|
||||
|
|
|
@ -36,7 +36,7 @@ U0 UnusedDefineScan()
|
|||
|
||||
progress1=0;
|
||||
progress1_max=count;
|
||||
StrCpy(progress1_desc,"Define Scan");
|
||||
StrCopy(progress1_desc,"Define Scan");
|
||||
|
||||
table=Fs->hash_table;
|
||||
while (table) {
|
||||
|
|
Binary file not shown.
|
@ -52,7 +52,7 @@ U0 AnimateTask(I64)
|
|||
I64 i;
|
||||
U64 *font=MAlloc(256*8);
|
||||
Fs->task_end_cb=&AnimateEndCB;
|
||||
MemCpy(font,text.font,256*8);
|
||||
MemCopy(font,text.font,256*8);
|
||||
text.font=font;
|
||||
font[CH_TREE]=0x18187E7E3C3C18;
|
||||
while (TRUE) {
|
||||
|
|
|
@ -6,7 +6,7 @@ U32 text[TEXT_ROWS][TEXT_COLS];
|
|||
|
||||
U0 DrawIt(CTask *task,CDC *)
|
||||
{ //$LK,"gr.text_base",A="MN:CGrGlobals"$ gets clear 30fps, so we must use our own permanent text array.
|
||||
MemCpy(gr.text_base+TEXT_COLS,text,(TEXT_ROWS-1)*TEXT_COLS*sizeof(U32));
|
||||
MemCopy(gr.text_base+TEXT_COLS,text,(TEXT_ROWS-1)*TEXT_COLS*sizeof(U32));
|
||||
|
||||
// You can copy it this way, if you like:
|
||||
// I64 i,j;
|
||||
|
|
|
@ -191,8 +191,8 @@ U0 TrackSlice(F64 *_x,F64 *_z,F64
|
|||
|
||||
tmpt=CAlloc(sizeof(Track));
|
||||
if (last) {
|
||||
MemCpy(&tmpt->center[0],&last->center[3],sizeof(CD3I32));
|
||||
MemCpy(&tmpt->center[1],&last->center[2],sizeof(CD3I32));
|
||||
MemCopy(&tmpt->center[0],&last->center[3],sizeof(CD3I32));
|
||||
MemCopy(&tmpt->center[1],&last->center[2],sizeof(CD3I32));
|
||||
}
|
||||
tmpt->center[2].x=x+(WIDTH/2)*c+dx;
|
||||
tmpt->center[2].z=z+(WIDTH/2)*s+dz;
|
||||
|
@ -202,8 +202,8 @@ U0 TrackSlice(F64 *_x,F64 *_z,F64
|
|||
tmpt->center[3].y=DipY(tmpt->center[3].x,tmpt->center[3].z);
|
||||
|
||||
if (last) {
|
||||
MemCpy(&tmpt->left[0],&last->left[3],sizeof(CD3I32));
|
||||
MemCpy(&tmpt->left[1],&last->left[2],sizeof(CD3I32));
|
||||
MemCopy(&tmpt->left[0],&last->left[3],sizeof(CD3I32));
|
||||
MemCopy(&tmpt->left[1],&last->left[2],sizeof(CD3I32));
|
||||
}
|
||||
tmpt->left[2].x=x-(WIDTH/2)*c+dx;
|
||||
tmpt->left[2].z=z-(WIDTH/2)*s+dz;
|
||||
|
@ -213,8 +213,8 @@ U0 TrackSlice(F64 *_x,F64 *_z,F64
|
|||
tmpt->left[3].y=DipY(tmpt->left[3].x,tmpt->left[3].z);
|
||||
|
||||
if (last) {
|
||||
MemCpy(&tmpt->right[0],&last->right[3],sizeof(CD3I32));
|
||||
MemCpy(&tmpt->right[1],&last->right[2],sizeof(CD3I32));
|
||||
MemCopy(&tmpt->right[0],&last->right[3],sizeof(CD3I32));
|
||||
MemCopy(&tmpt->right[1],&last->right[2],sizeof(CD3I32));
|
||||
}
|
||||
tmpt->right[2].x=x+(WIDTH/2+SHOULDER)*c+dx;
|
||||
tmpt->right[2].z=z+(WIDTH/2+SHOULDER)*s+dz;
|
||||
|
@ -255,12 +255,12 @@ U0 TrackSlice(F64 *_x,F64 *_z,F64
|
|||
U0 CoupleEnds()
|
||||
{
|
||||
Track *first=track_head.next,*last=track_head.last;
|
||||
MemCpy(&first->center[0],&last->center[3],sizeof(CD3I32));
|
||||
MemCpy(&first->center[1],&last->center[2],sizeof(CD3I32));
|
||||
MemCpy(&first->left[0] ,&last->left[3] ,sizeof(CD3I32));
|
||||
MemCpy(&first->left[1] ,&last->left[2] ,sizeof(CD3I32));
|
||||
MemCpy(&first->right[0] ,&last->right[3] ,sizeof(CD3I32));
|
||||
MemCpy(&first->right[1] ,&last->right[2] ,sizeof(CD3I32));
|
||||
MemCopy(&first->center[0],&last->center[3],sizeof(CD3I32));
|
||||
MemCopy(&first->center[1],&last->center[2],sizeof(CD3I32));
|
||||
MemCopy(&first->left[0] ,&last->left[3] ,sizeof(CD3I32));
|
||||
MemCopy(&first->left[1] ,&last->left[2] ,sizeof(CD3I32));
|
||||
MemCopy(&first->right[0] ,&last->right[3] ,sizeof(CD3I32));
|
||||
MemCopy(&first->right[1] ,&last->right[2] ,sizeof(CD3I32));
|
||||
}
|
||||
|
||||
U0 InitTrack()
|
||||
|
|
|
@ -18,7 +18,7 @@ U0 AnimateTask(I64)
|
|||
I64 i;
|
||||
U64 *font=MAlloc(256*8);
|
||||
Fs->task_end_cb=&AnimateEndCB;
|
||||
MemCpy(font,text.font,256*8);
|
||||
MemCopy(font,text.font,256*8);
|
||||
text.font=font;
|
||||
while (TRUE) {
|
||||
font[CH_SPACE]=waves[i++&0x3];
|
||||
|
|
|
@ -11,7 +11,7 @@ U0 GridDemo()
|
|||
{
|
||||
CGridGlobals old_grid;
|
||||
U0 (*old_draw_mouse)(CDC *dc,I64 x,I64 y); //Can't init this type of var.
|
||||
MemCpy(&old_grid,&mouse_grid,sizeof(CGridGlobals));
|
||||
MemCopy(&old_grid,&mouse_grid,sizeof(CGridGlobals));
|
||||
GridInit;
|
||||
mouse_grid.snap=TRUE; //You can set other $LK,"stuff",A="MN:CGridGlobals"$.
|
||||
mouse_grid.x=GRID;
|
||||
|
@ -24,7 +24,7 @@ U0 GridDemo()
|
|||
}
|
||||
DCFill;
|
||||
gr.fp_draw_mouse=old_draw_mouse;
|
||||
MemCpy(&mouse_grid,&old_grid,sizeof(CGridGlobals));
|
||||
MemCopy(&mouse_grid,&old_grid,sizeof(CGridGlobals));
|
||||
}
|
||||
|
||||
GridDemo;
|
||||
|
|
|
@ -47,7 +47,7 @@ U0 TurtleEnd(CDC *dc,Turtle *t,CColorROPU16 edge,CColorROPU16 middle,F64
|
|||
F64 r,x,y2;
|
||||
Turtle t2;
|
||||
if (r=t->w) {
|
||||
MemCpy(&t2,t,sizeof(Turtle)); //Save
|
||||
MemCopy(&t2,t,sizeof(Turtle)); //Save
|
||||
x=0;
|
||||
while (TRUE) {
|
||||
t->x+=1/r*Cos(é);
|
||||
|
@ -60,7 +60,7 @@ U0 TurtleEnd(CDC *dc,Turtle *t,CColorROPU16 edge,CColorROPU16 middle,F64
|
|||
} else
|
||||
break;
|
||||
}
|
||||
MemCpy(t,&t2,sizeof(Turtle));
|
||||
MemCopy(t,&t2,sizeof(Turtle));
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -96,7 +96,7 @@ U0 TurtleInit(Turtle *t)
|
|||
U0 DrawIt(CTask *,CDC *dc)
|
||||
{
|
||||
Turtle t2;
|
||||
MemCpy(&t2,&tt,sizeof(Turtle));
|
||||
MemCopy(&t2,&tt,sizeof(Turtle));
|
||||
GrPrint(dc,0,0,"Layer:%f Speed:%f é:%5.1f dé:%5.1f Width:%f",
|
||||
tt.z,tt.speed,tt.é*180/ã,angles[tt.dé_idx]*180/ã,tt.w);
|
||||
|
||||
|
|
Binary file not shown.
|
@ -21,7 +21,7 @@ U0 MGUpdate()
|
|||
//0xA0000 alias is slower than normal RAM.
|
||||
OutU8(VGAP_IDX,VGAR_MAP_MASK);
|
||||
OutU8(VGAP_DATA,0xF);//All color planes at once -- Black and White
|
||||
MemCpy(text.vga_alias,image,sizeof(image)); //Alias of 0xA0000
|
||||
MemCopy(text.vga_alias,image,sizeof(image)); //Alias of 0xA0000
|
||||
}
|
||||
|
||||
U0 MGPlot(I64 x,I64 y)
|
||||
|
|
|
@ -11,12 +11,12 @@ class Person
|
|||
U0 OffsetDemo1()
|
||||
{
|
||||
Person *p=MAlloc(sizeof(Person));
|
||||
StrCpy(p->first, "Terry");
|
||||
StrCpy(p->last, "Davis");
|
||||
StrCpy(p->address1, "8144 Sickle Lane");
|
||||
StrCpy(p->address2, "");
|
||||
StrCpy(p->city, "Las Vegas");
|
||||
StrCpy(p->state_zip,"NV 89128");
|
||||
StrCopy(p->first, "Terry");
|
||||
StrCopy(p->last, "Davis");
|
||||
StrCopy(p->address1, "8144 Sickle Lane");
|
||||
StrCopy(p->address2, "");
|
||||
StrCopy(p->city, "Las Vegas");
|
||||
StrCopy(p->state_zip,"NV 89128");
|
||||
}
|
||||
|
||||
U(&OffsetDemo1,34);
|
||||
|
@ -44,12 +44,12 @@ U8 state_zip[32];
|
|||
U0 OffsetDemo2()
|
||||
{
|
||||
Person *p=MAlloc(sizeof(Person))(I64)+128;
|
||||
StrCpy(p->first, "Terry");
|
||||
StrCpy(p->last, "Davis");
|
||||
StrCpy(p->address1, "8144 Sickle Lane");
|
||||
StrCpy(p->address2, "");
|
||||
StrCpy(p->city, "Las Vegas");
|
||||
StrCpy(p->state_zip,"NV 89128");
|
||||
StrCopy(p->first, "Terry");
|
||||
StrCopy(p->last, "Davis");
|
||||
StrCopy(p->address1, "8144 Sickle Lane");
|
||||
StrCopy(p->address2, "");
|
||||
StrCopy(p->city, "Las Vegas");
|
||||
StrCopy(p->state_zip,"NV 89128");
|
||||
}
|
||||
|
||||
U(&OffsetDemo2,34);
|
||||
|
|
|
@ -319,7 +319,7 @@ I64 TestCoreRange(RangeJob *r)
|
|||
{
|
||||
I64 i,n,res=0;
|
||||
RangeJob rj;
|
||||
MemCpy(&rj,r,sizeof(RangeJob));
|
||||
MemCopy(&rj,r,sizeof(RangeJob));
|
||||
for (i=r->lo;i<r->hi;i+=CORE_SUB_RANGE) {
|
||||
rj.lo=i;
|
||||
rj.hi=i+CORE_SUB_RANGE;
|
||||
|
|
|
@ -81,14 +81,14 @@ U0 MPRadixSortDemo(I64 dummy=0)
|
|||
|
||||
"$$GREEN$$QuickSort$$FG$$\n";
|
||||
t0=tS;
|
||||
MemCpy(arg2,arg1,sizeof(I32)*NUM);
|
||||
MemCopy(arg2,arg1,sizeof(I32)*NUM);
|
||||
QuickSort(arg2,NUM,sizeof(I32),&Compare);
|
||||
"Time:%9.6f\n",tS-t0;
|
||||
D(arg2+NUM/4);
|
||||
|
||||
"$$GREEN$$QuickSortU32$$FG$$\n";
|
||||
t0=tS;
|
||||
MemCpy(arg2,arg1,sizeof(I32)*NUM);
|
||||
MemCopy(arg2,arg1,sizeof(I32)*NUM);
|
||||
QuickSortU32(arg2,NUM);
|
||||
"Time:%9.6f\n",tS-t0;
|
||||
D(arg2+NUM/4);
|
||||
|
@ -118,7 +118,7 @@ U0 MPRadixSortDemo(I64 dummy=0)
|
|||
Yield;
|
||||
j=0;
|
||||
for (i=0;i<my_mp_count;i++) {
|
||||
MemCpy(&arg2[j],b[i],bn[i]*sizeof(I32));
|
||||
MemCopy(&arg2[j],b[i],bn[i]*sizeof(I32));
|
||||
j+=bn[i];
|
||||
}
|
||||
"Time:%9.6f\n",tS-t0;
|
||||
|
|
|
@ -32,7 +32,7 @@ U0 PhoneNumWords(U8 *num)
|
|||
|
||||
src=_num;
|
||||
while (*src) {
|
||||
if (!StrNCmp(st,src,StrLen(st))) {
|
||||
if (!StrNCompare(st,src,StrLen(st))) {
|
||||
ch=*src;
|
||||
*src=0;
|
||||
"%s",_num;
|
||||
|
|
|
@ -16,7 +16,7 @@ U0 Main1()
|
|||
"\nWith description.\n";
|
||||
PressAKey;
|
||||
progress1_max=200;
|
||||
StrCpy(progress1_desc,"Progress Demo"); //PROGRESS_DESC_LEN is max
|
||||
StrCopy(progress1_desc,"Progress Demo"); //PROGRESS_DESC_LEN is max
|
||||
while (progress1++!=progress1_max)
|
||||
Sleep(20);
|
||||
ProgressBarsReset;
|
||||
|
@ -29,7 +29,7 @@ U0 Main2()
|
|||
PressAKey;
|
||||
progress1_max=200;
|
||||
progress1_t0=tS;
|
||||
StrCpy(progress1_desc,"Progress Demo"); //PROGRESS_DESC_LEN is max
|
||||
StrCopy(progress1_desc,"Progress Demo"); //PROGRESS_DESC_LEN is max
|
||||
while (progress1++!=progress1_max)
|
||||
Sleep(20);
|
||||
ProgressBarsReset;
|
||||
|
@ -43,7 +43,7 @@ U0 Main3()
|
|||
progress1_max=200;
|
||||
progress1_t0=tS;
|
||||
RegExe("DemoCompany/ProgressBars");
|
||||
StrCpy(progress1_desc,"Progress Demo"); //PROGRESS_DESC_LEN is max
|
||||
StrCopy(progress1_desc,"Progress Demo"); //PROGRESS_DESC_LEN is max
|
||||
while (progress1++!=progress1_max)
|
||||
Sleep(20);
|
||||
ProgressBarsReset("DemoCompany/ProgressBars");
|
||||
|
|
|
@ -155,7 +155,7 @@ U0 Morse()
|
|||
*dst=0;
|
||||
src=morse_list;
|
||||
while (*src) {
|
||||
if (!StrCmp(src+1,buf)) {
|
||||
if (!StrCompare(src+1,buf)) {
|
||||
"$$GREEN$$%C$$FG$$",*src;
|
||||
break;
|
||||
} else
|
||||
|
@ -174,4 +174,3 @@ U0 Morse()
|
|||
}
|
||||
|
||||
Morse;
|
||||
|
|
@ -38,7 +38,7 @@ Bool SuggestSpelling(U8 *word)
|
|||
if (len)
|
||||
while (*dict) {
|
||||
wf=SuggestMatchForm(dict+1);
|
||||
if (!StrNCmp(pf,wf,len)) {
|
||||
if (!StrNCompare(pf,wf,len)) {
|
||||
"%16s",dict+1;
|
||||
if (++col>=num_cols) {
|
||||
col=0;
|
||||
|
|
|
@ -84,7 +84,7 @@ U8 *TOSLinkCvt2(U8 *filename,I64 line_num)
|
|||
U8 *res=NULL,*st;
|
||||
if (filename) {
|
||||
st=ExtChange(filename,"html");
|
||||
if (st && StrLen(st)>3 && !StrNCmp(st+1,":/",2))
|
||||
if (st && StrLen(st)>3 && !StrNCompare(st+1,":/",2))
|
||||
res=MStrPrint("http://www.templeos.org/Wb/%s#l%d",st+3,line_num);
|
||||
Free(st);
|
||||
}
|
||||
|
@ -94,7 +94,7 @@ U8 *TOSLinkCvt2(U8 *filename,I64 line_num)
|
|||
U8 *URLBibleGateway(U8 *src)
|
||||
{
|
||||
U8 buf[STR_LEN],*dst=buf;
|
||||
if (!MemCmp(src,"BF:",3))
|
||||
if (!MemCompare(src,"BF:",3))
|
||||
src+=3;
|
||||
while (*src) {
|
||||
if (*src==CH_SPACE || *src==',')
|
||||
|
@ -265,10 +265,10 @@ public CDoc *Doc2Html(CDoc *doc_in,U8 *html_header=NULL,U8 *body_header=NULL,
|
|||
case DOCT_TEXT:
|
||||
if (doc_e->de_flags&DOCEF_HIGHLIGHT) {
|
||||
if (doc_e->last==doc_in)
|
||||
MemCpy(&doc_e->settings,&doc_in->settings_head,
|
||||
MemCopy(&doc_e->settings,&doc_in->settings_head,
|
||||
sizeof(CDocSettings));
|
||||
else
|
||||
MemCpy(&doc_e->settings,&doc_e->last->settings,
|
||||
MemCopy(&doc_e->settings,&doc_e->last->settings,
|
||||
sizeof(CDocSettings));
|
||||
src=hl=DocHighlight(doc_e,doc_e->tag,StrLen(doc_e->tag),
|
||||
doc_e->type&0xFF00);
|
||||
|
@ -377,7 +377,7 @@ public U0 ToHtml(U8 *_in_name,U8 *_out_name=NULL,U8 *html_header=NULL,
|
|||
doc_in=DocRead(in_name);
|
||||
doc_out=Doc2Html(doc_in,html_header,body_header,body_footer,html_footer,
|
||||
line_anchors,link_cvt,line_nums);
|
||||
StrCpy(&doc_out->filename.name,out_name);
|
||||
StrCopy(&doc_out->filename.name,out_name);
|
||||
|
||||
SettingsPop;
|
||||
|
||||
|
|
|
@ -88,7 +88,7 @@ U0 ParseSingleLogFile(LogStruct *head,U8 *name,CDate *_dstart,CDate *_dend)
|
|||
|
||||
if (*src++!=CH_SPACE) throw;
|
||||
if (*src++!='\"') throw;
|
||||
if (!StrNCmp(src,"GET ",4)) {
|
||||
if (!StrNCompare(src,"GET ",4)) {
|
||||
src2=src+=4;
|
||||
do if (!*src2) throw;
|
||||
while (*src2++!=CH_SPACE);
|
||||
|
@ -113,7 +113,7 @@ U0 ParseSingleLogFile(LogStruct *head,U8 *name,CDate *_dstart,CDate *_dend)
|
|||
src=++src2;
|
||||
|
||||
QueueInsert(tmplg,head->last);
|
||||
} else if (!StrNCmp(src,"HEAD ",5)) {
|
||||
} else if (!StrNCompare(src,"HEAD ",5)) {
|
||||
LogStructDel(tmplg);
|
||||
} else
|
||||
throw;
|
||||
|
@ -211,7 +211,7 @@ Bool IsDownLoad(LogStruct *tmplg)
|
|||
|
||||
Bool IsIndex(LogStruct *tmplg)
|
||||
{
|
||||
if (!StrCmp(tmplg->file,"/index.html") || !StrCmp(tmplg->file,"/"))
|
||||
if (!StrCompare(tmplg->file,"/index.html") || !StrCompare(tmplg->file,"/"))
|
||||
return TRUE;
|
||||
else
|
||||
return FALSE;
|
||||
|
@ -222,8 +222,8 @@ Bool IsKeeper(LogStruct *tmplg,CDate dstart,CDate dend)
|
|||
if (dstart<=tmplg->datetime<=dend && !StrOcc(tmplg->file,'?') &&
|
||||
StrLen(tmplg->file)>2 && 'A'<=tmplg->file[1]<='Z' &&
|
||||
tmplg->size && tmplg->file[StrLen(tmplg->file)-1]!='/' &&
|
||||
(StrLen(tmplg->file)<3 || MemCmp(&tmplg->file[1],"Wb",2)) &&
|
||||
(StrLen(tmplg->file)<7 || MemCmp(&tmplg->file[1],"Family",6))) {
|
||||
(StrLen(tmplg->file)<3 || MemCompare(&tmplg->file[1],"Wb",2)) &&
|
||||
(StrLen(tmplg->file)<7 || MemCompare(&tmplg->file[1],"Family",6))) {
|
||||
return TRUE;
|
||||
|
||||
} else
|
||||
|
@ -261,7 +261,7 @@ U0 LinkTreeAdd(LinkStruct **_root,LogStruct *tmplg)
|
|||
throw;
|
||||
}
|
||||
if (root=*_root) {
|
||||
if (!(i=StrCmp(tmplg->link,root->link)))
|
||||
if (!(i=StrCompare(tmplg->link,root->link)))
|
||||
root->count++;
|
||||
else if (i<0)
|
||||
LinkTreeAdd(&root->left,tmplg);
|
||||
|
@ -284,7 +284,7 @@ U0 FileTreeAdd(LinkStruct **_root,LogStruct *tmplg)
|
|||
throw;
|
||||
}
|
||||
if (root=*_root) {
|
||||
if (!(i=StrCmp(tmplg->file,root->file)))
|
||||
if (!(i=StrCompare(tmplg->file,root->file)))
|
||||
root->count++;
|
||||
else if (i<0)
|
||||
FileTreeAdd(&root->left,tmplg);
|
||||
|
@ -514,7 +514,7 @@ U0 WebLogRep(U8 *mask,U8 *output_filename)
|
|||
FileRep(head,dstart,dend);
|
||||
DownLoadRep(head,dstart,dend);
|
||||
|
||||
StrCpy(DocPut->filename.name,output_filename);
|
||||
StrCopy(DocPut->filename.name,output_filename);
|
||||
DocWrite(DocPut,TRUE);
|
||||
|
||||
"$$WW,1$$";
|
||||
|
|
|
@ -49,7 +49,7 @@ U0 Search(I64 dx,I64 dy)
|
|||
for (i=n;i>2;i--) {
|
||||
buf[i]=0;
|
||||
if ((ptr=ACDWordPtAt(buf)) && *ptr++==ACD_WORD_CHAR &&
|
||||
!StrICmp(ptr,buf)) {
|
||||
!StrICompare(ptr,buf)) {
|
||||
"%s ",buf;
|
||||
}
|
||||
}
|
||||
|
@ -87,7 +87,7 @@ U0 CollectWords(I64 dx,I64 dy,I64 *_n)
|
|||
|
||||
I64 WordsCompare(U8 *e1,U8 *e2)
|
||||
{
|
||||
return StrCmp(e1,e2);
|
||||
return StrCompare(e1,e2);
|
||||
}
|
||||
|
||||
/*Format of word list entry:
|
||||
|
@ -113,11 +113,11 @@ U0 DisplayWords(I64 n)
|
|||
if (!*w2) {
|
||||
if (StrLen(dict+1)>2) {
|
||||
k=i;
|
||||
while (k<n && !StrNICmp(word_ptrs[k++],dict+1,StrLen(dict+1)))
|
||||
while (k<n && !StrNICompare(word_ptrs[k++],dict+1,StrLen(dict+1)))
|
||||
"%s ",dict+1;
|
||||
}
|
||||
w2=dict+1;
|
||||
while (!StrICmp(w2,dict+1))
|
||||
while (!StrICompare(w2,dict+1))
|
||||
dict+=StrLen(dict+1)+4;
|
||||
} else
|
||||
dict+=StrLen(dict+1)+4;
|
||||
|
|
|
@ -8,7 +8,7 @@ I, $FG,2$Terry A. Davis$FG$, wrote all of ZenithOS over the past $TX,"13.9",D="D
|
|||
|
||||
*) $LK,"ATA Reg and Cmd Definitions",A="MN:ATA_NOP"$ are originally from Linux. Later, I got the spec.
|
||||
|
||||
*) The heap algorithm, $LK,"::/Kernel/Mem/MAllocFree.HC"$, is adapted from one I saw at Ticketmaster when I worked on their VAX operating system.
|
||||
*) The heap algorithm, $LK,"::/Kernel/Memory/MAllocFree.HC"$, is adapted from one I saw at Ticketmaster when I worked on their VAX operating system.
|
||||
|
||||
*) The LZW compression algorithm, $LK,"::/Kernel/Compress.HC"$, came from a magazine and I implemented it when I worked for Ticketmaster.
|
||||
|
||||
|
|
|
@ -4,6 +4,6 @@ If you have an $FG,2$@$FG$ as the first char of a define list entry, it is an al
|
|||
|
||||
Each task can load its own Define strings. Remember, when a $LK,"Hash",A="HI:Hash"$ table is searched for a string, if it is not found, the parent task's table is searched.
|
||||
|
||||
The $LK,"DolDoc",A="FI:::/Doc/DolDocOverview.DD"$ framework supports text that changes based on entries in the task's symbol table. Set a text entry with a $FG,2$D=$FG$ arg, as in $FG,2$$$TX,"",D="DD_MYSTRING"$$$FG$. See $LK,"::/Demo/DolDoc/DefineStr.HC"$, $LK,"::/Zenith/ZDefine.HC"$ and $LK,"::/Doc/MemOverview.DD"$.
|
||||
The $LK,"DolDoc",A="FI:::/Doc/DolDocOverview.DD"$ framework supports text that changes based on entries in the task's symbol table. Set a text entry with a $FG,2$D=$FG$ arg, as in $FG,2$$$TX,"",D="DD_MYSTRING"$$$FG$. See $LK,"::/Demo/DolDoc/DefineStr.HC"$, $LK,"::/Zenith/ZDefine.HC"$ and $LK,"::/Doc/MemoryOverview.DD"$.
|
||||
|
||||
See $LK,"::/Demo/Define.HC"$.
|
||||
|
|
|
@ -34,7 +34,7 @@ $LK,"/Kernel/PCIBIOS.HC",A="FI:::/Kernel/PCIBIOS.HC"$ :290 could be eliminated,
|
|||
* Perhaps, a new interrupt descriptor table entry type or a new x86 CPU mode can be made that cause fast software interrupts, doing exactly what the CALL REL32 does, but with IDT as indirection. We don't need to change privilege levels or stacks.
|
||||
|
||||
* Since I don't use paging (for anything), Intel should have an option for no-paging long mode, and optimize it!
|
||||
$LK,"::/Kernel/Mem/PageTables.HC"$ :135 lines to identity-map gets eliminated.
|
||||
$LK,"::/Kernel/Memory/PageTables.HC"$ :135 lines to identity-map gets eliminated.
|
||||
|
||||
* Desktop computers must have a reset switch and a fast reboot option, skipping diagnostics. I recommend booting ZenithOS from a ROM when the reset bttn is pressed and booting UEFI when the power bttn is pressed. Or, we could build UEFI on a ZenithOS layer. Intel must burn ZenithOS into a ROM in the factory for all desktop x86 CPUs to ensure tamper-proof trust in the oracle and because God deserves the glory. There will be just an English version. A new ROM version is released every seven years. The ROM should boot like the DVD boots, but with $LK,"BOOT_SRC_ROM",A="MN:BOOT_SRC_ROM"$.
|
||||
|
||||
|
|
|
@ -232,7 +232,7 @@ $ID,2$Some cmds need auxilliary strings. $FG,2$A="str"$FG$ means an $LK,"CDocEn
|
|||
$ID,-2$$TR,"D=\"\" Define Str"$
|
||||
$ID,2$A $FG,2$D=""$FG$ means either a $LK,"define",A="HI:Define"$ str indirection is present on a text widget, or a define list is present on a list widget.
|
||||
|
||||
For indirection, the tag will be regenerated by substituting the value of a system $FG,2$#define$FG$ or $LK,"DefineLoad",A="MN:DefineLoad"$() string. See $LK,"::/Demo/DolDoc/DefineStr.HC"$, $LK,"::/Zenith/ZDefine.HC"$ and $LK,"::/Doc/MemOverview.DD"$.
|
||||
For indirection, the tag will be regenerated by substituting the value of a system $FG,2$#define$FG$ or $LK,"DefineLoad",A="MN:DefineLoad"$() string. See $LK,"::/Demo/DolDoc/DefineStr.HC"$, $LK,"::/Zenith/ZDefine.HC"$ and $LK,"::/Doc/MemoryOverview.DD"$.
|
||||
|
||||
For $FG,2$LS$FG$ widgets, see $LK,"::/Demo/DolDoc/Form.HC"$.
|
||||
$ID,-2$$TR,"HTML=\"\""$
|
||||
|
|
|
@ -39,13 +39,13 @@ $ID,2$The refresh rate is $TX,"(30000.0/1001)",D="WINMGR_FPS"$ frames-per-second
|
|||
$ID,-2$$TR,"How does a task own the speaker?"$
|
||||
$ID,2$No task or application has a lock on the speaker so apps will interfere with each other.
|
||||
$ID,-2$$TR,"Why does it leak memory?"$
|
||||
$ID,2$ZenithOS allocs mem as more items are displayed in the window. Also, ZenithOS allocs mem for code as it is compiled at the cmd line. If you $FG,2$#include$FG$ a file twice, it allocs more mem for it. If you have a 50,000 line program with each line taking twenty bytes on a machine with 1 Gig, you could $FG,2$#include$FG$ it a thousand times if it had no data or graphics and no other use of mem. If it bothers you, hit $FG,2$<CTRL-ALT-x>$FG$ and $FG,2$<CTRL-ALT-t>, $FG$periodically, to kill and recreate the task$FG$. Use the pop-up flag on macros in your $LK,"PersonalMenu",A="FI:::Home/PersonalMenu.DD"$ to spawn new tasks, run applications and free the applications when they are finished. Small mem chunks stick to the task when they are freed until it is killed. The only way to get in trouble is allocating multiple Meg chunks and freeing them. These can only be reused if the same size gets alloced again. Use $LK,"HeapLog",A="MN:HeapLog"$(), $LK,"HeapLogAddrRep",A="MN:HeapLogAddrRep"$() and $LK,"HeapLogSizeRep",A="MN:HeapLogSizeRep"$() to see who alloced mem and didn't free it. See $LK,"MemOverview",A="FI:::/Doc/MemOverview.DD"$.
|
||||
$ID,2$ZenithOS allocs mem as more items are displayed in the window. Also, ZenithOS allocs mem for code as it is compiled at the cmd line. If you $FG,2$#include$FG$ a file twice, it allocs more mem for it. If you have a 50,000 line program with each line taking twenty bytes on a machine with 1 Gig, you could $FG,2$#include$FG$ it a thousand times if it had no data or graphics and no other use of mem. If it bothers you, hit $FG,2$<CTRL-ALT-x>$FG$ and $FG,2$<CTRL-ALT-t>, $FG$periodically, to kill and recreate the task$FG$. Use the pop-up flag on macros in your $LK,"PersonalMenu",A="FI:::Home/PersonalMenu.DD"$ to spawn new tasks, run applications and free the applications when they are finished. Small mem chunks stick to the task when they are freed until it is killed. The only way to get in trouble is allocating multiple Meg chunks and freeing them. These can only be reused if the same size gets alloced again. Use $LK,"HeapLog",A="MN:HeapLog"$(), $LK,"HeapLogAddrRep",A="MN:HeapLogAddrRep"$() and $LK,"HeapLogSizeRep",A="MN:HeapLogSizeRep"$() to see who alloced mem and didn't free it. See $LK,"MemoryOverview",A="FI:::/Doc/MemoryOverview.DD"$.
|
||||
$ID,-2$$TR,"Why do I get a memory leak when editing big files?"$
|
||||
$ID,2$The editor periodically takes a snap-shot of the document for $FG,2$UNDO$FG$ and this looks like a memory leak.
|
||||
$ID,-2$$TR,"Why is it in text mode?"$
|
||||
$ID,2$ZenithOS runs in $FG,2$VGA 640x480 16 color$FG$ graphics mode, not text mode. It changes to this mode with a $LK,"BIOS call",A="FF:::/Kernel/KStart16.HC,INT 0x10"$ while in real-mode before it switches to 64-bit mode. The text is $LK,"drawn by hand",A="MN:GrUpdateTextFG"$. See $LK,"::/Kernel/FontStd.HC"$. If graphics mode fails, it falls-back on text mode. You can force text mode with an $LK,"Kernel config",A="FI:::/Kernel/KConfig.HC"$ option.
|
||||
$ID,-2$$TR,"Where is the kernel memory?"$
|
||||
$ID,2$ZenithOS identity-maps all memory, all the time. It is like paging is not used. There is no special kernel $FG,2$high half$FG$ memory space. ZenithOS is ring-0-only, so everything is kernel, even user programs. There is a special task called $FG,2$Zenith$FG$ and he doesn't die, so his heap never gets freed. That's as close to $FG,2$kernel memory$FG$ as it gets. All code goes in the lowest 2Gig of addresses, known as the $LK,"Code Heap",A="FF:::/Doc/Glossary.DD,Code and Data Heaps"$, so that the $FG,2$REL32$FG$ addressing mode can be used. See $LK,"MemOverview",A="FI:::/Doc/MemOverview.DD"$.
|
||||
$ID,2$ZenithOS identity-maps all memory, all the time. It is like paging is not used. There is no special kernel $FG,2$high half$FG$ memory space. ZenithOS is ring-0-only, so everything is kernel, even user programs. There is a special task called $FG,2$Zenith$FG$ and he doesn't die, so his heap never gets freed. That's as close to $FG,2$kernel memory$FG$ as it gets. All code goes in the lowest 2Gig of addresses, known as the $LK,"Code Heap",A="FF:::/Doc/Glossary.DD,Code and Data Heaps"$, so that the $FG,2$REL32$FG$ addressing mode can be used. See $LK,"MemoryOverview",A="FI:::/Doc/MemoryOverview.DD"$.
|
||||
$ID,-2$$TR,"Why does it run code from stack addresses?"$
|
||||
$ID,2$ZenithOS puts all code in the lowest 2Gig, known as the $LK,"Code Heap",A="FF:::/Doc/Glossary.DD,Code and Data Heaps"$, so that the $FG,2$REL32$FG$ addressing mode can be used. ZenithOS is 64-bit, but $FG,2$2Gig$FG$ is enough for code. It actually puts global variables there, too, but you can turn that off with $LK,"OPTf_GLBLS_ON_DATA_HEAP",A="MN:OPTf_GLBLS_ON_DATA_HEAP"$. $LK,"MAlloc",A="MN:MAlloc"$() allocs higher memory.
|
||||
$ID,-2$$TR,"How does it SYSCALL?"$
|
||||
|
|
Binary file not shown.
|
@ -8,16 +8,16 @@ You can create new, independent heaps using $LK,"HeapCtrlInit",A="MN:HeapCtrlIni
|
|||
|
||||
Memory alloced by a task will be freed when the task is killed. The $LK,"Zenith Task",A="FF:::/Doc/Glossary.DD,Zenith Task"$ is a task that never dies. His memory is like kernel memory in other operating systems. See $LK,"ZCAlloc",A="MN:ZCAlloc"$(), $LK,"ZMAlloc",A="MN:ZMAlloc"$(), $LK,"ZMAllocIdent",A="MN:ZMAllocIdent"$() and $LK,"ZStrNew",A="MN:ZStrNew"$().
|
||||
|
||||
All of the regular page tables are marked, "cached". When accessing hardware, however, you need uncached page table. The lowest 4Gig addresses have an alias to access hardware located toward the top of mapped space, $FG,2$0x$TX,"01AA000000",D="DD_UNCACHED_ALIAS"$$FG$. See $LK,"dev.uncached_alias",A="FF:::/Kernel/KMain.HC,dev.uncached_alias"$.
|
||||
All of the regular page tables are marked, "cached". When accessing hardware, however, you need uncached page table. The lowest 4Gig addresses have an alias to access hardware located toward the top of mapped space, $FG,2$0x$TX,"01A0000000",D="DD_UNCACHED_ALIAS"$$FG$. See $LK,"dev.uncached_alias",A="FF:::/Kernel/KMain.HC,dev.uncached_alias"$.
|
||||
|
||||
During an extended powered-on session of ZenithOS, in theory, memory will become fragmented, requiring a reboot. It has never happens to me.
|
||||
|
||||
See $LK,"MemRep",A="MN:MemRep"$() and $LK,"::/Demo/MemDemo.HC"$.
|
||||
|
||||
|
||||
$FG,5$$TX+CX,"Single System-wide Mem Map"$
|
||||
$FG,5$$TX+CX,"Single System-wide Memory Map"$
|
||||
|
||||
$FG,2$ 0x00$TX,"00007C00",D="DD_KERNEL"$- 0x00$TX,"00036AEF",D="DD_KERNEL_END"$$FG$
|
||||
$FG,2$ 0x00$TX,"00007C00",D="DD_KERNEL"$- 0x00$TX,"0003637F",D="DD_KERNEL_END"$$FG$
|
||||
$ID,2$Kernel module, placed here by the boot-loader, $LK,"BOOT_RAM_BASE",A="MN:BOOT_RAM_BASE"$.
|
||||
$ID,-2$
|
||||
$FG,2$ 0x00$TX,"00096600",D="DD_BOOT_HIGH_LOC_DVD"$- 0x00$TX,"00096FFF",D="DD_BOOT_HIGH_LOC_DVD_END"$$FG$
|
||||
|
@ -33,13 +33,13 @@ $FG,2$ 0x00E0000000- 0x00FFFFFFFF$FG$
|
|||
$ID,2$32-bit devices could alloc memory at 0xF0000000 going up, but this is wrong, since some PCs already have devices at 0xF0000000. No PCI devices are supported, so $LK,"Mem32DevAlloc",A="MN:Mem32DevAlloc"$() flaws are not an issue.
|
||||
$ID,-2$
|
||||
$FG,2$ 0x0080000000-~0x00DFFFFFFF$FG$
|
||||
$FG,2$ 0x0100000000-~0x$TX,"01A9FFFFFF",D="DD_PHYSICAL_SPACE_END"$$FG$
|
||||
$FG,2$ 0x0100000000-~0x$TX,"019FFFFFFF",D="DD_PHYSICAL_SPACE_END"$$FG$
|
||||
$ID,2$Data Heap mem. (The physical memory that exists in this range is data heap.)
|
||||
$ID,-2$
|
||||
$FG,2$ 0x$TX,"01AA000000",D="DD_UNCACHED_ALIAS"$- 0x$TX,"02A9FFFFFF",D="DD_MAPPED_SPACE_END"$$FG$
|
||||
$FG,2$ 0x$TX,"01A0000000",D="DD_UNCACHED_ALIAS"$- 0x$TX,"029FFFFFFF",D="DD_MAPPED_SPACE_END"$$FG$
|
||||
$ID,2$Uncached alias of first 4Gig. (For 32-bit device access.)
|
||||
$ID,-2$
|
||||
$FG,2$ - 0x$TX,"02A9FFFFFF",D="DD_MAPPED_SPACE_END"$$FG$
|
||||
$FG,2$ - 0x$TX,"029FFFFFFF",D="DD_MAPPED_SPACE_END"$$FG$
|
||||
$ID,2$64-bit devices are alloced with $LK,"Mem64DevAlloc",A="MN:Mem64DevAlloc"$() counting bwd, but no PCI devices are actually supported$WW,0$.
|
||||
$ID,-2$
|
||||
|
|
@ -26,7 +26,7 @@ $ID,-2$
|
|||
|
||||
* A $FG,2$goto$FG$ label name must not match a global scope object's name. (It's not worth slowing-down the compiler to handle this case.)
|
||||
|
||||
* $LK,"MemCpy",A="MN:MemCpy"$() only goes fwd.
|
||||
* $LK,"MemCopy",A="MN:MemCopy"$() only goes fwd.
|
||||
|
||||
* A $LK,"Cd",A="MN:Cd"$() cmd must be followed by two semicolons if a $FG,2$#include$FG$ is after it. This is because the preprocessor processes the next token ahead.
|
||||
|
||||
|
|
|
@ -129,7 +129,7 @@ Bool MyPutKey(I64 ch,I64 sc)
|
|||
ClipDel;
|
||||
st1=FileNameAbs(BIBLE_FILENAME);
|
||||
st2=FileNameAbs(DocPut->filename.name);
|
||||
if (!StrCmp(st1,st2)) {
|
||||
if (!StrCompare(st1,st2)) {
|
||||
Free(st1);
|
||||
st1=BibleLine2Verse(DocPut->cur_entry->y+1,',');
|
||||
DocPrint(sys_clip_doc,"$$LK,\"BF:%s\"$$",st1);
|
||||
|
|
BIN
src/Kernel.BIN.C
BIN
src/Kernel.BIN.C
Binary file not shown.
|
@ -437,7 +437,7 @@ U0 ATAPIReadBlks(CBlkDev *bd,U8 *buf, I64 blk, I64 count)
|
|||
ATAPIReadBlks2(bd,0,dvd_buf,blk2/spc,n,TRUE);
|
||||
if (bd->flags & BDF_READ_CACHE)
|
||||
DiskCacheAdd(drive,dvd_buf,blk2,n*spc);
|
||||
MemCpy(buf,dvd_buf+(blk-blk2)<<BLK_SIZE_BITS,count<<BLK_SIZE_BITS);
|
||||
MemCopy(buf,dvd_buf+(blk-blk2)<<BLK_SIZE_BITS,count<<BLK_SIZE_BITS);
|
||||
}
|
||||
Free(dvd_buf);
|
||||
}
|
||||
|
|
|
@ -6,7 +6,7 @@ U0 BlkWriteZero(CDrive *drive,I64 blk,I64 count)
|
|||
Bool show_progress;
|
||||
if (count>ZERO_BUF_SIZE && drive->bd->type!=BDT_RAM) {
|
||||
progress1=0; progress1_max=count;
|
||||
StrCpy(progress1_desc,"Zeroing");
|
||||
StrCopy(progress1_desc,"Zeroing");
|
||||
show_progress=TRUE;
|
||||
} else
|
||||
show_progress=FALSE;
|
||||
|
@ -45,7 +45,7 @@ Bool BlkRead(CDrive *drive,U8 *buf, I64 blk, I64 count)
|
|||
if (count>0) {
|
||||
switch (bd->type) {
|
||||
case BDT_RAM:
|
||||
MemCpy(buf,bd->RAM_disk+blk<<BLK_SIZE_BITS,count<<BLK_SIZE_BITS);
|
||||
MemCopy(buf,bd->RAM_disk+blk<<BLK_SIZE_BITS,count<<BLK_SIZE_BITS);
|
||||
break;
|
||||
case BDT_ISO_FILE_READ:
|
||||
case BDT_ISO_FILE_WRITE:
|
||||
|
@ -85,7 +85,7 @@ Bool BlkWrite(CDrive *drive,U8 *buf, I64 blk, I64 count)
|
|||
if (count>0) {
|
||||
switch (bd->type) {
|
||||
case BDT_RAM:
|
||||
MemCpy(bd->RAM_disk+blk<<BLK_SIZE_BITS,buf,count<<BLK_SIZE_BITS);
|
||||
MemCopy(bd->RAM_disk+blk<<BLK_SIZE_BITS,buf,count<<BLK_SIZE_BITS);
|
||||
break;
|
||||
case BDT_ISO_FILE_READ:
|
||||
case BDT_ISO_FILE_WRITE:
|
||||
|
|
|
@ -27,7 +27,7 @@ Bool ISOInit(CDrive *drive,I64 blk)
|
|||
case ISOT_SUPPLEMENTARY_DESC:
|
||||
de=&iso->root_dir_record;
|
||||
drive->size=iso->vol_space_size.little*bd->blk_size>>BLK_SIZE_BITS;
|
||||
if (!StrCmp(iso->publisher_id,"ZenithOS RedSea")) {
|
||||
if (!StrCompare(iso->publisher_id,"ZenithOS RedSea")) {
|
||||
drive->fs_type=FSt_REDSEA;
|
||||
bd->drv_offset=drive->drv_offset=19<<2+drv_offset;
|
||||
bd->max_blk=drive->size-1;
|
||||
|
@ -192,7 +192,7 @@ U0 DVDImageWrite(U8 dvd_drive_let,U8 *in_name=NULL,I64 media_type=MT_DVD)
|
|||
ATAPIWaitReady(bd,0);
|
||||
|
||||
progress1=0; progress1_max=count;
|
||||
StrCpy(progress1_desc,"Writing");
|
||||
StrCopy(progress1_desc,"Writing");
|
||||
while (count>0) {
|
||||
if (count>COPY_BUF_BLKS)
|
||||
n=COPY_BUF_BLKS;
|
||||
|
@ -215,7 +215,7 @@ U0 DVDImageWrite(U8 dvd_drive_let,U8 *in_name=NULL,I64 media_type=MT_DVD)
|
|||
ATAPISync(bd);
|
||||
|
||||
progress1=0; progress1_max=2;
|
||||
StrCpy(progress1_desc,"Closing");
|
||||
StrCopy(progress1_desc,"Closing");
|
||||
for (i=0;i<2;i++) {
|
||||
ATAPIClose(bd,0x100,i); //Close tracks
|
||||
progress1++;
|
||||
|
|
|
@ -46,7 +46,7 @@ CFile *FOpen(U8 *filename,U8 *flags,I64 count=0)
|
|||
f->de.full_name=full_name;
|
||||
f->flags|=FF_NEW_FILE;
|
||||
if (dirc=DirContextNew(full_name)) {
|
||||
StrCpy(f->de.name,dirc->mask);
|
||||
StrCopy(f->de.name,dirc->mask);
|
||||
if (count>0) {//We pre-alloc the whole thing.
|
||||
f->de.clus=ClusAlloc(f->drive,0,
|
||||
(count+f->drive->spc-1)/f->drive->spc,contiguous);
|
||||
|
@ -155,21 +155,21 @@ Bool FBlkRead(CFile *f,U8 *buf,I64 blk=FFB_NEXT_BLK,I64 count=1)
|
|||
j=count;
|
||||
else
|
||||
j=spc-i;
|
||||
MemCpy(buf,f->clus_buf+i<<BLK_SIZE_BITS,j<<BLK_SIZE_BITS);
|
||||
MemCopy(buf,f->clus_buf+i<<BLK_SIZE_BITS,j<<BLK_SIZE_BITS);
|
||||
buf+=j<<BLK_SIZE_BITS;
|
||||
count-=j;
|
||||
blk+=j;
|
||||
}
|
||||
while (count>=spc) {
|
||||
c=FSetClus(f,c,blk,TRUE);
|
||||
MemCpy(buf,f->clus_buf,spc<<BLK_SIZE_BITS);
|
||||
MemCopy(buf,f->clus_buf,spc<<BLK_SIZE_BITS);
|
||||
buf+=spc<<BLK_SIZE_BITS;
|
||||
count-=spc;
|
||||
blk+=spc;
|
||||
}
|
||||
if (count>0) {
|
||||
c=FSetClus(f,c,blk,TRUE);
|
||||
MemCpy(buf,f->clus_buf,count<<BLK_SIZE_BITS);
|
||||
MemCopy(buf,f->clus_buf,count<<BLK_SIZE_BITS);
|
||||
buf+=count<<BLK_SIZE_BITS;
|
||||
blk+=count;
|
||||
}
|
||||
|
@ -224,7 +224,7 @@ Bool FBlkWrite(CFile *f,U8 *buf,I64 blk=FFB_NEXT_BLK,I64 count=1)
|
|||
j=count;
|
||||
else
|
||||
j=spc-i;
|
||||
MemCpy(f->clus_buf+BLK_SIZE*i,buf,j<<BLK_SIZE_BITS);
|
||||
MemCopy(f->clus_buf+BLK_SIZE*i,buf,j<<BLK_SIZE_BITS);
|
||||
f->flags|=FF_BUF_DIRTY;
|
||||
buf+=j<<BLK_SIZE_BITS;
|
||||
count-=j;
|
||||
|
@ -238,7 +238,7 @@ Bool FBlkWrite(CFile *f,U8 *buf,I64 blk=FFB_NEXT_BLK,I64 count=1)
|
|||
}
|
||||
while (count>=spc) {
|
||||
FSetClus(f,c,blk,FALSE);
|
||||
MemCpy(f->clus_buf,buf,spc<<BLK_SIZE_BITS);
|
||||
MemCopy(f->clus_buf,buf,spc<<BLK_SIZE_BITS);
|
||||
f->flags|=FF_BUF_DIRTY;
|
||||
buf+=spc<<BLK_SIZE_BITS;
|
||||
count-=spc;
|
||||
|
@ -252,7 +252,7 @@ Bool FBlkWrite(CFile *f,U8 *buf,I64 blk=FFB_NEXT_BLK,I64 count=1)
|
|||
}
|
||||
if (count>0) {
|
||||
FSetClus(f,c,blk,TRUE);
|
||||
MemCpy(f->clus_buf,buf,count<<BLK_SIZE_BITS);
|
||||
MemCopy(f->clus_buf,buf,count<<BLK_SIZE_BITS);
|
||||
f->flags|=FF_BUF_DIRTY;
|
||||
buf+=count<<BLK_SIZE_BITS;
|
||||
blk+=count;
|
||||
|
|
|
@ -83,7 +83,7 @@ U0 DiskCacheAdd(CDrive *drive,U8 *buf, I64 blk, I64 count)
|
|||
if (!(tmpc=DiskCacheFind(drive,blk)))
|
||||
tmpc=blkdev.cache_ctrl->next_lru;
|
||||
DiskCacheQueueRemove(tmpc);
|
||||
MemCpy(&tmpc->body,buf,BLK_SIZE);
|
||||
MemCopy(&tmpc->body,buf,BLK_SIZE);
|
||||
tmpc->drive=drive;
|
||||
tmpc->blk=blk;
|
||||
DiskCacheQueueIns(tmpc);
|
||||
|
@ -125,7 +125,7 @@ U0 RCache(CDrive *drive,U8 **_buf, I64 *_blk, I64 *_count)
|
|||
//fetch leading blks from cache
|
||||
while (*_count>0) {
|
||||
if (tmpc=DiskCacheFind(drive,*_blk)) {
|
||||
MemCpy(*_buf,&tmpc->body,BLK_SIZE);
|
||||
MemCopy(*_buf,&tmpc->body,BLK_SIZE);
|
||||
*_count-=1;
|
||||
*_buf+=BLK_SIZE;
|
||||
*_blk+=1;
|
||||
|
@ -135,7 +135,7 @@ U0 RCache(CDrive *drive,U8 **_buf, I64 *_blk, I64 *_count)
|
|||
//fetch trailing blks from cache
|
||||
while (*_count>0) {
|
||||
if (tmpc=DiskCacheFind(drive,*_blk+*_count-1)) {
|
||||
MemCpy(*_buf+(*_count-1)<<BLK_SIZE_BITS,&tmpc->body,BLK_SIZE);
|
||||
MemCopy(*_buf+(*_count-1)<<BLK_SIZE_BITS,&tmpc->body,BLK_SIZE);
|
||||
*_count-=1;
|
||||
} else
|
||||
break;
|
||||
|
|
|
@ -25,7 +25,7 @@ Bool CopySingle(U8 *f1,U8 *f2) //Just one file
|
|||
U8 *absf1=FileNameAbs(f1),*absf2=FileNameAbs(f2),*buf;
|
||||
I64 count,n,size,attr1=FileAttr(f1),attr2=FileAttr(f2),i,j;
|
||||
CFile *in_file=NULL,*out_file=NULL;
|
||||
if (!StrCmp(absf1,absf2)) {//onto self?
|
||||
if (!StrCompare(absf1,absf2)) {//onto self?
|
||||
Free(absf1);
|
||||
Free(absf2);
|
||||
return FALSE;
|
||||
|
|
|
@ -68,13 +68,13 @@ I64 DirEntryCompareName(CDirEntry *e1,CDirEntry *e2)
|
|||
if (d1!=d2)
|
||||
return d2-d1;
|
||||
else {
|
||||
StrCpy(buf1,e1->name);
|
||||
StrCpy(buf2,e2->name);
|
||||
StrCopy(buf1,e1->name);
|
||||
StrCopy(buf2,e2->name);
|
||||
FileExtRemove(buf1,buf3);
|
||||
FileExtRemove(buf2,buf4);
|
||||
if (d1=StrCmp(buf3,buf4))
|
||||
if (d1=StrCompare(buf3,buf4))
|
||||
return d1;
|
||||
return StrCmp(buf1,buf2);
|
||||
return StrCompare(buf1,buf2);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -35,22 +35,22 @@ Bool Cd(U8 *dirname=NULL,Bool make_dirs=FALSE)
|
|||
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);
|
||||
StrCopy(new_cur_dir,Fs->cur_dir);
|
||||
while (*chg_to_buf && res) {
|
||||
StrFirstRemove(chg_to_buf,"/",buf);
|
||||
if (!*buf)
|
||||
StrCpy(new_cur_dir,"/");
|
||||
else if (!StrCmp(buf,"..")) {
|
||||
StrCopy(new_cur_dir,"/");
|
||||
else if (!StrCompare(buf,"..")) {
|
||||
StrLastRemove(new_cur_dir,"/");
|
||||
if (!*new_cur_dir)
|
||||
StrCpy(new_cur_dir,"/");
|
||||
} else if (!StrCmp(buf,"~")) {
|
||||
StrCopy(new_cur_dir,"/");
|
||||
} else if (!StrCompare(buf,"~")) {
|
||||
Free(new_cur_dir);
|
||||
new_cur_dir=MAlloc(StrLen(blkdev.home_dir+2)+1+StrLen(chg_to_buf)+1);
|
||||
StrCpy(new_cur_dir,blkdev.home_dir+2);
|
||||
StrCopy(new_cur_dir,blkdev.home_dir+2);
|
||||
if (Fs->cur_dv!=Letter2Drive('~') && !Drive('~'))
|
||||
return FALSE;
|
||||
} else if (StrCmp(buf,".") && *buf) {
|
||||
} else if (StrCompare(buf,".") && *buf) {
|
||||
drive=Fs->cur_dv;
|
||||
cur_dir_clus=Name2DirClus(drive,new_cur_dir);
|
||||
switch (drive->fs_type) {
|
||||
|
@ -70,7 +70,7 @@ Bool Cd(U8 *dirname=NULL,Bool make_dirs=FALSE)
|
|||
res=DirMk(buf);
|
||||
}
|
||||
if (res) {
|
||||
if (StrCmp(new_cur_dir,"/"))
|
||||
if (StrCompare(new_cur_dir,"/"))
|
||||
CatPrint(new_cur_dir,"/");
|
||||
CatPrint(new_cur_dir,buf);
|
||||
}
|
||||
|
@ -114,7 +114,7 @@ I64 Dir(U8 *files_find_mask,Bool full)
|
|||
st=MAllocIdent(tmpde1->full_name);
|
||||
StrLastRemove(st,"/");
|
||||
if (!st[2])
|
||||
StrCpy(st+2,"/");
|
||||
StrCopy(st+2,"/");
|
||||
//Find max columns
|
||||
tmpde2=tmpde1;
|
||||
while (tmpde2) {
|
||||
|
|
|
@ -41,14 +41,14 @@ CDirContext *DirContextNew(U8 *_mask,Bool make_mask=FALSE,
|
|||
dirc->drive=Fs->cur_dv;
|
||||
DriveCheck(dirc->drive);
|
||||
buf=MAlloc(mask_len+2);
|
||||
StrCpy(buf,mask);
|
||||
StrCopy(buf,mask);
|
||||
|
||||
dirc->mask=MAlloc(mask_len+2);
|
||||
if (no_mask)
|
||||
*dirc->mask=0;
|
||||
else if (StrOcc(buf,';')) {
|
||||
semicolon_mask=MAlloc(mask_len+2);
|
||||
StrCpy(semicolon_mask,mask);
|
||||
StrCopy(semicolon_mask,mask);
|
||||
StrFirstRemove(semicolon_mask,";",buf);
|
||||
StrLastRemove(buf,"/",dirc->mask);
|
||||
CatPrint(dirc->mask,";%s",semicolon_mask);
|
||||
|
@ -57,7 +57,7 @@ CDirContext *DirContextNew(U8 *_mask,Bool make_mask=FALSE,
|
|||
StrLastRemove(buf,"/",dirc->mask);
|
||||
|
||||
if (*mask=='/' && !*buf)
|
||||
StrCpy(buf,"/");
|
||||
StrCopy(buf,"/");
|
||||
//If began with Dir, change to Dir.
|
||||
if (*buf && !Cd(buf,make_dirs))
|
||||
valid=FALSE;
|
||||
|
|
|
@ -11,7 +11,7 @@ U8 *FileRead(U8 *filename,I64 *_size=NULL,I64 *_attr=NULL)
|
|||
(tmph=HashFind(altname,zenith_task->hash_table,HTT_FILE))) {
|
||||
size=tmph->user_data1;
|
||||
res=MAlloc(size+1);
|
||||
MemCpy(res,tmph->user_data0,size);
|
||||
MemCopy(res,tmph->user_data0,size);
|
||||
res[size]=0; //Terminate
|
||||
attr=FileAttr(tmph->str,attr);
|
||||
} else {
|
||||
|
@ -42,7 +42,7 @@ U8 *FileRead(U8 *filename,I64 *_size=NULL,I64 *_attr=NULL)
|
|||
else
|
||||
curname=altname;
|
||||
if (dirc=DirContextNew(curname)) {
|
||||
while (!res && StrCmp(Fs->cur_dir,"/")) {
|
||||
while (!res && StrCompare(Fs->cur_dir,"/")) {
|
||||
Cd("..");
|
||||
switch (Fs->cur_dv->fs_type) {
|
||||
case FSt_REDSEA:
|
||||
|
|
|
@ -92,7 +92,7 @@ Bool FileFind(U8 *filename,CDirEntry *_de=NULL,I64 fuf_flags=0)
|
|||
PrintErr("File System Not Supported\n");
|
||||
}
|
||||
if (res && _de) {
|
||||
if (StrCmp(Fs->cur_dir,"/"))
|
||||
if (StrCompare(Fs->cur_dir,"/"))
|
||||
full_name=MStrPrint("%C:%s/%s",
|
||||
Drive2Letter(Fs->cur_dv),Fs->cur_dir,de.name);
|
||||
else
|
||||
|
@ -112,7 +112,7 @@ Bool FileFind(U8 *filename,CDirEntry *_de=NULL,I64 fuf_flags=0)
|
|||
else {
|
||||
Silent(old_silent);
|
||||
cur_dir_clus=Name2DirClus(dirc->drive,Fs->cur_dir);
|
||||
while (!res && StrCmp(Fs->cur_dir,"/")) {
|
||||
while (!res && StrCompare(Fs->cur_dir,"/")) {
|
||||
Cd("..");
|
||||
cur_dir_clus=Name2DirClus(dirc->drive,Fs->cur_dir);
|
||||
switch (dirc->drive->fs_type) {
|
||||
|
@ -129,7 +129,7 @@ Bool FileFind(U8 *filename,CDirEntry *_de=NULL,I64 fuf_flags=0)
|
|||
}
|
||||
}
|
||||
if (res && _de) {
|
||||
if (StrCmp(Fs->cur_dir,"/"))
|
||||
if (StrCompare(Fs->cur_dir,"/"))
|
||||
full_name=MStrPrint("%C:%s/%s",
|
||||
Drive2Letter(Fs->cur_dv),Fs->cur_dir,de.name);
|
||||
else
|
||||
|
@ -141,7 +141,7 @@ Bool FileFind(U8 *filename,CDirEntry *_de=NULL,I64 fuf_flags=0)
|
|||
}
|
||||
if (_de) {
|
||||
if (res) {
|
||||
MemCpy(_de,&de,sizeof(CDirEntry));
|
||||
MemCopy(_de,&de,sizeof(CDirEntry));
|
||||
_de->full_name=full_name;
|
||||
} else
|
||||
MemSet(_de,0,sizeof(CDirEntry));
|
||||
|
|
|
@ -12,7 +12,7 @@ U8 *FileExtRemove(U8 *src,U8 *dst=NULL)
|
|||
U8 *ptr;
|
||||
if (ptr=FileExtDot(src)) {
|
||||
if (dst)
|
||||
StrCpy(dst,ptr+1);
|
||||
StrCopy(dst,ptr+1);
|
||||
*ptr=0;
|
||||
} else if (dst)
|
||||
*dst=0;
|
||||
|
@ -43,11 +43,11 @@ Bool FilesFindMatch(U8 *_test_name,U8 *files_find_mask,I64 fuf_flags=0)
|
|||
U8 *mask1=MAlloc(mask_len+1),*mask2=MAlloc(mask_len+1),
|
||||
*ptr,*test_name1,*test_name2;
|
||||
Bool res=FALSE;
|
||||
StrCpy(mask1,files_find_mask);
|
||||
StrCopy(mask1,files_find_mask);
|
||||
if (StrOcc(_test_name,'/')) {
|
||||
test_name1=MAlloc(tn_len+1);
|
||||
test_name2=MAlloc(tn_len+1);
|
||||
StrCpy(test_name1,_test_name);
|
||||
StrCopy(test_name1,_test_name);
|
||||
StrLastRemove(test_name1,"/",test_name2);
|
||||
} else {
|
||||
test_name1=NULL;
|
||||
|
@ -136,31 +136,31 @@ U8 *DirNameAbs(U8 *_dirname)
|
|||
maxlen=StrLen(buf)+1+StrLen(buf2)+1;
|
||||
buf3=MAlloc(maxlen);
|
||||
buf4=MAlloc(maxlen);
|
||||
StrCpy(buf3,buf);
|
||||
StrCopy(buf3,buf);
|
||||
while (*buf2) {
|
||||
StrFirstRemove(buf2,"/",buf4);
|
||||
if (!*buf4)
|
||||
StrCpy(buf3,"/");
|
||||
else if (!StrCmp(buf4,"..")) {
|
||||
StrCopy(buf3,"/");
|
||||
else if (!StrCompare(buf4,"..")) {
|
||||
StrLastRemove(buf3,"/");
|
||||
if (!*buf3)
|
||||
StrCpy(buf3,"/");
|
||||
} else if (!StrCmp(buf4,"~")) {
|
||||
StrCopy(buf3,"/");
|
||||
} else if (!StrCompare(buf4,"~")) {
|
||||
Free(buf3);
|
||||
buf3=MAlloc(StrLen(blkdev.home_dir+2)+1+StrLen(buf2)+1);
|
||||
StrCpy(buf3,blkdev.home_dir+2);
|
||||
StrCopy(buf3,blkdev.home_dir+2);
|
||||
*drv=*blkdev.home_dir;
|
||||
} else if (!StrCmp(buf4,"."));
|
||||
} else if (!StrCompare(buf4,"."));
|
||||
else if (*buf4) {
|
||||
if (StrCmp(buf3,"/"))
|
||||
if (StrCompare(buf3,"/"))
|
||||
CatPrint(buf3,"/");
|
||||
CatPrint(buf3,buf4);
|
||||
}
|
||||
}
|
||||
Free(buf);
|
||||
res=MAlloc(StrLen(buf3)+3);
|
||||
StrCpy(res,drv);
|
||||
StrCpy(res+2,buf3);
|
||||
StrCopy(res,drv);
|
||||
StrCopy(res+2,buf3);
|
||||
Free(buf2);
|
||||
Free(buf3);
|
||||
Free(buf4);
|
||||
|
@ -182,11 +182,11 @@ U8 *FileNameAbs(U8 *_filename,I64 fuf_flags=0)
|
|||
buf_file=MAlloc(StrLen(free_filename)+1);
|
||||
StrLastRemove(buf,"/",buf_file);
|
||||
if (*filename=='/' && !*buf)
|
||||
StrCpy(buf,"/");
|
||||
StrCopy(buf,"/");
|
||||
buf_dir=DirNameAbs(free_buf);
|
||||
Free(free_buf);
|
||||
res=MAlloc(StrLen(buf_dir)+1+StrLen(buf_file)+1);
|
||||
StrCpy(res,buf_dir);
|
||||
StrCopy(res,buf_dir);
|
||||
if (res[StrLen(res)-1]!='/')
|
||||
CatPrint(res,"/");
|
||||
CatPrint(res,buf_file);
|
||||
|
@ -203,7 +203,7 @@ U8 *FileNameAbs(U8 *_filename,I64 fuf_flags=0)
|
|||
U8 *ExtChange(U8 *filename,U8 *extension)
|
||||
{//Change filename extension.
|
||||
U8 *res=MAlloc(StrLen(filename)+1+StrLen(extension)+1);
|
||||
StrCpy(res,filename);
|
||||
StrCopy(res,filename);
|
||||
if (FileExtDot(filename))
|
||||
FileExtRemove(res);
|
||||
return CatPrint(res,".%s",extension);
|
||||
|
@ -212,7 +212,7 @@ U8 *ExtChange(U8 *filename,U8 *extension)
|
|||
U8 *ExtDefault(U8 *filename,U8 *extension)
|
||||
{//Give extension if has none.
|
||||
U8 *res=MAlloc(StrLen(filename)+1+StrLen(extension)+1);
|
||||
StrCpy(res,filename);
|
||||
StrCopy(res,filename);
|
||||
if (!FileExtDot(filename))
|
||||
CatPrint(res,".%s",extension);
|
||||
return res;
|
||||
|
@ -223,7 +223,7 @@ CDirEntry *Cd2DirEntry(CDirEntry *tmpde,U8 *abs_name)
|
|||
I64 i;
|
||||
while (tmpde) {
|
||||
i=StrLen(tmpde->full_name);
|
||||
if (StrNCmp(tmpde->full_name,abs_name,i)||
|
||||
if (StrNCompare(tmpde->full_name,abs_name,i)||
|
||||
i && tmpde->full_name[i-1]!='/' && abs_name[i] && abs_name[i]!='/')
|
||||
tmpde=tmpde->next;
|
||||
else
|
||||
|
@ -287,7 +287,7 @@ U8 *DirCur(CTask *task=NULL,CTask *mem_task=NULL)
|
|||
st=MAlloc(StrLen(task->cur_dir)+3,mem_task);
|
||||
*st=Drive2Letter(task->cur_dv);
|
||||
st[1]=':';
|
||||
StrCpy(st+2,task->cur_dir);
|
||||
StrCopy(st+2,task->cur_dir);
|
||||
return st;
|
||||
}
|
||||
|
||||
|
|
|
@ -3,7 +3,7 @@ Bool CFileNameTo(U8 *dst,U8 *src)
|
|||
MemSet(dst,0,CDIR_FILENAME_LEN);
|
||||
if (!FileNameCheck(src))
|
||||
return FALSE;
|
||||
StrCpy(dst,src);
|
||||
StrCopy(dst,src);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
|
|
@ -86,7 +86,7 @@ U0 FAT32Format(U8 drv_let,Bool quick=TRUE)
|
|||
br->log_drive_num=0x80;
|
||||
br->ext_signature=0x29;
|
||||
br->serial_num=RandU32;
|
||||
MemCpy(br->vol_name,"NONAME",11);
|
||||
MemCopy(br->vol_name,"NONAME",11);
|
||||
br->fat_name[0](I64)='FAT32';
|
||||
br->signature=0xAA55;
|
||||
fis->signature1='RRaA';
|
||||
|
@ -121,11 +121,11 @@ Bool FATNameTo(U8 *dst,U8 *src)
|
|||
MemSet(dst,CH_SPACE,11);
|
||||
if (!FileNameCheck(src))
|
||||
return FALSE;
|
||||
if (!StrCmp(src,"..")) {
|
||||
if (!StrCompare(src,"..")) {
|
||||
*dst='.';
|
||||
dst[1]='.';
|
||||
return TRUE;
|
||||
} else if (!StrCmp(src,".")) {
|
||||
} else if (!StrCompare(src,".")) {
|
||||
*dst='.';
|
||||
return TRUE;
|
||||
}
|
||||
|
@ -237,7 +237,7 @@ Bool FAT32DirFill(CFAT32DirEntry *de,
|
|||
MemSet(de,0,sizeof(CFAT32DirEntry));
|
||||
res=FATNameTo(de->name,tmpde->name);
|
||||
FATFromName(dname,de->name);
|
||||
if (StrCmp(dname,tmpde->name)) {
|
||||
if (StrCompare(dname,tmpde->name)) {
|
||||
ord=0x41;
|
||||
xsum=FATNameXSum(de->name);
|
||||
if ((l=StrLen(tmpde->name))>13) {
|
||||
|
@ -315,14 +315,14 @@ Bool FAT32FileFind(CDrive *drive,I64 cur_dir_clus,
|
|||
else {
|
||||
if (!(attr&RS_ATTR_VOL_ID)) {
|
||||
if (xsum==FATNameXSum(buf[cur_dir_entry].name))
|
||||
MemCpy(_res,&long_name,sizeof(CDirEntry));
|
||||
MemCopy(_res,&long_name,sizeof(CDirEntry));
|
||||
else
|
||||
MemSet(_res,0,sizeof(CDirEntry));
|
||||
if (!(fuf_flags&FUF_JUST_DIRS && !(attr & RS_ATTR_DIR)) &&
|
||||
!(fuf_flags&FUF_JUST_FILES && attr & RS_ATTR_DIR) &&
|
||||
FAT32CDirFill(_res,&buf[cur_dir_entry],
|
||||
drive->fat32_local_time_offset) &&
|
||||
!StrCmp(dname,_res->name)) {
|
||||
!StrCompare(dname,_res->name)) {
|
||||
res=TRUE;
|
||||
goto fff_done;
|
||||
}
|
||||
|
@ -594,7 +594,7 @@ Bool FAT32DirNew(CDrive *drive,U8 *cur_dir,CDirEntry *tmpde,Bool free_old_chain)
|
|||
break;
|
||||
}
|
||||
if (ch==0xE5 && !written && avail_count>=de_count) {
|
||||
MemCpy(&buf[cur_dir_entry],&de,de_count*sizeof(CFAT32DirEntry));
|
||||
MemCopy(&buf[cur_dir_entry],&de,de_count*sizeof(CFAT32DirEntry));
|
||||
BlkWrite(drive,&buf[cur_dir_entry & -FAT32_ENTRIES_PER_BLK],
|
||||
drive->data_area+cur_dir_clus*drive->spc
|
||||
+cur_dir_entry>>FAT32_ENTRIES_BITS,1);
|
||||
|
@ -606,12 +606,12 @@ Bool FAT32DirNew(CDrive *drive,U8 *cur_dir,CDirEntry *tmpde,Bool free_old_chain)
|
|||
if (!*long_name.name)
|
||||
FATFromName(long_name.name,buf[cur_dir_entry].name);
|
||||
//Del old entry with same name
|
||||
if (!StrCmp(long_name.name,tmpde->name)) {
|
||||
if (!StrCompare(long_name.name,tmpde->name)) {
|
||||
if (free_old_chain)
|
||||
FAT32FreeClus(drive,buf[cur_dir_entry].clus_lo+
|
||||
buf[cur_dir_entry].clus_hi<<16);
|
||||
if (!written) {
|
||||
MemCpy(&buf[cur_dir_entry],&de[de_count-1],sizeof(CFAT32DirEntry));
|
||||
MemCopy(&buf[cur_dir_entry],&de[de_count-1],sizeof(CFAT32DirEntry));
|
||||
BlkWrite(drive,&buf[cur_dir_entry & -FAT32_ENTRIES_PER_BLK],
|
||||
drive->data_area+cur_dir_clus*drive->spc
|
||||
+cur_dir_entry>>FAT32_ENTRIES_BITS,1);
|
||||
|
@ -678,7 +678,7 @@ Bool FAT32DirNew(CDrive *drive,U8 *cur_dir,CDirEntry *tmpde,Bool free_old_chain)
|
|||
ClusWrite(drive,buf,cur_dir_clus,1);
|
||||
}
|
||||
}
|
||||
MemCpy(&buf[cur_dir_entry],&de,de_count*sizeof(CFAT32DirEntry));
|
||||
MemCopy(&buf[cur_dir_entry],&de,de_count*sizeof(CFAT32DirEntry));
|
||||
BlkWrite(drive,&buf[cur_dir_entry &-FAT32_ENTRIES_PER_BLK],
|
||||
drive->data_area+cur_dir_clus*drive->spc+
|
||||
cur_dir_entry>>FAT32_ENTRIES_BITS,1);
|
||||
|
@ -858,7 +858,7 @@ CDirEntry *FAT32FilesFind(U8 *files_find_mask,
|
|||
if (!(attr&RS_ATTR_VOL_ID)) {
|
||||
tmpde=MAlloc(sizeof(CDirEntry));
|
||||
if (xsum==FATNameXSum(buf[cur_dir_entry].name))
|
||||
MemCpy(tmpde,&long_name,sizeof(CDirEntry));
|
||||
MemCopy(tmpde,&long_name,sizeof(CDirEntry));
|
||||
else
|
||||
MemSet(tmpde,0,sizeof(CDirEntry));
|
||||
if (FAT32CDirFill(tmpde,&buf[cur_dir_entry],
|
||||
|
|
|
@ -187,8 +187,8 @@ Bool RedSeaFileFind(CDrive *drive,I64 cur_dir_clus,U8 *name,
|
|||
else if (!(ptr->attr & RS_ATTR_DELETED) &&
|
||||
!(fuf_flags&FUF_JUST_DIRS && !(ptr->attr & RS_ATTR_DIR)) &&
|
||||
!(fuf_flags&FUF_JUST_FILES && ptr->attr & RS_ATTR_DIR) &&
|
||||
!StrCmp(dname,ptr->name)) {
|
||||
MemCpy(&_res->attr,&ptr->attr,CDIR_SIZE);
|
||||
!StrCompare(dname,ptr->name)) {
|
||||
MemCopy(&_res->attr,&ptr->attr,CDIR_SIZE);
|
||||
res=TRUE;
|
||||
goto rsff_done;
|
||||
}
|
||||
|
@ -372,12 +372,12 @@ Bool RedSeaDirNew(CDrive *drive,U8 *cur_dir,CDirEntry *tmpde,Bool free_old_chain
|
|||
while (TRUE) {
|
||||
if (!(ch=*ptr->name)) {
|
||||
if (!written)
|
||||
MemCpy(&ptr->start,&tmpde->start,CDIR_SIZE);
|
||||
MemCopy(&ptr->start,&tmpde->start,CDIR_SIZE);
|
||||
if ((i+1)*CDIR_SIZE+j<<BLK_SIZE_BITS<dir_size)
|
||||
BlkWrite(drive,buf(U8 *)+j<<BLK_SIZE_BITS,cur_dir_clus+j,1);
|
||||
else {
|
||||
buf2=CAlloc(dir_size+BLK_SIZE);
|
||||
MemCpy(buf2,buf,dir_size);
|
||||
MemCopy(buf2,buf,dir_size);
|
||||
RedSeaFreeClus(drive,cur_dir_clus,dir_size>>BLK_SIZE_BITS);
|
||||
dir_size+=BLK_SIZE;
|
||||
c=ClusAlloc(drive,0,dir_size>>BLK_SIZE_BITS,TRUE);
|
||||
|
@ -416,17 +416,17 @@ Bool RedSeaDirNew(CDrive *drive,U8 *cur_dir,CDirEntry *tmpde,Bool free_old_chain
|
|||
break;
|
||||
} else if (ptr->attr & RS_ATTR_DELETED) {
|
||||
if (!written) {
|
||||
MemCpy(&ptr->start,&tmpde->start,CDIR_SIZE);
|
||||
MemCopy(&ptr->start,&tmpde->start,CDIR_SIZE);
|
||||
BlkWrite(drive,buf(U8 *)+j<<BLK_SIZE_BITS,cur_dir_clus+j,1);
|
||||
written=TRUE;
|
||||
}
|
||||
} else {
|
||||
if (!StrCmp(tmpde->name,ptr->name)) {
|
||||
if (!StrCompare(tmpde->name,ptr->name)) {
|
||||
if (free_old_chain)
|
||||
RedSeaFreeClus(drive,ptr->clus,
|
||||
(ptr->size+BLK_SIZE-1)>>BLK_SIZE_BITS);
|
||||
if (!written)
|
||||
MemCpy(&ptr->start,&tmpde->start,CDIR_SIZE);
|
||||
MemCopy(&ptr->start,&tmpde->start,CDIR_SIZE);
|
||||
else
|
||||
ptr->attr|=RS_ATTR_DELETED;
|
||||
BlkWrite(drive,buf(U8 *)+j<<BLK_SIZE_BITS,cur_dir_clus+j,1);
|
||||
|
@ -564,7 +564,7 @@ CDirEntry *RedSeaFilesFind(U8 *files_find_mask,I64 fuf_flags,
|
|||
break;
|
||||
else if (!(ptr->attr & RS_ATTR_DELETED)) {
|
||||
tmpde=CAlloc(sizeof(CDirEntry));
|
||||
MemCpy(&tmpde->start,&ptr->start,CDIR_SIZE);
|
||||
MemCopy(&tmpde->start,&ptr->start,CDIR_SIZE);
|
||||
tmpde->parent=parent;
|
||||
if (Bt(&fuf_flags,FUf_RECURSE) && tmpde->attr&RS_ATTR_DIR &&
|
||||
*tmpde->name!='.') {
|
||||
|
@ -611,7 +611,7 @@ Bool RedSeaMkDir(CDrive *drive,U8 *cur_dir,U8 *name,I64 entry_count)
|
|||
unlock_break=BreakLock;
|
||||
c=FileWrite(name,buf,size,0,RS_ATTR_DIR);
|
||||
d_native->attr=RS_ATTR_DIR|RS_ATTR_CONTIGUOUS;
|
||||
StrCpy(d_native->name,name);
|
||||
StrCopy(d_native->name,name);
|
||||
d_native->clus=c;
|
||||
d_native->size=size;
|
||||
d_native->datetime=Now;
|
||||
|
|
|
@ -260,7 +260,7 @@ U8 *ExpandBuf(CArcCompress *arc,CTask *mem_task=NULL)
|
|||
res[arc->expanded_size]=0; //terminate
|
||||
switch [arc->compression_type] {
|
||||
case CT_NONE:
|
||||
MemCpy(res,&arc->body,arc->expanded_size);
|
||||
MemCopy(res,&arc->body,arc->expanded_size);
|
||||
break;
|
||||
case CT_7_BIT:
|
||||
case CT_8_BIT:
|
||||
|
@ -292,12 +292,12 @@ CArcCompress *CompressBuf(U8 *src,I64 size,CTask *mem_task=NULL)
|
|||
if (ArcFinishCompression(c) && c->src_pos==c->src_size) {
|
||||
size_out=(c->dst_pos+7)>>3;
|
||||
arc=MAlloc(size_out,mem_task);
|
||||
MemCpy(arc,c->dst_buf,size_out);
|
||||
MemCopy(arc,c->dst_buf,size_out);
|
||||
arc->compression_type=compression_type;
|
||||
arc->compressed_size=size_out;
|
||||
} else {
|
||||
arc=MAlloc(size+sizeof(CArcCompress),mem_task);
|
||||
MemCpy(&arc->body,src,size);
|
||||
MemCopy(&arc->body,src,size);
|
||||
arc->compression_type=CT_NONE;
|
||||
arc->compressed_size=size+sizeof(CArcCompress);
|
||||
}
|
||||
|
|
|
@ -44,7 +44,7 @@ See also $LK,"GrUpdateScreen",A="MN:GrUpdateScreen"$().
|
|||
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(text.vga_text_alias,text.vga_text_alias+text.cols*2,
|
||||
MemCopy(text.vga_text_alias,text.vga_text_alias+text.cols*2,
|
||||
text.cols*(text.rows-1)*2);
|
||||
MemSet(text.vga_text_alias+text.cols*(text.rows-1)*2,0,text.cols*2);
|
||||
text.raw_col-=text.cols;
|
||||
|
@ -58,13 +58,13 @@ See also $LK,"GrUpdateScreen",A="MN:GrUpdateScreen"$().
|
|||
OutU8(VGAP_DATA,0x0F); //All planes -- WHITE
|
||||
if (text.raw_flags&RWF_SCROLL && text.raw_col && !row && !col) {
|
||||
//Scroll cached image
|
||||
MemCpy(text.raw_scrn_image,
|
||||
MemCopy(text.raw_scrn_image,
|
||||
text.raw_scrn_image+GR_WIDTH*FONT_HEIGHT>>3,
|
||||
GR_WIDTH*(GR_HEIGHT-FONT_HEIGHT)>>3);
|
||||
MemSet(text.raw_scrn_image+GR_WIDTH*(GR_HEIGHT-FONT_HEIGHT)>>3,0,
|
||||
GR_WIDTH*FONT_HEIGHT>>3);
|
||||
|
||||
MemCpy(text.vga_alias,text.raw_scrn_image,GR_WIDTH*GR_HEIGHT>>3);
|
||||
MemCopy(text.vga_alias,text.raw_scrn_image,GR_WIDTH*GR_HEIGHT>>3);
|
||||
text.raw_col-=text.cols;
|
||||
row=text.rows-1;
|
||||
}
|
||||
|
|
|
@ -101,7 +101,7 @@ Bool EdLite(U8 *filename,I64 num=1,I64 edf_dof_flags=0)
|
|||
|
||||
if (src+1-buf<size) {
|
||||
bin_data=MAlloc(bin_size=size-(src-buf));
|
||||
MemCpy(bin_data,src,bin_size);
|
||||
MemCopy(bin_data,src,bin_size);
|
||||
}
|
||||
Free(buf);
|
||||
res=TRUE;
|
||||
|
@ -192,7 +192,7 @@ Bool EdLite(U8 *filename,I64 num=1,I64 edf_dof_flags=0)
|
|||
Free(tmpl);
|
||||
}
|
||||
} else
|
||||
StrCpy(cur_line->line+cur_col,cur_line->line+cur_col+1);
|
||||
StrCopy(cur_line->line+cur_col,cur_line->line+cur_col+1);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
|
@ -207,7 +207,7 @@ Bool EdLite(U8 *filename,I64 num=1,I64 edf_dof_flags=0)
|
|||
break;
|
||||
case CH_BACKSPACE:
|
||||
if (cur_col) {
|
||||
StrCpy(cur_line->line+cur_col-1,cur_line->line+cur_col);
|
||||
StrCopy(cur_line->line+cur_col-1,cur_line->line+cur_col);
|
||||
cur_col--;
|
||||
} else if (cur_line!=&head && cur_line->last!=&head) {
|
||||
tmpl=cur_line->last;
|
||||
|
@ -239,10 +239,10 @@ Bool EdLite(U8 *filename,I64 num=1,I64 edf_dof_flags=0)
|
|||
QueueInsert(cur_line,head.last);
|
||||
}
|
||||
src=MAlloc(StrLen(cur_line->line)+2);
|
||||
MemCpy(src,cur_line->line,cur_col);
|
||||
MemCopy(src,cur_line->line,cur_col);
|
||||
src[cur_col]=ch;
|
||||
if (cur_col<StrLen(cur_line->line))
|
||||
StrCpy(src+cur_col+1,cur_line->line+cur_col);
|
||||
StrCopy(src+cur_col+1,cur_line->line+cur_col);
|
||||
else
|
||||
src[cur_col+1]=0;
|
||||
Free(cur_line->line);
|
||||
|
@ -268,13 +268,13 @@ Bool EdLite(U8 *filename,I64 num=1,I64 edf_dof_flags=0)
|
|||
tmpl=head.next;
|
||||
while (tmpl!=&head) {
|
||||
i=StrLen(tmpl->line);
|
||||
MemCpy(dst,tmpl->line,i);
|
||||
MemCopy(dst,tmpl->line,i);
|
||||
dst+=i;
|
||||
*dst++='\n';
|
||||
tmpl=tmpl->next;
|
||||
}
|
||||
if (bin_data)
|
||||
MemCpy(dst,bin_data,bin_size);
|
||||
MemCopy(dst,bin_data,bin_size);
|
||||
FileWrite(filename,buf,size);
|
||||
Free(buf);
|
||||
|
||||
|
|
|
@ -105,7 +105,7 @@ U0 FunSegCacheAdd(CHash *tmps,U8 *addr)
|
|||
if (addr>=tmpfsc->limit)
|
||||
tmpfsc->limit=addr+1;
|
||||
i=MinI64(StrLen(tmps->str),FUN_SEG_CACHE_STR_LEN-1);
|
||||
MemCpy(tmpfsc->str,tmps->str,i);
|
||||
MemCopy(tmpfsc->str,tmps->str,i);
|
||||
tmpfsc->str[i]=0;
|
||||
tmpfsc->time_stamp=tS;
|
||||
}
|
||||
|
@ -157,17 +157,17 @@ U0 StrPrintFunSeg(U8 *buf,I64 addr,I64 field_len,I64 flags)
|
|||
if (is_fun) {
|
||||
str2=MStrPrint("&%s",str);
|
||||
if (!field_len)
|
||||
StrCpy(buf,str2);
|
||||
StrCopy(buf,str2);
|
||||
else if (flags&PRTF_LEFT_JUSTIFY && StrLen(str2)<field_len)
|
||||
StrCpy(buf,str2);
|
||||
StrCopy(buf,str2);
|
||||
else
|
||||
StrPrint(buf,"%*ts",field_len,str2);
|
||||
Free(str2);
|
||||
} else {
|
||||
if (!field_len)
|
||||
StrCpy(buf,str);
|
||||
StrCopy(buf,str);
|
||||
else if (flags&PRTF_LEFT_JUSTIFY && StrLen(str)<field_len)
|
||||
StrCpy(buf,str);
|
||||
StrCopy(buf,str);
|
||||
else
|
||||
StrPrint(buf,"%*ts",field_len,str);
|
||||
}
|
||||
|
@ -196,7 +196,7 @@ U0 StrPrintFunSeg(U8 *buf,I64 addr,I64 field_len,I64 flags)
|
|||
}
|
||||
}
|
||||
if (flags&PRTF_COMMA)
|
||||
StrCpy(buf,".");
|
||||
StrCopy(buf,".");
|
||||
else if (flags&PRTF_TRUNCATE && field_len)
|
||||
StrPrint(buf,"%*tX",field_len,addr);
|
||||
else
|
||||
|
|
|
@ -102,7 +102,7 @@ U0 KConfigOptions(CKConfig *c)
|
|||
}
|
||||
Free(c->home_dir);
|
||||
c->home_dir=st2;
|
||||
if (StrCmp(c->home_dir,"::/Home"))
|
||||
if (StrCompare(c->home_dir,"::/Home"))
|
||||
c->opts[i]=TRUE;
|
||||
else
|
||||
c->opts[i]=FALSE;
|
||||
|
|
|
@ -123,7 +123,7 @@ U0 StackRep(CTask *task=NULL)
|
|||
addr=*rsp;
|
||||
else
|
||||
addr=task->rip;
|
||||
MemCpy(my_rsp,rsp,STACK_REP_LEN*sizeof(U8 *));
|
||||
MemCopy(my_rsp,rsp,STACK_REP_LEN*sizeof(U8 *));
|
||||
POPFD
|
||||
Fs->hash_table=task->hash_table;
|
||||
for (i=0;i<STACK_REP_LEN;i++) {
|
||||
|
|
|
@ -25,7 +25,7 @@ CHashDefineStr *DefineListLoad(U8 *dname,U8 *list)
|
|||
while (*ptr++);
|
||||
}
|
||||
tmph->data=MAlloc(ptr+1-list);
|
||||
MemCpy(tmph->data,list,ptr+1-list);
|
||||
MemCopy(tmph->data,list,ptr+1-list);
|
||||
tmph->count=count;
|
||||
|
||||
idx=tmph->sub_idx=MAlloc(count*sizeof(U8 *));
|
||||
|
@ -172,13 +172,13 @@ CColorROPU16 Str2ColorU16(U8 *st)
|
|||
while (st<ptr)
|
||||
*ptr2++=*st++;
|
||||
*ptr2++=0;
|
||||
if (!StrICmp(st2,"TWO"))
|
||||
if (!StrICompare(st2,"TWO"))
|
||||
res.rop|=ROPBF_TWO_SIDED;
|
||||
else if (!StrICmp(st2,"HALF"))
|
||||
else if (!StrICompare(st2,"HALF"))
|
||||
res.rop|=ROPBF_HALF_RANGE_COLOR;
|
||||
else if ((i=DefineMatch(st2,"ST_COLORS",LMF_IGNORE_CASE))>=0)
|
||||
res.color=i;
|
||||
else if (!StrICmp(st2,"TRANSPARENT"))
|
||||
else if (!StrICompare(st2,"TRANSPARENT"))
|
||||
res.color=TRANSPARENT;
|
||||
else {
|
||||
Free(st2);
|
||||
|
|
|
@ -120,7 +120,7 @@ I64 HashTablePurge(CHashTable *table)
|
|||
while (tmph2) {
|
||||
if ((tmph2->type&HTT_EXPORT_SYS_SYM ||
|
||||
tmph2->type&HTG_TYPE_MASK==HTT_INVALID) &&
|
||||
!StrCmp(tmph2->str,tmph->str)) {
|
||||
!StrCompare(tmph2->str,tmph->str)) {
|
||||
if (tmph2->type&HTG_TYPE_MASK==HTT_INVALID)
|
||||
tmph2->type=HTT_KEYWORD;//Won't delete HTT_INVALID
|
||||
HashRemDel(tmph2,table);
|
||||
|
|
|
@ -217,7 +217,7 @@ CBinFile *Load(U8 *filename,I64 ld_flags=0,CBinFile *bfh_addr=INVALID_PTR)
|
|||
} else
|
||||
bfh_addr=bfh->org;
|
||||
}
|
||||
MemCpy(bfh_addr,bfh,size);
|
||||
MemCopy(bfh_addr,bfh,size);
|
||||
Free(bfh);
|
||||
|
||||
lo_skip:
|
||||
|
|
|
@ -143,8 +143,8 @@ U0 KMain()
|
|||
UncachedAliasAlloc;
|
||||
LoadKernel;
|
||||
SysGrInit;
|
||||
StrCpy(Fs->task_name,"Zenith Task CPU00");
|
||||
StrCpy(Fs->task_title,Fs->task_name);
|
||||
StrCopy(Fs->task_name,"Zenith Task CPU00");
|
||||
StrCopy(Fs->task_title,Fs->task_name);
|
||||
Fs->title_src=TTS_TASK_NAME;
|
||||
Fs->win_right=text.cols-2;
|
||||
Fs->win_top++;
|
||||
|
|
|
@ -209,7 +209,7 @@ I64 TaskInit(CTask *task,I64 stack_size)
|
|||
QueueInit(&task->next_ode);
|
||||
|
||||
task->fpu_mmx=MAllocAligned(sizeof(CFPU),0x10,task);
|
||||
MemCpy(task->fpu_mmx,
|
||||
MemCopy(task->fpu_mmx,
|
||||
SYS_FIXED_AREA+offset(CSysFixedArea.init_fpu_mmx),sizeof(CFPU));
|
||||
|
||||
task->hash_table=HashTableNew(TASK_HASH_TABLE_SIZE,task);
|
||||
|
@ -270,8 +270,8 @@ CTask *Spawn(U0 (*fp_start_addr)(U8 *data),U8 *data=NULL,U8 *task_name=NULL,
|
|||
task->rsp(U8 *)-=8;
|
||||
*task->rsp=&Exit;
|
||||
task->hash_table->next=parent->hash_table;
|
||||
MemCpy(task->task_name,task_name,TASK_NAME_LEN);
|
||||
StrCpy(task->task_title,task->task_name);
|
||||
MemCopy(task->task_name,task_name,TASK_NAME_LEN);
|
||||
StrCopy(task->task_title,task->task_name);
|
||||
task->title_src=TTS_TASK_NAME;
|
||||
PUSHFD
|
||||
CLI
|
||||
|
@ -333,7 +333,7 @@ I64 ExeCmdLine(CCompCtrl *cc)
|
|||
if (ptr2<ptr3) *ptr2=0;
|
||||
} else
|
||||
if ((ptr=cc->lex_include_stack->line_start) && *ptr)
|
||||
MemCpy(ptr2,ptr,STR_LEN-1);
|
||||
MemCopy(ptr2,ptr,STR_LEN-1);
|
||||
}
|
||||
cc->flags&=~CCF_HAS_MISC_DATA;
|
||||
machine_code=LexStatement2Bin(cc,&type);
|
||||
|
@ -353,7 +353,7 @@ I64 ExeCmdLine(CCompCtrl *cc)
|
|||
}
|
||||
if (Fs->title_src!=TTS_LOCKED_CONST) {
|
||||
Fs->title_src=old_title_src;
|
||||
StrCpy(Fs->task_title,old_task_title);
|
||||
StrCopy(Fs->task_title,old_task_title);
|
||||
}
|
||||
Free(old_task_title);
|
||||
if (cc->flags&CCF_JUST_LOAD) {
|
||||
|
@ -372,7 +372,7 @@ U0 SrvTaskCont()
|
|||
while (TRUE) {
|
||||
CLI
|
||||
if (JobsHandler(old_flags) && Fs->title_src==TTS_TASK_NAME)
|
||||
MemCpy(Fs->task_title,Fs->task_name,TASK_NAME_LEN);
|
||||
MemCopy(Fs->task_title,Fs->task_name,TASK_NAME_LEN);
|
||||
FlushMessages;
|
||||
LBts(&Fs->task_flags,TASKf_IDLE);
|
||||
LBts(&Fs->task_flags,TASKf_AWAITING_MESSAGE);
|
||||
|
|
|
@ -51,7 +51,7 @@ _MEMSET_I64::
|
|||
POP RDI
|
||||
POP RBP
|
||||
RET1 24
|
||||
_MEMCPY::
|
||||
_MEMCOPY::
|
||||
PUSH RBP
|
||||
MOV RBP,RSP
|
||||
PUSH RSI
|
||||
|
@ -66,7 +66,7 @@ _MEMCPY::
|
|||
POP RSI
|
||||
POP RBP
|
||||
RET1 24
|
||||
_MEMCMP::
|
||||
_MEMCOMPARE::
|
||||
PUSH RBP
|
||||
MOV RBP,RSP
|
||||
PUSH RSI
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
$LK,"TASK_EXCEPT_CALLERS",A="FL:::/Kernel/KernelA.HH,3256"$
|
||||
$LK,"ARGT_R64",A="FL:::/Kernel/KernelA.HH,1907"$
|
||||
$LK,"MAlloc",A="FL:::/Kernel/Mem/MAllocFree.HC,387"$
|
||||
$LK,"MAlloc",A="FL:::/Kernel/Memory/MAllocFree.HC,387"$
|
||||
$LK,"BOOT_SRC_NULL",A="FL:::/Kernel/KernelA.HH,3839"$
|
||||
$LK,"KbdTypeMatic",A="FL:::/Kernel/SerialDev/Keyboard.HC,86",BI=1$
|
||||
$LK,"KbdLEDsSet",A="FL:::/Kernel/SerialDev/Keyboard.HC,52",BI=2$
|
||||
|
@ -81,7 +81,6 @@ $LK,"CMF_I16_JMP_TABLE",A="FL:::/Kernel/KernelA.HH,1710"$
|
|||
$LK,"FramePtrSet",A="FL:::/Kernel/KHashB.HC,230",BI=12$
|
||||
$LK,"CCf_PASS_TRACE_PRESENT",A="FL:::/Kernel/KernelA.HH,2150"$
|
||||
$LK,"CMF_U16_JMP_TABLE",A="FL:::/Kernel/KernelA.HH,1711"$
|
||||
$LK,"_STRICMP",A="FL:::/Kernel/StrA.HC,117"$
|
||||
$LK,"IET_REL_I64",A="FL:::/Kernel/KernelA.HH,415"$
|
||||
$LK,"CFAT32Boot",A="FL:::/Kernel/KernelA.HH,2348"$
|
||||
$LK,"DOCEf_RIGHT_IN_STR",A="FL:::/Kernel/KernelA.HH,1079"$
|
||||
|
@ -123,8 +122,9 @@ $LK,"RLF_ONCE_USER",A="FL:::/Kernel/KernelA.HH,495"$
|
|||
$LK,"RLf_ONCE_USER",A="FL:::/Kernel/KernelA.HH,473"$
|
||||
$LK,"RFLAGf_AUX_CARRY",A="FL:::/Kernel/KernelA.HH,323"$
|
||||
$LK,"DOCEf_LEFT_X",A="FL:::/Kernel/KernelA.HH,1080"$
|
||||
$LK,"Mem64DevFree",A="FL:::/Kernel/Mem/MemPhysical.HC,127",BI=18$
|
||||
$LK,"Mem32DevFree",A="FL:::/Kernel/Mem/MemPhysical.HC,91",BI=19$
|
||||
$LK,"Mem64DevFree",A="FL:::/Kernel/Memory/MemPhysical.HC,127",BI=18$
|
||||
$LK,"Mem32DevFree",A="FL:::/Kernel/Memory/MemPhysical.HC,91",BI=19$
|
||||
$LK,"_STRCOPY",A="FL:::/Kernel/StrA.HC,65"$
|
||||
$LK,"DOCT_DEFAULT_BACKGROUND",A="FL:::/Kernel/KernelA.HH,923"$
|
||||
$LK,"DOCT_DEFAULT_FOREGROUND",A="FL:::/Kernel/KernelA.HH,922"$
|
||||
$LK,"ARGT_UIMM64",A="FL:::/Kernel/KernelA.HH,1902"$
|
||||
|
@ -194,7 +194,6 @@ $LK,"DOC_COLOR_CHAR_CONST",A="FL:::/Kernel/KernelA.HH,1149"$
|
|||
$LK,"E",A="FL:::/Kernel/FunSeg.HC,332",BI=36$
|
||||
$LK,"CEdFileName",A="FL:::/Kernel/KernelA.HH,1251"$
|
||||
$LK,"DOCT_LEFT_MARGIN",A="FL:::/Kernel/KernelA.HH,915"$
|
||||
$LK,"_STRNCMP",A="FL:::/Kernel/StrA.HC,154"$
|
||||
$LK,"CCF_NO_CHAR_CONST",A="FL:::/Kernel/KernelA.HH,2149"$
|
||||
$LK,"U64_MAX",A="FL:::/Kernel/KernelA.HH,40"$
|
||||
$LK,"G",A="FL:::/Kernel/KDebug.HC,444",BI=37$
|
||||
|
@ -205,7 +204,7 @@ $LK,"PressAKey",A="FL:::/Kernel/StrB.HC,103",BI=39$
|
|||
$LK,"DOF_WIN_MAX",A="FL:::/Kernel/KernelA.HH,1229"$
|
||||
$LK,"CCodeCtrl",A="FL:::/Kernel/KernelA.HH,2027"$
|
||||
$LK,"Char2ScanCode",A="FL:::/Kernel/SerialDev/Keyboard.HC,100",BI=40$
|
||||
$LK,"Mem32DevInit",A="FL:::/Kernel/Mem/MemPhysical.HC,30",BI=41$
|
||||
$LK,"Mem32DevInit",A="FL:::/Kernel/Memory/MemPhysical.HC,30",BI=41$
|
||||
$LK,"_BIT_FIELD_OR_U32",A="FL:::/Kernel/KUtils.HC,154"$
|
||||
$LK,"DOCf_NO_SCROLL_BARS",A="FL:::/Kernel/KernelA.HH,1320"$
|
||||
$LK,"SPutChar",A="FL:::/Kernel/StrPrint.HC,1",BI=42$
|
||||
|
@ -337,8 +336,8 @@ $LK,"TaskQueueInsChild",A="FL:::/Kernel/Sched.HC,314",BI=67$
|
|||
$LK,"SYS_FIND_PCIBIOS_SERVICE_DIR",A="FL:::/Kernel/PCIBIOS.HC,8"$
|
||||
$LK,"CTRLF_CLICKED",A="FL:::/Kernel/KernelA.HH,3047"$
|
||||
$LK,"HTF_RESOLVE",A="FL:::/Kernel/KernelA.HH,712"$
|
||||
$LK,"Mem64DevAlloc",A="FL:::/Kernel/Mem/MemPhysical.HC,108",BI=68$
|
||||
$LK,"Mem32DevAlloc",A="FL:::/Kernel/Mem/MemPhysical.HC,58",BI=69$
|
||||
$LK,"Mem64DevAlloc",A="FL:::/Kernel/Memory/MemPhysical.HC,108",BI=68$
|
||||
$LK,"Mem32DevAlloc",A="FL:::/Kernel/Memory/MemPhysical.HC,58",BI=69$
|
||||
$LK,"RT_U64",A="FL:::/Kernel/KernelA.HH,1574"$
|
||||
$LK,"DOCT_TAB",A="FL:::/Kernel/KernelA.HH,908"$
|
||||
$LK,"HTT_FRAME_PTR",A="FL:::/Kernel/KernelA.HH,703"$
|
||||
|
@ -382,6 +381,7 @@ $LK,"RFLAGf_NESTED_TASK",A="FL:::/Kernel/KernelA.HH,332"$
|
|||
$LK,"BEqu",A="FL:::/Kernel/KernelB.HH,28"$
|
||||
$LK,"FAT32MkDir",A="FL:::/Kernel/BlkDev/FileSysFAT.HC,919",BI=82$
|
||||
$LK,"ClusBlkRead",A="FL:::/Kernel/BlkDev/DiskClus.HC,44",BI=83$
|
||||
$LK,"_MEMCOPY",A="FL:::/Kernel/KUtils.HC,55"$
|
||||
$LK,"DCS_SIGNATURE_VAL",A="FL:::/Kernel/KernelA.HH,3590"$
|
||||
$LK,"ICF_USE_INT",A="FL:::/Kernel/KernelA.HH,1610"$
|
||||
$LK,"DOCT_NEW_LINE",A="FL:::/Kernel/KernelA.HH,906"$
|
||||
|
@ -416,13 +416,13 @@ $LK,"_CONFIG_HEAP_DBG",A="FL:::/Kernel/KernelA.HH,2773"$
|
|||
$LK,"Cf_EXTERN",A="FL:::/Kernel/KernelA.HH,835"$
|
||||
$LK,"HPET_GCAP_ID",A="FL:::/Kernel/KernelA.HH,554"$
|
||||
$LK,"ATan",A="FL:::/Kernel/KernelB.HH,95"$
|
||||
$LK,"SysBadFree",A="FL:::/Kernel/Mem/MemPag.HC,1",BI=88$
|
||||
$LK,"SysBadFree",A="FL:::/Kernel/Memory/MemPag.HC,1",BI=88$
|
||||
$LK,"ATA_ID_DEV",A="FL:::/Kernel/KernelA.HH,2280"$
|
||||
$LK,"CHashReg",A="FL:::/Kernel/KernelA.HH,753"$
|
||||
$LK,"MEM_512GIG_NUM",A="FL:::/Kernel/KStart32.HC,12"$
|
||||
$LK,"SCf_INS",A="FL:::/Kernel/KernelA.HH,3475"$
|
||||
$LK,"LAPIC_LVT_ERR",A="FL:::/Kernel/KernelA.HH,524"$
|
||||
$LK,"Scale2Mem",A="FL:::/Kernel/Mem/MemPhysical.HC,169",BI=89$
|
||||
$LK,"Scale2Mem",A="FL:::/Kernel/Memory/MemPhysical.HC,169",BI=89$
|
||||
$LK,"RandU32",A="FL:::/Kernel/KMathB.HC,107",BI=90$
|
||||
$LK,"RandU16",A="FL:::/Kernel/KMathB.HC,87",BI=91$
|
||||
$LK,"F64_MIN",A="FL:::/Kernel/KernelA.HH,48"$
|
||||
|
@ -490,7 +490,7 @@ $LK,"RS_ATTR_RESIDENT",A="FL:::/Kernel/KernelA.HH,2507"$
|
|||
$LK,"HashSrcFileSet",A="FL:::/Kernel/KHashB.HC,154",BI=108$
|
||||
$LK,"ROP_XOR",A="FL:::/Kernel/KernelA.HH,2899"$
|
||||
$LK,"NULL",A="FL:::/Kernel/KernelA.HH,19"$
|
||||
$LK,"BlkPoolInit",A="FL:::/Kernel/Mem/BlkPool.HC,18",BI=109$
|
||||
$LK,"BlkPoolInit",A="FL:::/Kernel/Memory/BlkPool.HC,18",BI=109$
|
||||
$LK,"BDF_EXT_SIZE",A="FL:::/Kernel/KernelA.HH,2617"$
|
||||
$LK,"DriveRep",A="FL:::/Kernel/BlkDev/DiskDrive.HC,331",BI=110$
|
||||
$LK,"sys_boot_blk",A="FL:::/Kernel/KernelB.HH,38"$
|
||||
|
@ -541,6 +541,7 @@ $LK,"DOC_ATTR_DEFAULT_TEXT",A="FL:::/Kernel/KernelA.HH,1139"$
|
|||
$LK,"exp_1",A="FL:::/Kernel/KernelA.HH,53"$
|
||||
$LK,"CTRL_KEY_SCAN_DECODE_TABLE",A="FL:::/Kernel/SerialDev/Keyboard.HC,15"$
|
||||
$LK,"G2",A="FL:::/Kernel/KDebug.HC,469",BI=115$
|
||||
$LK,"StrNCompare",A="FL:::/Kernel/StrA.HC,313"$
|
||||
$LK,"DOCEG_HAS_ARG",A="FL:::/Kernel/KernelA.HH,1036"$
|
||||
$LK,"TSSNew",A="FL:::/Kernel/MultiProc.HC,76",BI=116$
|
||||
$LK,"SYS_PROGRESS1_DESC",A="FL:::/Kernel/KStart32.HC,45"$
|
||||
|
@ -626,7 +627,6 @@ $LK,"D3Copy",A="FL:::/Kernel/KernelB.HH,147"$
|
|||
$LK,"MESSAGE_MS_L_D_UP",A="FL:::/Kernel/KernelA.HH,3182"$
|
||||
$LK,"Beep",A="FL:::/Kernel/KMisc.HC,237",BI=125$
|
||||
$LK,"mouse_hard",A="FL:::/Kernel/KGlobals.HC,28"$
|
||||
$LK,"_STRNICMP",A="FL:::/Kernel/StrA.HC,183"$
|
||||
$LK,"_MEMSET_I64",A="FL:::/Kernel/KUtils.HC,42"$
|
||||
$LK,"CH_SPACE",A="FL:::/Kernel/KernelA.HH,3457"$
|
||||
$LK,"AAT_SUB_U8",A="FL:::/Kernel/KernelA.HH,1980"$
|
||||
|
@ -641,6 +641,7 @@ $LK,"SYS_STAFF_MODE_FLAG",A="FL::/Tmp.DD,1"$
|
|||
$LK,"BlkDevLockFwdingSet",A="FL:::/Kernel/BlkDev/DiskAddDev.HC,1",BI=126$
|
||||
$LK,"InU8",A="FL:::/Kernel/KernelB.HH,77"$
|
||||
$LK,"ARGT_SREG",A="FL:::/Kernel/KernelA.HH,1936"$
|
||||
$LK,"_STRNCOMPARE",A="FL:::/Kernel/StrA.HC,154"$
|
||||
$LK,"QueueInsRev",A="FL:::/Kernel/KernelB.HH,70"$
|
||||
$LK,"CMemUnused",A="FL:::/Kernel/KernelA.HH,2792"$
|
||||
$LK,"IEF_48_REX",A="FL:::/Kernel/KernelA.HH,1743"$
|
||||
|
@ -726,8 +727,8 @@ $LK,"FilesFind2",A="FL:::/Kernel/BlkDev/DiskFind.HC,1",BI=142$
|
|||
$LK,"TaskKillDying",A="FL:::/Kernel/KTask.HC,528",BI=143$
|
||||
$LK,"scan_code_map",A="FL:::/Kernel/SerialDev/Keyboard.HC,157"$
|
||||
$LK,"progress2_t0",A="FL:::/Kernel/KernelB.HH,219"$
|
||||
$LK,"UncachedAliasAlloc",A="FL:::/Kernel/Mem/MemPhysical.HC,138",BI=144$
|
||||
$LK,"MSize2",A="FL:::/Kernel/Mem/MAllocFree.HC,385"$
|
||||
$LK,"UncachedAliasAlloc",A="FL:::/Kernel/Memory/MemPhysical.HC,138",BI=144$
|
||||
$LK,"MSize2",A="FL:::/Kernel/Memory/MAllocFree.HC,385"$
|
||||
$LK,"SYS_16MEG_AREA_LIMIT",A="FL:::/Kernel/KernelA.HH,3414"$
|
||||
$LK,"MemSetU32",A="FL:::/Kernel/KernelB.HH,177"$
|
||||
$LK,"MemSetU16",A="FL:::/Kernel/KernelB.HH,175"$
|
||||
|
@ -765,7 +766,7 @@ $LK,"DOCT_MARKER",A="FL:::/Kernel/KernelA.HH,911"$
|
|||
$LK,"KeyDevRemove",A="FL:::/Kernel/KeyDev.HC,64",BI=153$
|
||||
$LK,"BptS",A="FL:::/Kernel/KDebug.HC,368",BI=154$
|
||||
$LK,"_HASH_BUCKET_FIND",A="FL:::/Kernel/KHashA.HC,158"$
|
||||
$LK,"_MHEAP_CTRL",A="FL:::/Kernel/Mem/MAllocFree.HC,368"$
|
||||
$LK,"_MHEAP_CTRL",A="FL:::/Kernel/Memory/MAllocFree.HC,368"$
|
||||
$LK,"progress4_t0",A="FL:::/Kernel/KernelB.HH,231"$
|
||||
$LK,"ATAMount",A="FL:::/Kernel/BlkDev/DiskATAId.HC,248",BI=155$
|
||||
$LK,"FifoI64Peek",A="FL:::/Kernel/KDataTypes.HC,290",BI=156$
|
||||
|
@ -816,7 +817,7 @@ $LK,"_D3_COPY",A="FL:::/Kernel/KMathA.HC,212"$
|
|||
$LK,"PUT_STR",A="FL:::/Kernel/StrA.HC,58"$
|
||||
$LK,"_RET",A="FL:::/Kernel/KUtils.HC,456"$
|
||||
$LK,"_RCX",A="FL:::/Kernel/KernelA.HH,3371"$
|
||||
$LK,"BIOSTotalMem",A="FL:::/Kernel/Mem/MemPhysical.HC,151",BI=168$
|
||||
$LK,"BIOSTotalMem",A="FL:::/Kernel/Memory/MemPhysical.HC,151",BI=168$
|
||||
$LK,"_RDX",A="FL:::/Kernel/KernelA.HH,3372"$
|
||||
$LK,"SYS_PROGRESS4_DESC",A="FL:::/Kernel/KStart32.HC,60"$
|
||||
$LK,"__FILE__",A="FL:::/Kernel/KernelA.HH,2041"$
|
||||
|
@ -835,7 +836,7 @@ $LK,"_FSTSW",A="FL:::/Kernel/KMathA.HC,641"$
|
|||
$LK,"ARGT_IMM32",A="FL:::/Kernel/KernelA.HH,1896"$
|
||||
$LK,"ARGT_IMM16",A="FL:::/Kernel/KernelA.HH,1895"$
|
||||
$LK,"CheckCodePtr",A="FL:::/Kernel/KDebug.HC,16",BI=170$
|
||||
$LK,"Free",A="FL:::/Kernel/Mem/MAllocFree.HC,383"$
|
||||
$LK,"Free",A="FL:::/Kernel/Memory/MAllocFree.HC,383"$
|
||||
$LK,"DOCEf_AUX_STR",A="FL:::/Kernel/KernelA.HH,1060"$
|
||||
$LK,"DOCEF_AUX_STR",A="FL:::/Kernel/KernelA.HH,972"$
|
||||
$LK,"REGT_FSTACK",A="FL:::/Kernel/KernelA.HH,749"$
|
||||
|
@ -885,7 +886,7 @@ $LK,"DOCf_UNDERLINE",A="FL:::/Kernel/KernelA.HH,1337"$
|
|||
$LK,"DOCF_UNDERLINE",A="FL:::/Kernel/KernelA.HH,1299"$
|
||||
$LK,"DOCT_UNDERLINE",A="FL:::/Kernel/KernelA.HH,928"$
|
||||
$LK,"IntDivZero",A="FL:::/Kernel/KInts.HC,150",BI=180$
|
||||
$LK,"MemPagFree",A="FL:::/Kernel/Mem/MemPag.HC,83",BI=181$
|
||||
$LK,"MemPagFree",A="FL:::/Kernel/Memory/MemPag.HC,83",BI=181$
|
||||
$LK,"_SQR",A="FL:::/Kernel/KMathA.HC,337"$
|
||||
$LK,"DISPLAYf_SILENT",A="FL:::/Kernel/KernelA.HH,3249"$
|
||||
$LK,"MDF_SIB",A="FL:::/Kernel/KernelA.HH,1595"$
|
||||
|
@ -906,6 +907,7 @@ $LK,"FlushMessages",A="FL:::/Kernel/SerialDev/Message.HC,87",BI=185$
|
|||
$LK,"IntInit1",A="FL:::/Kernel/KInts.HC,180",BI=186$
|
||||
$LK,"CH_CURSOR",A="FL:::/Kernel/KernelA.HH,3452"$
|
||||
$LK,"IntInit2",A="FL:::/Kernel/KInts.HC,195",BI=187$
|
||||
$LK,"MemCompare",A="FL:::/Kernel/KernelB.HH,167"$
|
||||
$LK,"DOCT_CURSOR",A="FL:::/Kernel/KernelA.HH,910"$
|
||||
$LK,"GetKey",A="FL:::/Kernel/SerialDev/Message.HC,142",BI=188$
|
||||
$LK,"ROP_MONO",A="FL:::/Kernel/KernelA.HH,2901"$
|
||||
|
@ -916,7 +918,7 @@ $LK,"TK_IFDEF",A="FL:::/Kernel/KernelA.HH,2111"$
|
|||
$LK,"REGT_R64",A="FL:::/Kernel/KernelA.HH,747"$
|
||||
$LK,"SingleUser",A="FL:::/Kernel/KMisc.HC,302",BI=190$
|
||||
$LK,"Date2Struct",A="FL:::/Kernel/KDate.HC,39",BI=191$
|
||||
$LK,"ZCAlloc",A="FL:::/Kernel/Mem/MAllocFree.HC,402",BI=192$
|
||||
$LK,"ZCAlloc",A="FL:::/Kernel/Memory/MAllocFree.HC,402",BI=192$
|
||||
$LK,"progress4_tf",A="FL:::/Kernel/KernelB.HH,232"$
|
||||
$LK,"CFile",A="FL:::/Kernel/KernelA.HH,2763"$
|
||||
$LK,"Fault2",A="FL:::/Kernel/KDebug.HC,596",BI=193$
|
||||
|
@ -1014,6 +1016,7 @@ $LK,"DOCEF_LEFT_EXP",A="FL:::/Kernel/KernelA.HH,975"$
|
|||
$LK,"ATAPIWaitReady",A="FL:::/Kernel/BlkDev/DiskATA.HC,337",BI=216$
|
||||
$LK,"Message",A="FL:::/Kernel/Job.HC,259",BI=217$
|
||||
$LK,"MESSAGE_MS_R_DOWN",A="FL:::/Kernel/KernelA.HH,3183"$
|
||||
$LK,"_MEMCOMPARE",A="FL:::/Kernel/KUtils.HC,70"$
|
||||
$LK,"SC_PRTSCRN1",A="FL:::/Kernel/KernelA.HH,3531"$
|
||||
$LK,"FUF_ALL",A="FL:::/Kernel/KernelA.HH,2569"$
|
||||
$LK,"SEMA_DISK_CACHE",A="FL:::/Kernel/KernelA.HH,622"$
|
||||
|
@ -1033,7 +1036,7 @@ $LK,"MinI64",A="FL:::/Kernel/KernelB.HH,101"$
|
|||
$LK,"MaxU64",A="FL:::/Kernel/KernelB.HH,100"$
|
||||
$LK,"CallInd",A="FL:::/Kernel/KernelB.HH,49"$
|
||||
$LK,"EndianI64",A="FL:::/Kernel/KMisc.HC,25",BI=223$
|
||||
$LK,"_MSIZE",A="FL:::/Kernel/Mem/MAllocFree.HC,337"$
|
||||
$LK,"_MSIZE",A="FL:::/Kernel/Memory/MAllocFree.HC,337"$
|
||||
$LK,"GVF_IMPORT",A="FL:::/Kernel/KernelA.HH,872"$
|
||||
$LK,"HTF_IMPORT",A="FL:::/Kernel/KernelA.HH,709"$
|
||||
$LK,"HTf_IMPORT",A="FL:::/Kernel/KernelA.HH,679"$
|
||||
|
@ -1134,7 +1137,7 @@ $LK,"JobDel",A="FL:::/Kernel/Job.HC,1",BI=239$
|
|||
$LK,"SC_F6",A="FL:::/Kernel/KernelA.HH,3522"$
|
||||
$LK,"SysGrInit",A="FL:::/Kernel/KMain.HC,65",BI=240$
|
||||
$LK,"ArcCtrlDel",A="FL:::/Kernel/Compress.HC,244",BI=241$
|
||||
$LK,"SysBadMAlloc",A="FL:::/Kernel/Mem/MemPag.HC,6",BI=242$
|
||||
$LK,"SysBadMAlloc",A="FL:::/Kernel/Memory/MemPag.HC,6",BI=242$
|
||||
$LK,"SC_F7",A="FL:::/Kernel/KernelA.HH,3523"$
|
||||
$LK,"DOCSS_NORMAL",A="FL:::/Kernel/KernelA.HH,1133"$
|
||||
$LK,"GVF_EXTERN",A="FL:::/Kernel/KernelA.HH,873"$
|
||||
|
@ -1159,7 +1162,7 @@ $LK,"PutDirLink",A="FL:::/Kernel/BlkDev/DiskDirA.HC,197",BI=246$
|
|||
$LK,"LinkedListSize",A="FL:::/Kernel/KDataTypes.HC,31",BI=247$
|
||||
$LK,"EndianU32",A="FL:::/Kernel/KMisc.HC,15",BI=248$
|
||||
$LK,"EndianU16",A="FL:::/Kernel/KMisc.HC,7",BI=249$
|
||||
$LK,"MemPagTaskFree",A="FL:::/Kernel/Mem/MemPag.HC,153",BI=250$
|
||||
$LK,"MemPagTaskFree",A="FL:::/Kernel/Memory/MemPag.HC,153",BI=250$
|
||||
$LK,"DOCEf_SOLID_BORDER",A="FL:::/Kernel/KernelA.HH,1096"$
|
||||
$LK,"DOCEF_LEFT_IN_STR",A="FL:::/Kernel/KernelA.HH,989"$
|
||||
$LK,"sys_pci_busses",A="FL:::/Kernel/KernelB.HH,248"$
|
||||
|
@ -1264,7 +1267,6 @@ $LK,"SYS_HASH_BUCKET_FIND",A="FL:::/Kernel/KHashA.HC,109"$
|
|||
$LK,"BOOT_SRC_DVD",A="FL:::/Kernel/KernelA.HH,3843"$
|
||||
$LK,"FUF_RECURSE",A="FL:::/Kernel/KernelA.HH,2565"$
|
||||
$LK,"FUf_RECURSE",A="FL:::/Kernel/KernelA.HH,2537"$
|
||||
$LK,"MemCmp",A="FL:::/Kernel/KernelB.HH,167"$
|
||||
$LK,"CallStackGrow",A="FL:::/Kernel/KTask.HC,110",BI=266$
|
||||
$LK,"SC_PAGE_UP",A="FL:::/Kernel/KernelA.HH,3511"$
|
||||
$LK,"User",A="FL:::/Kernel/KTask.HC,424",BI=267$
|
||||
|
@ -1304,7 +1306,6 @@ $LK,"DOCEf_BIN_PTR_LINK",A="FL:::/Kernel/KernelA.HH,1068"$
|
|||
$LK,"SSF_NO_TENSION",A="FL:::/Kernel/KernelA.HH,227"$
|
||||
$LK,"I32",A="FL:::/Kernel/KernelA.HH,88"$
|
||||
$LK,"I16",A="FL:::/Kernel/KernelA.HH,74"$
|
||||
$LK,"MemCpy",A="FL:::/Kernel/KernelB.HH,169"$
|
||||
$LK,"CT_NONE",A="FL:::/Kernel/KernelA.HH,3687"$
|
||||
$LK,"OM_IW",A="FL:::/Kernel/KernelA.HH,1886"$
|
||||
$LK,"VGAP_DATA",A="FL:::/Kernel/KernelA.HH,3672"$
|
||||
|
@ -1399,7 +1400,7 @@ $LK,"MEM_FREE_PAG_HASH_SIZE",A="FL:::/Kernel/KernelA.HH,2835"$
|
|||
$LK,"RLF_AUTO_COMPLETE",A="FL:::/Kernel/KernelA.HH,492"$
|
||||
$LK,"SYS_KERNEL_END",A="FL:::/Kernel/KMain.HC,231"$
|
||||
$LK,"TakeExcept",A="FL:::/Kernel/KExcept.HC,42"$
|
||||
$LK,"_MALLOC",A="FL:::/Kernel/Mem/MAllocFree.HC,5"$
|
||||
$LK,"_MALLOC",A="FL:::/Kernel/Memory/MAllocFree.HC,5"$
|
||||
$LK,"CHashDefineStr",A="FL:::/Kernel/KernelA.HH,829"$
|
||||
$LK,"MemSet",A="FL:::/Kernel/KernelB.HH,171"$
|
||||
$LK,"_TRUNC",A="FL:::/Kernel/KMathA.HC,400"$
|
||||
|
@ -1446,7 +1447,7 @@ $LK,"TaskQueueRemove",A="FL:::/Kernel/Sched.HC,301",BI=305$
|
|||
$LK,"U64",A="FL:::/Kernel/KernelA.HH,96"$
|
||||
$LK,"FSize",A="FL:::/Kernel/BlkDev/DiskCFile.HC,1",BI=306$
|
||||
$LK,"IntEntrySet",A="FL:::/Kernel/KInts.HC,109",BI=307$
|
||||
$LK,"Mem32DevIns",A="FL:::/Kernel/Mem/MemPhysical.HC,1",BI=308$
|
||||
$LK,"Mem32DevIns",A="FL:::/Kernel/Memory/MemPhysical.HC,1",BI=308$
|
||||
$LK,"FUf_FLATTEN_TREE",A="FL:::/Kernel/KernelA.HH,2560"$
|
||||
$LK,"WIf_FOCUS_TASK_MS_L",A="FL:::/Kernel/KernelA.HH,1462"$
|
||||
$LK,"WIF_SELF_MS_L",A="FL:::/Kernel/KernelA.HH,1422"$
|
||||
|
@ -1503,7 +1504,6 @@ $LK,"ansf",A="FL:::/Kernel/KernelA.HH,3367"$
|
|||
$LK,"BlkDevsInitAll",A="FL:::/Kernel/BlkDev/DiskAddDev.HC,225",BI=321$
|
||||
$LK,"SysUntry",A="FL:::/Kernel/KExcept.HC,77",BI=322$
|
||||
$LK,"WIF_FOCUS_TASK_BORDER",A="FL:::/Kernel/KernelA.HH,1440"$
|
||||
$LK,"_MEMCMP",A="FL:::/Kernel/KUtils.HC,70"$
|
||||
$LK,"DISPLAYf_NO_BORDER",A="FL:::/Kernel/KernelA.HH,3250"$
|
||||
$LK,"DOCEF_DEFAULT_LEN",A="FL:::/Kernel/KernelA.HH,1029"$
|
||||
$LK,"OFF",A="FL:::/Kernel/KernelA.HH,23"$
|
||||
|
@ -1546,7 +1546,6 @@ $LK,"TASK_CONTEXT_SAVE",A="FL:::/Kernel/Sched.HC,56"$
|
|||
$LK,"SCf_NEW_KEY",A="FL:::/Kernel/KernelA.HH,3471"$
|
||||
$LK,"CDirContext",A="FL:::/Kernel/KernelA.HH,2747"$
|
||||
$LK,"BootDVDProbeAll",A="FL:::/Kernel/BlkDev/DiskATAId.HC,29",BI=331$
|
||||
$LK,"_MEMCPY",A="FL:::/Kernel/KUtils.HC,55"$
|
||||
$LK,"_D3_DIST_SQR",A="FL:::/Kernel/KMathA.HC,61"$
|
||||
$LK,"ARGT_XMM64",A="FL:::/Kernel/KernelA.HH,1954"$
|
||||
$LK,"ATAWriteBlks",A="FL:::/Kernel/BlkDev/DiskATA.HC,464",BI=332$
|
||||
|
@ -1578,7 +1577,7 @@ $LK,"SYS_HASH_SINGLE_TABLE_FIND",A="FL:::/Kernel/KHashA.HC,41"$
|
|||
$LK,"OC_OP_SIZE_PREFIX",A="FL:::/Kernel/KernelA.HH,1767"$
|
||||
$LK,"CCF_UNRESOLVED",A="FL:::/Kernel/KernelA.HH,2158"$
|
||||
$LK,"MLF_FUN",A="FL:::/Kernel/KernelA.HH,782"$
|
||||
$LK,"ZStrNew",A="FL:::/Kernel/Mem/MAllocFree.HC,461",BI=338$
|
||||
$LK,"ZStrNew",A="FL:::/Kernel/Memory/MAllocFree.HC,461",BI=338$
|
||||
$LK,"ExtDefault",A="FL:::/Kernel/BlkDev/DiskStrA.HC,212",BI=339$
|
||||
$LK,"DOCEF_ZERO_BASED",A="FL:::/Kernel/KernelA.HH,1019"$
|
||||
$LK,"HTF_UNRESOLVED",A="FL:::/Kernel/KernelA.HH,713"$
|
||||
|
@ -1612,7 +1611,7 @@ $LK,"CCF_KEEP_SIGN_NUM",A="FL:::/Kernel/KernelA.HH,2147"$
|
|||
$LK,"HashFind",A="FL:::/Kernel/KHashA.HC,255"$
|
||||
$LK,"D3Cross",A="FL:::/Kernel/KernelB.HH,148"$
|
||||
$LK,"DOCEF_ESC",A="FL:::/Kernel/KernelA.HH,1004"$
|
||||
$LK,"_FREE",A="FL:::/Kernel/Mem/MAllocFree.HC,224"$
|
||||
$LK,"_FREE",A="FL:::/Kernel/Memory/MAllocFree.HC,224"$
|
||||
$LK,"SrcLineNum",A="FL:::/Kernel/FunSeg.HC,206",BI=349$
|
||||
$LK,"ATAPIClose",A="FL:::/Kernel/BlkDev/DiskATA.HC,524",BI=350$
|
||||
$LK,"DOCT_MACRO",A="FL:::/Kernel/KernelA.HH,938"$
|
||||
|
@ -1622,11 +1621,11 @@ $LK,"CDATE_YEAR_DAYS",A="FL:::/Kernel/KernelA.HH,184"$
|
|||
$LK,"RFLAGf_OVERFLOW",A="FL:::/Kernel/KernelA.HH,329"$
|
||||
$LK,"SYS_POW",A="FL:::/Kernel/KMathA.HC,462"$
|
||||
$LK,"DRIVE_SIGNATURE_VAL",A="FL:::/Kernel/KernelA.HH,2687"$
|
||||
$LK,"StrNICmp",A="FL:::/Kernel/StrA.HC,315"$
|
||||
$LK,"ARf_CSPRITE_INS_CLIP",A="FL:::/Kernel/KernelA.HH,3851"$
|
||||
$LK,"DOCf_NULL_GRAB_SCROLL",A="FL:::/Kernel/KernelA.HH,1326"$
|
||||
$LK,"DOCEf_RIGHT_X",A="FL:::/Kernel/KernelA.HH,1082"$
|
||||
$LK,"DOCEF_RIGHT_X",A="FL:::/Kernel/KernelA.HH,994"$
|
||||
$LK,"StrICompare",A="FL:::/Kernel/StrA.HC,311"$
|
||||
$LK,"DCF_FILL_NOT_COLOR",A="FL:::/Kernel/KernelA.HH,3582"$
|
||||
$LK,"WIF_FOCUS_TASK_MS_WHEEL",A="FL:::/Kernel/KernelA.HH,1439"$
|
||||
$LK,"Debug",A="FL:::/Kernel/KDebug.HC,649",BI=351$
|
||||
|
@ -1638,6 +1637,7 @@ $LK,"_MEMSET",A="FL:::/Kernel/KUtils.HC,3"$
|
|||
$LK,"ROP_COLLISION",A="FL:::/Kernel/KernelA.HH,2900"$
|
||||
$LK,"TK_PLUS_PLUS",A="FL:::/Kernel/KernelA.HH,2088"$
|
||||
$LK,"char_bmp_safe_dollar",A="FL:::/Kernel/StrA.HC,386"$
|
||||
$LK,"StrNICompare",A="FL:::/Kernel/StrA.HC,315"$
|
||||
$LK,"sys_heap_init_val",A="FL:::/Kernel/KernelB.HH,182"$
|
||||
$LK,"DOCEF_DEREF_DATA",A="FL:::/Kernel/KernelA.HH,1016"$
|
||||
$LK,"VGAP_REG_WRITE",A="FL:::/Kernel/KernelA.HH,3675"$
|
||||
|
@ -1713,6 +1713,7 @@ $LK,"RFLAGf_CARRY",A="FL:::/Kernel/KernelA.HH,321"$
|
|||
$LK,"FAT32FileRead",A="FL:::/Kernel/BlkDev/FileSysFAT.HC,355",BI=371$
|
||||
$LK,"DirFilesFlatten",A="FL:::/Kernel/BlkDev/DiskDirA.HC,133",BI=372$
|
||||
$LK,"FileExtDot",A="FL:::/Kernel/BlkDev/DiskStrA.HC,1",BI=373$
|
||||
$LK,"_STRICOMPARE",A="FL:::/Kernel/StrA.HC,117"$
|
||||
$LK,"Bts",A="FL:::/Kernel/KernelB.HH,20"$
|
||||
$LK,"CMemBlk",A="FL:::/Kernel/KernelA.HH,2814"$
|
||||
$LK,"Man",A="FL:::/Kernel/FunSeg.HC,346",BI=374$
|
||||
|
@ -1720,7 +1721,7 @@ $LK,"TK_SHR_EQU",A="FL:::/Kernel/KernelA.HH,2102"$
|
|||
$LK,"CDATE_FREQ",A="FL:::/Kernel/KernelA.HH,572"$
|
||||
$LK,"FilesFind",A="FL:::/Kernel/BlkDev/DiskFind.HC,27",BI=375$
|
||||
$LK,"_HASH_FIND",A="FL:::/Kernel/KHashA.HC,129"$
|
||||
$LK,"MSize",A="FL:::/Kernel/Mem/MAllocFree.HC,384"$
|
||||
$LK,"MSize",A="FL:::/Kernel/Memory/MAllocFree.HC,384"$
|
||||
$LK,"CSysFixedArea",A="FL:::/Kernel/KernelA.HH,3415"$
|
||||
$LK,"ExeCmdLine",A="FL:::/Kernel/KTask.HC,302",BI=376$
|
||||
$LK,"Log10",A="FL:::/Kernel/KernelB.HH,135"$
|
||||
|
@ -1730,6 +1731,7 @@ $LK,"CallExtStr",A="FL:::/Kernel/KernelB.HH,46"$
|
|||
$LK,"VGAM_GRAPHICS",A="FL:::/Kernel/KernelA.HH,3663"$
|
||||
$LK,"DCF_LOCATE_NEAREST",A="FL:::/Kernel/KernelA.HH,3578"$
|
||||
$LK,"Ff_ARGPOP",A="FL:::/Kernel/KernelA.HH,854"$
|
||||
$LK,"_STRNICOMPARE",A="FL:::/Kernel/StrA.HC,183"$
|
||||
$LK,"SCF_ALT",A="FL:::/Kernel/KernelA.HH,3482"$
|
||||
$LK,"CViewAngles",A="FL:::/Kernel/KernelA.HH,3058"$
|
||||
$LK,"CArrayDim",A="FL:::/Kernel/KernelA.HH,787"$
|
||||
|
@ -1802,9 +1804,9 @@ $LK,"SYS_PROGRESS3_MAX",A="FL:::/Kernel/KStart32.HC,52"$
|
|||
$LK,"SUF_REM_LEADING",A="FL:::/Kernel/KernelA.HH,3731"$
|
||||
$LK,"OPTf_USE_IMM64",A="FL:::/Kernel/KernelA.HH,1558"$
|
||||
$LK,"Raw",A="FL:::/Kernel/KMisc.HC,290",BI=395$
|
||||
$LK,"ZMAlloc",A="FL:::/Kernel/Mem/MAllocFree.HC,390",BI=396$
|
||||
$LK,"ZMAlloc",A="FL:::/Kernel/Memory/MAllocFree.HC,390",BI=396$
|
||||
$LK,"DOCT_PROMPT",A="FL:::/Kernel/KernelA.HH,912"$
|
||||
$LK,"MemPagAlloc",A="FL:::/Kernel/Mem/MemPag.HC,11",BI=397$
|
||||
$LK,"MemPagAlloc",A="FL:::/Kernel/Memory/MemPag.HC,11",BI=397$
|
||||
$LK,"OPTf_GLBLS_ON_DATA_HEAP",A="FL:::/Kernel/KernelA.HH,1555"$
|
||||
$LK,"KbdInit",A="FL:::/Kernel/SerialDev/Keyboard.HC,424",BI=398$
|
||||
$LK,"ToBool",A="FL:::/Kernel/KernelB.HH,119"$
|
||||
|
@ -1875,7 +1877,7 @@ $LK,"WIf_SELF_BORDER",A="FL:::/Kernel/KernelA.HH,1455"$
|
|||
$LK,"text",A="FL:::/Kernel/KGlobals.HC,30"$
|
||||
$LK,"ATA_READ_NATIVE_MAX_EXT",A="FL:::/Kernel/KernelA.HH,2273"$
|
||||
$LK,"MPrintQ",A="FL:::/Kernel/StrPrint.HC,56",BI=410$
|
||||
$LK,"MHeapCtrl",A="FL:::/Kernel/Mem/MAllocFree.HC,386"$
|
||||
$LK,"MHeapCtrl",A="FL:::/Kernel/Memory/MAllocFree.HC,386"$
|
||||
$LK,"CCF_CMD_LINE",A="FL:::/Kernel/KernelA.HH,2137"$
|
||||
$LK,"RECALCt_FIND_CURSOR",A="FL:::/Kernel/KernelA.HH,1360"$
|
||||
$LK,"CCF_RAX",A="FL:::/Kernel/KernelA.HH,2167"$
|
||||
|
@ -1950,7 +1952,7 @@ $LK,"CT_7_BIT",A="FL:::/Kernel/KernelA.HH,3688"$
|
|||
$LK,"PUSH_REGS",A="FL:::/Kernel/KernelA.HH,1779"$
|
||||
$LK,"KbdMouseHandler",A="FL:::/Kernel/SerialDev/Mouse.HC,313",BI=426$
|
||||
$LK,"Color2Str",A="FL:::/Kernel/KDefine.HC,127",BI=427$
|
||||
$LK,"MAllocIdent",A="FL:::/Kernel/Mem/MAllocFree.HC,407",BI=428$
|
||||
$LK,"MAllocIdent",A="FL:::/Kernel/Memory/MAllocFree.HC,407",BI=428$
|
||||
$LK,"EDF_COLLAPSE",A="FL:::/Kernel/KernelA.HH,1259"$
|
||||
$LK,"CTRL_ALT_X",A="FL:::/Kernel/KernelA.HH,636"$
|
||||
$LK,"LAPIC_DFR",A="FL:::/Kernel/KernelA.HH,507"$
|
||||
|
@ -1962,7 +1964,7 @@ $LK,"EDf_COLLAPSE",A="FL:::/Kernel/KernelA.HH,1265"$
|
|||
$LK,"QuickSort2b",A="FL:::/Kernel/QuickSort.HC,55",BI=431$
|
||||
$LK,"MPrintq",A="FL:::/Kernel/StrPrint.HC,113",BI=432$
|
||||
$LK,"LinkedListCount",A="FL:::/Kernel/KDataTypes.HC,21",BI=433$
|
||||
$LK,"ZMAllocIdent",A="FL:::/Kernel/Mem/MAllocFree.HC,418",BI=434$
|
||||
$LK,"ZMAllocIdent",A="FL:::/Kernel/Memory/MAllocFree.HC,418",BI=434$
|
||||
$LK,"sys_font_cyrillic",A="FL:::/Kernel/FontCyrillic.HC,3"$
|
||||
$LK,"SYS_FOCUS_TASK",A="FL:::/Kernel/KStart32.HC,63"$
|
||||
$LK,"DYING_JIFFIES",A="FL:::/Kernel/KernelA.HH,3264"$
|
||||
|
@ -1973,13 +1975,14 @@ $LK,"OutU32",A="FL:::/Kernel/KernelB.HH,79"$
|
|||
$LK,"OutU16",A="FL:::/Kernel/KernelB.HH,78"$
|
||||
$LK,"LAPIC_ICR_HIGH",A="FL:::/Kernel/KernelA.HH,517"$
|
||||
$LK,"LMF_IGNORE_CASE",A="FL:::/Kernel/KernelA.HH,3749"$
|
||||
$LK,"StrCompare",A="FL:::/Kernel/StrA.HC,309"$
|
||||
$LK,"SFF_IGNORE_CASE",A="FL:::/Kernel/KernelA.HH,3743"$
|
||||
$LK,"HashRemDel",A="FL:::/Kernel/KHashA.HC,264"$
|
||||
$LK,"REG_RSI",A="FL:::/Kernel/KernelA.HH,1790"$
|
||||
$LK,"HashAdd",A="FL:::/Kernel/KHashA.HC,262"$
|
||||
$LK,"MLF_DOT_DOT_DOT",A="FL:::/Kernel/KernelA.HH,783"$
|
||||
$LK,"IsSuspended",A="FL:::/Kernel/KTask.HC,91",BI=435$
|
||||
$LK,"CAlloc",A="FL:::/Kernel/Mem/MAllocFree.HC,395",BI=436$
|
||||
$LK,"CAlloc",A="FL:::/Kernel/Memory/MAllocFree.HC,395",BI=436$
|
||||
$LK,"BDF_INITIALIZED",A="FL:::/Kernel/KernelA.HH,2610"$
|
||||
$LK,"CAsmUnresolvedRef",A="FL:::/Kernel/KernelA.HH,1866"$
|
||||
$LK,"BDf_INITIALIZED",A="FL:::/Kernel/KernelA.HH,2620"$
|
||||
|
@ -2009,7 +2012,7 @@ $LK,"I_DIV_ZERO",A="FL:::/Kernel/KernelA.HH,300"$
|
|||
$LK,"DOCEF_DEFINE",A="FL:::/Kernel/KernelA.HH,973"$
|
||||
$LK,"DOC_DEFAULT",A="FL:::/Kernel/KernelA.HH,1168"$
|
||||
$LK,"DOCEf_DEFINE",A="FL:::/Kernel/KernelA.HH,1061"$
|
||||
$LK,"HeapCtrlInit",A="FL:::/Kernel/Mem/HeapCtrl.HC,1",BI=439$
|
||||
$LK,"HeapCtrlInit",A="FL:::/Kernel/Memory/HeapCtrl.HC,1",BI=439$
|
||||
$LK,"MESSAGE_MS_MOVE",A="FL:::/Kernel/KernelA.HH,3178"$
|
||||
$LK,"SEMA_DBG_MODE",A="FL:::/Kernel/KernelA.HH,615"$
|
||||
$LK,"BlkWriteZero",A="FL:::/Kernel/BlkDev/DiskBlk.HC,2",BI=440$
|
||||
|
@ -2063,7 +2066,8 @@ $LK,"ICF_DONT_RESTORE",A="FL:::/Kernel/KernelA.HH,1631"$
|
|||
$LK,"RedSeaDirNew",A="FL:::/Kernel/BlkDev/FileSysRedSea.HC,350",BI=452$
|
||||
$LK,"IET_REL64_EXPORT",A="FL:::/Kernel/KernelA.HH,421"$
|
||||
$LK,"IET_REL32_EXPORT",A="FL:::/Kernel/KernelA.HH,419"$
|
||||
$LK,"SYS_INIT_16MEG_SYS_CODE_BP",A="FL:::/Kernel/Mem/PageTables.HC,157"$
|
||||
$LK,"_STRCOMPARE",A="FL:::/Kernel/StrA.HC,86"$
|
||||
$LK,"SYS_INIT_16MEG_SYS_CODE_BP",A="FL:::/Kernel/Memory/PageTables.HC,157"$
|
||||
$LK,"CExcept",A="FL:::/Kernel/KernelA.HH,3116"$
|
||||
$LK,"DiskCacheInit",A="FL:::/Kernel/BlkDev/DiskCache.HC,1",BI=453$
|
||||
$LK,"SYS_EXTERN_TABLE",A="FL:::/Kernel/KStart32.HC,35"$
|
||||
|
@ -2131,8 +2135,8 @@ $LK,"QueueInit",A="FL:::/Kernel/KernelB.HH,66"$
|
|||
$LK,"DOCT_MENU_VAL",A="FL:::/Kernel/KernelA.HH,939"$
|
||||
$LK,"CQueueD3I32",A="FL:::/Kernel/KernelA.HH,133"$
|
||||
$LK,"Bcd2Bin",A="FL:::/Kernel/KDate.HC,123",BI=461$
|
||||
$LK,"CAllocAligned",A="FL:::/Kernel/Mem/MAllocFree.HC,434",BI=462$
|
||||
$LK,"MAllocAligned",A="FL:::/Kernel/Mem/MAllocFree.HC,423",BI=463$
|
||||
$LK,"CAllocAligned",A="FL:::/Kernel/Memory/MAllocFree.HC,434",BI=462$
|
||||
$LK,"MAllocAligned",A="FL:::/Kernel/Memory/MAllocFree.HC,423",BI=463$
|
||||
$LK,"ext",A="FL:::/Kernel/KernelB.HH,53"$
|
||||
$LK,"FUN_SEG_CACHE_SIZE",A="FL:::/Kernel/KernelA.HH,3800"$
|
||||
$LK,"DRIVES_NUM",A="FL:::/Kernel/KernelA.HH,2685"$
|
||||
|
@ -2140,11 +2144,10 @@ $LK,"ACf_INIT_IN_PROGRESS",A="FL:::/Kernel/KernelA.HH,1495"$
|
|||
$LK,"RawDm",A="FL:::/Kernel/KDebug.HC,250",BI=464$
|
||||
$LK,"ICf_DONT_POP_FLOAT0",A="FL:::/Kernel/KernelA.HH,1624"$
|
||||
$LK,"MPNMInt",A="FL:::/Kernel/MultiProc.HC,159",BI=465$
|
||||
$LK,"_MSIZE2",A="FL:::/Kernel/Mem/MAllocFree.HC,353"$
|
||||
$LK,"_MSIZE2",A="FL:::/Kernel/Memory/MAllocFree.HC,353"$
|
||||
$LK,"DiskCacheAdd",A="FL:::/Kernel/BlkDev/DiskCache.HC,76",BI=466$
|
||||
$LK,"LTPURPLE",A="FL:::/Kernel/KernelA.HH,2927"$
|
||||
$LK,"RawDr",A="FL:::/Kernel/KDebug.HC,291",BI=467$
|
||||
$LK,"StrICmp",A="FL:::/Kernel/StrA.HC,311"$
|
||||
$LK,"ATAR0_DATA",A="FL:::/Kernel/KernelA.HH,2288"$
|
||||
$LK,"OPTf_TRACE",A="FL:::/Kernel/KernelA.HH,1547"$
|
||||
$LK,"HTG_FLAGS_MASK",A="FL:::/Kernel/KernelA.HH,715"$
|
||||
|
@ -2174,7 +2177,7 @@ $LK,"CHashImport",A="FL:::/Kernel/KernelA.HH,769"$
|
|||
$LK,"CMT_LABEL",A="FL:::/Kernel/KernelA.HH,1697"$
|
||||
$LK,"C32_ADD",A="FL:::/Kernel/PCIBIOS.HC,122"$
|
||||
$LK,"MBS_USED_SIGNATURE_VAL",A="FL:::/Kernel/KernelA.HH,2812"$
|
||||
$LK,"HeapCtrlDel",A="FL:::/Kernel/Mem/HeapCtrl.HC,15",BI=470$
|
||||
$LK,"HeapCtrlDel",A="FL:::/Kernel/Memory/HeapCtrl.HC,15",BI=470$
|
||||
$LK,"_CALLEXTSTR",A="FL:::/Kernel/KUtils.HC,392"$
|
||||
$LK,"SYS_PROGRESS2_T0",A="FL:::/Kernel/KStart32.HC,48"$
|
||||
$LK,"FF_USE_OLD_DATETIME",A="FL:::/Kernel/KernelA.HH,2761"$
|
||||
|
@ -2275,7 +2278,6 @@ $LK,"BDT_ATA",A="FL:::/Kernel/KernelA.HH,2603"$
|
|||
$LK,"RFLAGf_RESUME",A="FL:::/Kernel/KernelA.HH,333"$
|
||||
$LK,"C32_EAX",A="FL:::/Kernel/PCIBIOS.HC,58"$
|
||||
$LK,"PortNop",A="FL:::/Kernel/KMisc.HC,1",BI=486$
|
||||
$LK,"StrNCmp",A="FL:::/Kernel/StrA.HC,313"$
|
||||
$LK,"FUF_PUBLIC",A="FL:::/Kernel/KernelA.HH,2573"$
|
||||
$LK,"FUf_PUBLIC",A="FL:::/Kernel/KernelA.HH,2545"$
|
||||
$LK,"CFAT32FileInfoSect",A="FL:::/Kernel/KernelA.HH,2381"$
|
||||
|
@ -2297,7 +2299,7 @@ $LK,"U8_MIN",A="FL:::/Kernel/KernelA.HH,27"$
|
|||
$LK,"DiskCacheQueueRemove",A="FL:::/Kernel/BlkDev/DiskCache.HC,46",BI=489$
|
||||
$LK,"JOB_DONE",A="FL:::/Kernel/Job.HC,265"$
|
||||
$LK,"LoadPass2",A="FL:::/Kernel/KLoad.HC,154",BI=490$
|
||||
$LK,"MemPagTaskAlloc",A="FL:::/Kernel/Mem/MemPag.HC,114",BI=491$
|
||||
$LK,"MemPagTaskAlloc",A="FL:::/Kernel/Memory/MemPag.HC,114",BI=491$
|
||||
$LK,"ARf_MANAGE_SLIDER",A="FL:::/Kernel/KernelA.HH,3856"$
|
||||
$LK,"SC_PAGE_DOWN",A="FL:::/Kernel/KernelA.HH,3512"$
|
||||
$LK,"QueueVectU8Del",A="FL:::/Kernel/KDataTypes.HC,132",BI=492$
|
||||
|
@ -2329,11 +2331,11 @@ $LK,"MDf_SIB",A="FL:::/Kernel/KernelA.HH,1587"$
|
|||
$LK,"Freq2Ona",A="FL:::/Kernel/KMisc.HC,171",BI=500$
|
||||
$LK,"RLF_COMPILER",A="FL:::/Kernel/KernelA.HH,487"$
|
||||
$LK,"RLf_COMPILER",A="FL:::/Kernel/KernelA.HH,465"$
|
||||
$LK,"SYS_INIT_PAGE_TABLES",A="FL:::/Kernel/Mem/PageTables.HC,6"$
|
||||
$LK,"SYS_INIT_PAGE_TABLES",A="FL:::/Kernel/Memory/PageTables.HC,6"$
|
||||
$LK,"TASK_NAME_LEN",A="FL:::/Kernel/KernelA.HH,3255"$
|
||||
$LK,"COLORROP_COLORS_MASK",A="FL:::/Kernel/KernelA.HH,2943"$
|
||||
$LK,"C32_ESI",A="FL:::/Kernel/PCIBIOS.HC,62"$
|
||||
$LK,"BlkPoolsInit",A="FL:::/Kernel/Mem/BlkPool.HC,29",BI=501$
|
||||
$LK,"BlkPoolsInit",A="FL:::/Kernel/Memory/BlkPool.HC,29",BI=501$
|
||||
$LK,"SYS_DATA_BP",A="FL:::/Kernel/KStart32.HC,38"$
|
||||
$LK,"VGAP_PALETTE_DATA",A="FL:::/Kernel/KernelA.HH,3676"$
|
||||
$LK,"ATAR0_HCYL",A="FL:::/Kernel/KernelA.HH,2293"$
|
||||
|
@ -2545,7 +2547,6 @@ $LK,"SC_ESC",A="FL:::/Kernel/KernelA.HH,3497"$
|
|||
$LK,"ACD_WORD_CHAR",A="FL:::/Kernel/KernelA.HH,1526"$
|
||||
$LK,"SF_ARG7",A="FL:::/Kernel/KernelA.HH,586"$
|
||||
$LK,"QueueVectU8Put",A="FL:::/Kernel/KDataTypes.HC,96",BI=544$
|
||||
$LK,"StrCmp",A="FL:::/Kernel/StrA.HC,309"$
|
||||
$LK,"DOF_INTERCEPT_TASK_END",A="FL:::/Kernel/KernelA.HH,1227"$
|
||||
$LK,"SF_ARG8",A="FL:::/Kernel/KernelA.HH,587"$
|
||||
$LK,"BlkDevDel",A="FL:::/Kernel/BlkDev/DiskBlkDev.HC,159",BI=545$
|
||||
|
@ -2558,6 +2559,7 @@ $LK,"VGAP_PALETTE_MASK",A="FL:::/Kernel/KernelA.HH,3673"$
|
|||
$LK,"ATAPISync",A="FL:::/Kernel/BlkDev/DiskATA.HC,504",BI=547$
|
||||
$LK,"TO_UPPER",A="FL:::/Kernel/StrA.HC,110"$
|
||||
$LK,"RFLAGG_NORMAL",A="FL:::/Kernel/KernelA.HH,341"$
|
||||
$LK,"StrCopy",A="FL:::/Kernel/StrA.HC,321"$
|
||||
$LK,"KERNEL_MODULE_NAME",A="FL:::/Kernel/KernelA.HH,721"$
|
||||
$LK,"MEM_PAGE_SIZE",A="FL:::/Kernel/KStart32.HC,8"$
|
||||
$LK,"SleepUntil",A="FL:::/Kernel/KMisc.HC,147",BI=548$
|
||||
|
@ -2578,7 +2580,6 @@ $LK,"SC_SHIFT",A="FL:::/Kernel/KernelA.HH,3501"$
|
|||
$LK,"ATA_SET_MAX_EXT",A="FL:::/Kernel/KernelA.HH,2275"$
|
||||
$LK,"CUAsmGlobals",A="FL:::/Kernel/KernelA.HH,2241"$
|
||||
$LK,"StrOcc",A="FL:::/Kernel/StrA.HC,462",BI=552$
|
||||
$LK,"StrCpy",A="FL:::/Kernel/StrA.HC,321"$
|
||||
$LK,"DOCT_INS_BIN",A="FL:::/Kernel/KernelA.HH,943"$
|
||||
$LK,"StrMatch",A="FL:::/Kernel/StrA.HC,317"$
|
||||
$LK,"CMT_JMP_TABLE",A="FL:::/Kernel/KernelA.HH,1701"$
|
||||
|
@ -2630,7 +2631,7 @@ $LK,"MP_VECT_ADDR",A="FL:::/Kernel/KernelA.HH,527"$
|
|||
$LK,"I_WAKE",A="FL:::/Kernel/KernelA.HH,309"$
|
||||
$LK,"Yield",A="FL:::/Kernel/Sched.HC,284"$
|
||||
$LK,"MRT_DEV",A="FL:::/Kernel/KernelA.HH,2822"$
|
||||
$LK,"StrNew",A="FL:::/Kernel/Mem/MAllocFree.HC,446",BI=563$
|
||||
$LK,"StrNew",A="FL:::/Kernel/Memory/MAllocFree.HC,446",BI=563$
|
||||
$LK,"HTT_GLBL_VAR",A="FL:::/Kernel/KernelA.HH,690"$
|
||||
$LK,"HTt_GLBL_VAR",A="FL:::/Kernel/KernelA.HH,660"$
|
||||
$LK,"STACK_REP_LEN",A="FL:::/Kernel/KDebug.HC,102"$
|
||||
|
@ -2749,6 +2750,7 @@ $LK,"ARGT_AL",A="FL:::/Kernel/KernelA.HH,1929"$
|
|||
$LK,"CIntermediateCodeBase",A="FL:::/Kernel/KernelA.HH,1657"$
|
||||
$LK,"SYS_CODE_BP",A="FL:::/Kernel/KStart32.HC,37"$
|
||||
$LK,"LXchgI64",A="FL:::/Kernel/KernelB.HH,264"$
|
||||
$LK,"MemCopy",A="FL:::/Kernel/KernelB.HH,169"$
|
||||
$LK,"TASKf_NONTIMER_RAND",A="FL:::/Kernel/KernelA.HH,3244"$
|
||||
$LK,"ARGT_CL",A="FL:::/Kernel/KernelA.HH,1934"$
|
||||
$LK,"ARGT_M8",A="FL:::/Kernel/KernelA.HH,1914"$
|
||||
|
@ -2756,7 +2758,7 @@ $LK,"TK_F64",A="FL:::/Kernel/KernelA.HH,2087"$
|
|||
$LK,"ICF_ARG1_TO_INT",A="FL:::/Kernel/KernelA.HH,1605"$
|
||||
$LK,"I_USER",A="FL:::/Kernel/KernelA.HH,315"$
|
||||
$LK,"FAT32CDirFill",A="FL:::/Kernel/BlkDev/FileSysFAT.HC,214",BI=589$
|
||||
$LK,"BlkPoolAdd",A="FL:::/Kernel/Mem/BlkPool.HC,1",BI=590$
|
||||
$LK,"BlkPoolAdd",A="FL:::/Kernel/Memory/BlkPool.HC,1",BI=590$
|
||||
$LK,"TK_NORMALSCRIPT",A="FL:::/Kernel/KernelA.HH,2082"$
|
||||
$LK,"PTR_STARS_NUM",A="FL:::/Kernel/KernelA.HH,776"$
|
||||
$LK,"TaskMessage",A="FL:::/Kernel/Job.HC,119",BI=591$
|
||||
|
@ -2777,7 +2779,6 @@ $LK,"MESSAGE_MS_L_D_DOWN",A="FL:::/Kernel/KernelA.HH,3181"$
|
|||
$LK,"ARGT_CS",A="FL:::/Kernel/KernelA.HH,1944"$
|
||||
$LK,"DOCSS_DBL_QUOTE",A="FL:::/Kernel/KernelA.HH,1135"$
|
||||
$LK,"SYS_PCI_SERVICES",A="FL:::/Kernel/PCIBIOS.HC,5"$
|
||||
$LK,"_STRCMP",A="FL:::/Kernel/StrA.HC,86"$
|
||||
$LK,"ARGT_AX",A="FL:::/Kernel/KernelA.HH,1930"$
|
||||
$LK,"LAPIC_PROCESSOR_PRIORITY",A="FL:::/Kernel/KernelA.HH,504"$
|
||||
$LK,"Core0Init",A="FL:::/Kernel/MultiProc.HC,354",BI=592$
|
||||
|
@ -2808,14 +2809,13 @@ $LK,"RFLAGG_START",A="FL:::/Kernel/KernelA.HH,340"$
|
|||
$LK,"CKeyDevEntry",A="FL:::/Kernel/KernelA.HH,3754"$
|
||||
$LK,"HPET_MAIN_COUNT",A="FL:::/Kernel/KernelA.HH,556"$
|
||||
$LK,"XTalkWait",A="FL:::/Kernel/Job.HC,454",BI=595$
|
||||
$LK,"MemPageTable",A="FL:::/Kernel/Mem/PageTables.HC,199",BI=596$
|
||||
$LK,"MemPageTable",A="FL:::/Kernel/Memory/PageTables.HC,199",BI=596$
|
||||
$LK,"ARGT_MM",A="FL:::/Kernel/KernelA.HH,1948"$
|
||||
$LK,"Zenith",A="FL:::/Kernel/Job.HC,406",BI=597$
|
||||
$LK,"SysHlt",A="FL:::/Kernel/KernelB.HH,270"$
|
||||
$LK,"FUF_JUST_DIRS",A="FL:::/Kernel/KernelA.HH,2577"$
|
||||
$LK,"CD2I64",A="FL:::/Kernel/KernelA.HH,143"$
|
||||
$LK,"CD3I32",A="FL:::/Kernel/KernelA.HH,129"$
|
||||
$LK,"_STRCPY",A="FL:::/Kernel/StrA.HC,65"$
|
||||
$LK,"DiskCacheInvalidate",A="FL:::/Kernel/BlkDev/DiskDrive.HC,218",BI=598$
|
||||
$LK,"YELLOW",A="FL:::/Kernel/KernelA.HH,2928"$
|
||||
$LK,"FUf_JUST_DIRS",A="FL:::/Kernel/KernelA.HH,2549"$
|
||||
|
|
|
@ -28,7 +28,7 @@
|
|||
#include "KGlobals"
|
||||
#include "KMathB"
|
||||
#include "Sched"
|
||||
#include "Mem/MakeMem"
|
||||
#include "Memory/MakeMemory"
|
||||
#include "FontStd"
|
||||
#include "FontCyrillic"
|
||||
#include "StrB"
|
||||
|
|
|
@ -163,9 +163,9 @@ public _extern _D3_UNIT CD3 *D3Unit(CD3 *d); //To unit vect
|
|||
public _extern _D3_ZERO CD3 *D3Zero(CD3 *dst); //To zero
|
||||
|
||||
#help_index "Memory"
|
||||
public _extern _MEMCMP I64 MemCmp(
|
||||
public _extern _MEMCOMPARE I64 MemCompare(
|
||||
U8 *ptr1,U8 *ptr2,I64 count); //Compare chunk of memory.
|
||||
public _extern _MEMCPY U8 *MemCpy(
|
||||
public _extern _MEMCOPY U8 *MemCopy(
|
||||
U8 *dst,U8 *src,I64 count); //Copy chunk of memory. Only goes fwd.
|
||||
public _extern _MEMSET U8 *MemSet(
|
||||
U8 *dst,I64 val,I64 count); //Set chunk of U8s to value.
|
||||
|
|
|
@ -64,18 +64,18 @@ public extern U8 *MStrPrint(U8 *format,...);
|
|||
public extern U8 *MStrUtil(U8 *src,I64 flags,F64 indent_scale_factor=0);
|
||||
public extern U8 *ScaleIndent(U8 *src,F64 indent_scale_factor);
|
||||
public extern I64 Spaces2Tabs(U8 *dst,U8 *src);
|
||||
public _extern _STRCMP I64 StrCmp(U8 *st1,U8 *st2);
|
||||
public _extern _STRCPY U0 StrCpy(U8 *dst,U8 *src);
|
||||
public _extern _STRCOMPARE I64 StrCompare(U8 *st1,U8 *st2);
|
||||
public _extern _STRCOPY U0 StrCopy(U8 *dst,U8 *src);
|
||||
public extern U8 *StrFind(U8 *needle,U8 *haystack_str,I64 flags=0);
|
||||
public extern U8 *StrFirstOcc(U8 *src,U8 *marker);
|
||||
public extern U8 *StrFirstRemove(U8 *src,U8 *marker,U8 *dst=NULL);
|
||||
public _extern _STRICMP I64 StrICmp(U8 *st1,U8 *st2);
|
||||
public _extern _STRICOMPARE I64 StrICompare(U8 *st1,U8 *st2);
|
||||
public _extern _STRIMATCH U8 *StrIMatch(U8 *needle,U8 *haystack_str);
|
||||
public extern U8 *StrLastOcc(U8 *src,U8 *marker);
|
||||
public extern U8 *StrLastRemove(U8 *src,U8 *marker,U8 *dst=NULL);
|
||||
public _extern _STRMATCH U8 *StrMatch(U8 *needle,U8 *haystack_str);
|
||||
public _extern _STRNCMP I64 StrNCmp(U8 *st1,U8 *st2,I64 n);
|
||||
public _extern _STRNICMP I64 StrNICmp(U8 *st1,U8 *st2,I64 n);
|
||||
public _extern _STRNCOMPARE I64 StrNCompare(U8 *st1,U8 *st2,I64 n);
|
||||
public _extern _STRNICOMPARE I64 StrNICompare(U8 *st1,U8 *st2,I64 n);
|
||||
public extern I64 StrOcc(U8 *src, U8 ch);
|
||||
public extern U8 *StrPrint(U8 *dst,U8 *format,...);
|
||||
public extern U8 *StrPrintJoin(U8 *dst,U8 *format,I64 argc,I64 *argv);
|
||||
|
|
|
@ -56,7 +56,7 @@ U0 PutS(U8 *st)
|
|||
U0 KeyDescSet(U8 *format,...)
|
||||
{//Call this from key handler to report desc in $LK,"KeyMap",A="MN:KeyMap"$().
|
||||
U8 *buf=StrPrintJoin(NULL,format,argc,argv);
|
||||
StrCpy(keydev.desc,buf);
|
||||
StrCopy(keydev.desc,buf);
|
||||
keydev.handler=Caller;
|
||||
Free(buf);
|
||||
}
|
||||
|
|
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue