From 66b9e3183fbc7be51c82a538021f6642665809e7 Mon Sep 17 00:00:00 2001 From: "Terry A. Davis" Date: Wed, 15 Mar 2017 00:27:25 -0400 Subject: [PATCH] TempleOS V5.03 Nightly (ISO SHA-1 54758c6) --- 0000Boot/0000Kernel.BIN.C | Bin 192080 -> 192080 bytes Adam/ABlkDev/ChkDsk.HC | 444 +++ Adam/ABlkDev/PrtDsk.HC | 167 + Adam/ASnd.HC | 409 +++ Adam/Gr/GrMV.HC | 58 + Adam/Gr/ScrnCast.HC | 96 + Compiler/Compiler.BIN | Bin 192920 -> 192920 bytes Compiler/CompilerB.HH | 2 +- Demo/AcctExample/AlienProject/AlienMain.HC | 17 + .../AlienProject/AlienWorkingDir.HC | Bin 0 -> 309 bytes Demo/AcctExample/LightTable.HC | 90 + Demo/AcctExample/PersonalNotes.DD | 6 + Demo/AcctExample/Registry.HC | 2 +- Demo/AcctExample/TOS/TOSTheme.HC | Bin 0 -> 30675 bytes Demo/WebLogDemo/access_170605.log | 2029 +++++++++++ Demo/WebLogDemo/access_170606.log | 1649 +++++++++ Demo/WebLogDemo/access_170622.log | 3169 +++++++++++++++++ Doc/ChgLog.DD | 2 +- Doc/NewASCII.DD | 26 + Doc/Reliability.DD | 24 + Downloads/Linux/TOSZ | Bin 0 -> 29280 bytes Downloads/Linux/TOSZ.CPP | 1084 ++++++ Downloads/Linux/gw | 6 + Downloads/Linux/make_tosz | 7 + Downloads/ReadMe.TXT | 23 + Kernel/BlkDev/DskCluster.HC | 151 + Kernel/KMain.HC | 238 ++ Linux/TOSZ | Bin 0 -> 26912 bytes Linux/gw | 6 + Linux/make_tosz | 9 + 30 files changed, 9711 insertions(+), 3 deletions(-) create mode 100644 Adam/ABlkDev/ChkDsk.HC create mode 100644 Adam/ABlkDev/PrtDsk.HC create mode 100644 Adam/ASnd.HC create mode 100644 Adam/Gr/GrMV.HC create mode 100644 Adam/Gr/ScrnCast.HC create mode 100644 Demo/AcctExample/AlienProject/AlienMain.HC create mode 100644 Demo/AcctExample/AlienProject/AlienWorkingDir.HC create mode 100644 Demo/AcctExample/LightTable.HC create mode 100644 Demo/AcctExample/TOS/TOSTheme.HC create mode 100644 Demo/WebLogDemo/access_170605.log create mode 100644 Demo/WebLogDemo/access_170606.log create mode 100644 Demo/WebLogDemo/access_170622.log create mode 100644 Doc/NewASCII.DD create mode 100644 Doc/Reliability.DD create mode 100644 Downloads/Linux/TOSZ create mode 100644 Downloads/Linux/TOSZ.CPP create mode 100644 Downloads/Linux/gw create mode 100644 Downloads/Linux/make_tosz create mode 100644 Downloads/ReadMe.TXT create mode 100644 Kernel/BlkDev/DskCluster.HC create mode 100644 Kernel/KMain.HC create mode 100644 Linux/TOSZ create mode 100644 Linux/gw create mode 100644 Linux/make_tosz diff --git a/0000Boot/0000Kernel.BIN.C b/0000Boot/0000Kernel.BIN.C index 8a6ae786e6afd2f50668c9faf326072c589490c8..ce990f19aefec1fc9d57ff3c8e42afb478862e82 100644 GIT binary patch delta 324 zcmca`hx@`E?g=LBYgVn0|8L8^c_GV1=FL1Thawq+H=mDHV`btC+59~zSC;9&>gKeD zbPwN@|Co6uoXB66;_<6r9WAJuGLB?)FW~2YA+t)iW&gEy)@}2G%#8?Lw zIUmHxD-LGe&t!Ze%(TLE`_Wp)?IO&k5O;`gpEil{H9I52_NG~kokmQXWw!I4WvpXo zy5%`}<1gXu3$8G3Rb%wq9`>8@Iyu{#l!0p*lOj9hU2evUvZkL$Cl*!I? M(sXM9%VlISR+43$9N(!p`A54k(~`53bvyi6 zrba-NNK8K8Cb)S;M=~Q+hAAg>b8Od4ImXD%-&brfVpnext; + if (tmpde1->attr & RS_ATTR_DIR && tmpde1->sub) + errs+=RedSeaChkDskLst(dv,tmpde1->sub,bits,bits2,size,bpc); + j=(tmpde1->size+bpc-1)/bpc; + for (i=0;icluster-dv->data_area>size) { + PrintErr("Invalid Cluster:%s Cluster:%X\n",tmpde1->full_name, + i+tmpde1->cluster); + errs++; + break; + } + if (LBts(bits,i+tmpde1->cluster-dv->data_area)) { + PrintErr("Dbl Alloc:%s Cluster:%X\n",tmpde1->full_name, + i+tmpde1->cluster); + errs++; + } + if (!LBtr(bits2,i+tmpde1->cluster-dv->data_area)) { + PrintErr("UnAlloc:%s Cluster:%X\n",tmpde1->full_name, + i+tmpde1->cluster); + errs++; + } + } + DirEntryDel(tmpde1); + tmpde1=tmpde2; + } + return errs; +} + +I64 RedSeaChkDsk(U8 drv_let,Bool *_fix,Bool *_confirm) +{ + I64 i,j,bpc,size,errs=0; + CDrv *dv=Let2Drv(drv_let),*old_dv=Fs->cur_dv; + U8 *files_find_mask=MStrPrint("%c:/*",Drv2Let(dv)), + *old_dir=StrNew(Fs->cur_dir), + *bits,*bits2; + CDirEntry *ptr,*ptr2; + + Drv(drv_let); + "Scanning...\n"; + size=(dv->size-(dv->data_area-dv->drv_offset))/dv->spc; + bpc=dv->spc<>3); + bits2=CAlloc((size+7)>>3+BLK_SIZE); + RBlks(dv,bits2,dv->fat1,((size+7)>>3+BLK_SIZE-1)>>BLK_SIZE_BITS); + + //Get Root Dir size + ptr2=MAlloc(bpc); + RBlks(dv,ptr2,dv->root_cluster,1); + ptr=ptr2(U8 *)-offset(CDirEntry.start); + j=(ptr->size+bpc-1)/bpc; + Free(ptr2); + + for (i=0;iroot_cluster-dv->data_area>size) { + PrintErr("Invalid Cluster: RootDir Cluster:%X\n",i+dv->root_cluster); + errs++; + break; + } + if (LBts(bits,i+dv->root_cluster-dv->data_area)) { + PrintErr("Dbl Alloc: RootDir Cluster:%X\n",i+dv->root_cluster); + errs++; + } + if (!LBtr(bits2,i+dv->root_cluster-dv->data_area)) { + PrintErr("UnAlloc: RootDir Cluster:%X\n",i+dv->root_cluster); + errs++; + } + } + + errs+=RedSeaChkDskLst(dv,FilesFind(files_find_mask,FUF_RECURSE), + bits,bits2,size,bpc); + for (i=1;idata_area); + errs++; + if (ChkDskConfirm(_fix,_confirm)) + RedSeaFreeClusters(dv,i+dv->data_area,1); + } + + Free(files_find_mask); + Free(bits); + Free(bits2); + Drv(Drv2Let(old_dv)); + Cd(old_dir); + Free(old_dir); + return errs; +} + +I64 FAT32ChkDskLst(CDrv *dv,CDirEntry *tmpde1, + U8 *bits,U32 *bits2,I64 size,I64 bpc) +{ + CDirEntry *tmpde2; + I64 i,c,errs=0; + while (tmpde1) { + tmpde2=tmpde1->next; + if (tmpde1->attr & RS_ATTR_DIR && tmpde1->sub) + errs+=FAT32ChkDskLst(dv,tmpde1->sub,bits,bits2,size,bpc); + i=0; + c=tmpde1->cluster; + while (0size) { + PrintErr("Invalid Cluster:%s Cluster:%X\n",tmpde1->full_name,c); + errs++; + break; + } + if (LBts(bits,c)) { + PrintErr("Dbl Alloc:%s Cluster:%X\n",tmpde1->full_name,c); + errs++; + } + if (!bits2[c]) { + PrintErr("UnAlloc:%s Cluster:%X\n",tmpde1->full_name,c); + errs++; + } else + bits2[c]=0; + c=ClusterNumNext(dv,c); + i++; + } + if (!(tmpde1->attr & RS_ATTR_DIR)) { + i*=bpc; + if (tmpde1->size>i) { + PrintErr("Alloced File Too Short:%s\n",tmpde1->full_name); + errs++; + } + if (i>tmpde1->size+bpc-1) { + PrintWarn("Alloced File Too Long:%s\n",tmpde1->full_name); + errs++; + } + } + DirEntryDel(tmpde1); + tmpde1=tmpde2; + } + return errs; +} + +I64 FAT32ChkDsk(U8 drv_let,Bool *_fix,Bool *_confirm) +{ + I64 i,bpc,size,c,errs=0; + CDrv *dv=Let2Drv(drv_let),*old_dv=Fs->cur_dv; + U8 *files_find_mask=MStrPrint("%c:/*",Drv2Let(dv)), + *old_dir=StrNew(Fs->cur_dir), + *bits; + U32 *bits2; + Drv(drv_let); + "Scanning...\n"; + size=(dv->size-(dv->data_area-dv->drv_offset))/dv->spc; + bpc=dv->spc<>3); + bits2=CAlloc(size*4+BLK_SIZE); + RBlks(dv,bits2,dv->fat1,(size*4+BLK_SIZE-1)>>BLK_SIZE_BITS); + + c=dv->root_cluster; + while (0size) { + PrintErr("Invalid Cluster: RootDir Cluster:%X\n",c); + errs++; + break; + } + if (LBts(bits,c)) { + PrintErr("Dbl Alloc: RootDir Cluster:%X\n",c); + errs++; + } + if (!bits2[c]) { + PrintErr("UnAlloc: RootDir Cluster:%X\n",c); + errs++; + } else + bits2[c]=0; + c=ClusterNumNext(dv,c); + } + + errs+=FAT32ChkDskLst(dv,FilesFind(files_find_mask,FUF_RECURSE), + bits,bits2,size,bpc); + + bits2[1]=0; //See $LK,"FAT32Fmt",A="MN:FAT32Fmt"$() + for (i=1;ifs_type) { + case FSt_REDSEA: + errs=RedSeaChkDsk(drv_let,&fix,&confirm); + break; + case FSt_FAT32: + errs=FAT32ChkDsk(drv_let,&fix,&confirm); + break; + default: + PrintErr("File System Not Supported\n"); + } + if (errs) { + if (fix) + "It might be a little better. "; + "Copy files to another partition or CD/DVD, " + "reformat, and copy back. " + "Or, copy from a back-up.\n"; + } + return errs; +} + +U0 RedSeaDrvView(U8 drv_let=0) +{ + CDrv *dv=Let2Drv(drv_let); + I64 lohi,c1,i,x,y,l=(GR_HEIGHT-3*FONT_HEIGHT)*(GR_WIDTH-FONT_WIDTH<<1), + s=dv->size+dv->drv_offset-dv->data_area; + U8 *bitmap; + CDC *dc=DCAlias; + + SettingsPush; //See $LK,"SettingsPush",A="MN:SettingsPush"$ + WinMax; + WinBorder(ON); + DocCursor; + DocClear; + DCFill; + try { + i=((s+7)>>3+BLK_SIZE-1)>>BLK_SIZE_BITS; + bitmap=MAlloc(i<fat1,i); + i=0; + for (y=0;ycolor=ROP_XOR+BLUE^TRANSPARENT; + else + dc->color=ROP_XOR+WHITE^TRANSPARENT; + GrPlot(dc,x,y); + i++; + } + } + Free(bitmap); + } catch + DrvUnlock(dv); + GetChar; + + SettingsPop; + DCFill; + DCDel(dc); +} +U0 FAT32DrvView(U8 drv_let=0) +{ + CDrv *dv=Let2Drv(drv_let); + I64 lohi,c1,i,x,y,l=(GR_HEIGHT-3*FONT_HEIGHT)*(GR_WIDTH-FONT_WIDTH<<1), + s=(dv->size+dv->spc-1)/dv->spc-(2+dv->data_area-dv->drv_offset); + U32 *bitmap; + CDC *dc=DCAlias; + + SettingsPush; //See $LK,"SettingsPush",A="MN:SettingsPush"$ + WinMax; + WinBorder(ON); + DocCursor; + DocClear; + DCFill; + try { + i=(s*4+BLK_SIZE-1)>>BLK_SIZE_BITS; + bitmap=MAlloc(i<fat1,i); + i=0; + for (y=0;ycolor=ROP_XOR+BLUE^TRANSPARENT; + else + dc->color=ROP_XOR+WHITE^TRANSPARENT; + GrPlot(dc,x,y); + i++; + } + } + Free(bitmap); + } catch + DrvUnlock(dv); + GetChar; + + SettingsPop; + DCFill; + DCDel(dc); +} +public U0 DrvView(U8 drv_let=0) +{//Drive view. Graph the allocation map's fragmentation. + CDrv *dv=Let2Drv(drv_let),*old_dv=Fs->cur_dv; + Drv(drv_let); + switch (dv->fs_type) { + case FSt_REDSEA: + RedSeaDrvView(drv_let); + break; + case FSt_FAT32: + FAT32DrvView(drv_let); + break; + default: + PrintErr("File System Not Supported\n"); + } + Drv(Drv2Let(old_dv)); +} + +public U0 DskView(U8 drv_let=0) +{//Disk view. Pie chart of partition sizes. + I64 i,j,attr, + h=Fs->pix_width, + v=Fs->pix_height, + radius; + CDrv *dv; + CBlkDev *bd=Let2BlkDev(drv_let); + CDC *dc=DCAlias; + F64 sect_start,sect_end; + + SettingsPush; //See $LK,"SettingsPush",A="MN:SettingsPush"$ + DocCursor; + DocClear; + DCFill; + if (hcolor=BLACK; + GrCircle(dc,h>>1,v>>1,radius); + + j=1; + for (i=0;ibd && dv->fs_type) { + sect_start=-(dv->drv_offset*2*ã/(bd->max_blk+1)); + sect_end =-((dv->drv_offset+dv->size)*2*ã/(bd->max_blk+1)); + dc->color=BLACK; + GrLine(dc,h>>1,v>>1, + h>>1+radius*Cos(sect_start), + v>>1+radius*Sin(sect_start)); + GrLine(dc,h>>1,v>>1, + h>>1+radius*Cos(sect_end), + v>>1+radius*Sin(sect_end)); + + attr=DrvTextAttrGet(Drv2Let(dv)); + dc->color=attr&15; + GrPrint(dc,0,v-FONT_HEIGHT*j,"%C %-8Z",Drv2Let(dv), + dv->fs_type,"ST_DRV_TYPES"); + dc->color.c1=attr>>4; + dc->color|=ROPF_DITHER; + GrFloodFill(dc, + h>>1+(radius-4)*Cos((sect_start+sect_end)/2), + v>>1+(radius-4)*Sin((sect_start+sect_end)/2),FALSE); + j++; + } + } + + GetChar(,FALSE); + SettingsPop; + DCFill; + DCDel(dc); +} + +I64 RedSeaUnusedDrvSpace(U8 drv_let=0) +{ + CDrv *dv=Let2Drv(drv_let); + I64 res=0,i,l; + U8 *bitmap; + try { + l=dv->size+dv->drv_offset-dv->data_area; + i=((l+7)>>3+BLK_SIZE-1)>>BLK_SIZE_BITS; + bitmap=MAlloc(i<fat1,i); + for (i=0;ispc; +} +I64 FAT32UnusedDrvSpace(U8 drv_let=0) +{ + CDrv *dv=Let2Drv(drv_let); + I64 res=0,i,l; + U32 *bitmap; + try { + l=(dv->size+dv->spc-1)/dv->spc-(2+dv->data_area-dv->drv_offset); + i=(l*4+BLK_SIZE-1)>>BLK_SIZE_BITS; + bitmap=MAlloc(i<fat1,i); + for (i=0;ispc; +} +public I64 UnusedDrvSpace(U8 drv_let=0) +{//Returns unused size in bytes. + CDrv *dv=Let2Drv(drv_let),*old_dv=Fs->cur_dv; + U8 *old_dir=StrNew(Fs->cur_dir); + I64 res=0; + Drv(drv_let); + switch (dv->fs_type) { + case FSt_REDSEA: + res=RedSeaUnusedDrvSpace(drv_let); + break; + case FSt_FAT32: + res=FAT32UnusedDrvSpace(drv_let); + break; + default: + PrintErr("File System Not Supported\n"); + } + Drv(Drv2Let(old_dv)); + Cd(old_dir); + Free(old_dir); + return res; +} diff --git a/Adam/ABlkDev/PrtDsk.HC b/Adam/ABlkDev/PrtDsk.HC new file mode 100644 index 0000000..9313e45 --- /dev/null +++ b/Adam/ABlkDev/PrtDsk.HC @@ -0,0 +1,167 @@ +#help_index "Install;File/Cmd Line (Typically);Cmd Line (Typically)" + +#define ROUND_DRV_TO (63*255) +#define DRV_HEADER 63 + +class CPlannedDrv +{ + CPlannedDrv *next,*last; + I64 size; + Bool pri; +}; + +public I64 PrtDsk(U8 drv_let=0,...) +{/*Partition the disk containing partition drv_let. + +drv_let=0 means add new drive that is not already mounted. + +>PrtDsk('C',0.5,0.25,0.25); //Make three. 50% C, 25% D, 25% E, round-up to blk. + +*/ + CBlkDev *bd; + CPlannedDrv head,*tmppp; + CMasterBoot mbr; + Bool pri=TRUE; + I64 ext_base,drv_let2,pri_cnt=0,i,start_offset,offset, + total,remaining,cur_arg=0; + "This command does not play well\n" + "with other operating systems.\n" + "You really should use another\n" + "operating system's partitioner.\n" + "If you use this, it may, in fact,\n" + "make your hard drive impossible\n" + "to repartition with other operating\n" + "until you set block zero to zero\n" + "with $$LK,\"BootMHDZero\",\"MN:BootMHDZero\"$$()\n\n\n" + "Continue"; + if (argc<=cur_arg && !YorN) + return 0; + '\n'; + + if (drv_let && !Let2BlkDev(drv_let,FALSE)) + drv_let=0; + if (!drv_let && !(drv_let=Mount(TRUE)) || + !(bd=Let2BlkDev(drv_let,FALSE)) || bd->type!=BDT_ATA) + return 0; + + total=bd->max_blk+1; + QueInit(&head); + drv_let2=bd->first_drv_let; + remaining=FloorU64(bd->max_blk+1,ROUND_DRV_TO); + while (FloorU64(remaining,ROUND_DRV_TO)>=ROUND_DRV_TO) { + tmppp=MAlloc(sizeof(CPlannedDrv)); + do { + "$$RED$$Partition %C$$FG$$\n",drv_let2; + tmppp->pri=FALSE; + if (pri) { + "Primary Partition"; + if (argc>cur_arg || YorN) { + pri_cnt++; + tmppp->pri=TRUE; + if (pri_cnt==3) + pri=FALSE; + } else + pri=FALSE; + } + "\nBlocks Remaining:%d (0x%X)\n", + remaining-DRV_HEADER,remaining-DRV_HEADER; + if (argc>cur_arg) + tmppp->size=MinI64(CeilU64(MaxI64(remaining,DRV_HEADER),ROUND_DRV_TO), + CeilU64(argv[cur_arg++](F64)*total,ROUND_DRV_TO)); + else + tmppp->size=CeilU64(GetI64("Size in Blocks :", + remaining-DRV_HEADER)+DRV_HEADER,ROUND_DRV_TO); + } while (!(ROUND_DRV_TO<=tmppp->size<=FloorU64(remaining,ROUND_DRV_TO))); + QueIns(tmppp,head.last); + remaining-=tmppp->size; + drv_let2++; + } + + "\n\n!!! Repartition Drive !!!\n\n"; + tmppp=head.next; + drv_let2=bd->first_drv_let; + while (tmppp!=&head) { + "Drive %C:%08X ",drv_let2,tmppp->size; + if (tmppp->pri) + "Primary\n"; + else + "Logical\n"; + tmppp=tmppp->next; + drv_let2++; + } + if (!argc && !AreYouSure) + goto pd_done; + + remaining=FloorU64(bd->max_blk+1,ROUND_DRV_TO)-ROUND_DRV_TO; + tmppp=head.next; + MemSet(&mbr,0,BLK_SIZE); + mbr.signature=0xAA55; + offset=0; + for (i=0;isize-DRV_HEADER; + offset+=tmppp->size; + remaining-=tmppp->size; + tmppp=tmppp->next; + } + if (!i) i++; + if (tmppp!=&head) { + mbr.p[i].active=0x80; + mbr.p[i].start_head=0; + mbr.p[i].start_cyl=0x101; + mbr.p[i].type=0xF; + mbr.p[i].end_head=0xFE; + mbr.p[i].end_cyl=0xFFFF; + mbr.p[i].offset=offset; + mbr.p[i].size=remaining; + ext_base=offset; + } + ATAWriteBlks(bd,&mbr,0,1); + + while (tmppp!=&head) { + start_offset=offset; + MemSet(&mbr,0,BLK_SIZE); + mbr.signature=0xAA55; + + mbr.p[0].active=0x80; + mbr.p[0].start_head=1; + mbr.p[0].start_cyl=0x101; + mbr.p[0].type=1; //Will get set different. + mbr.p[0].end_head=0xFE; + mbr.p[0].end_cyl=0xFFFF; + mbr.p[0].offset=DRV_HEADER; + mbr.p[0].size=tmppp->size-DRV_HEADER; + offset+=tmppp->size; + tmppp=tmppp->next; + if (tmppp!=&head) { + mbr.p[1].active=0x80; + mbr.p[1].start_head=0; + mbr.p[1].start_cyl=0x101; + mbr.p[1].type=5; + mbr.p[1].end_head=0xFE; + mbr.p[1].end_cyl=0xFFFF; + mbr.p[1].offset=offset-ext_base; + mbr.p[1].size=tmppp->size; + } + ATAWriteBlks(bd,&mbr,start_offset,1); + } + + bd->flags&=~(BDF_INITIALIZED | BDF_INIT_IN_PROGRESS); + BlkDevAdd(bd,,FALSE,TRUE); + for (i=bd->first_drv_let;i=0.0) + return t%period/period; + else + return 1.0+t%period/period; + } else + return 0.0; +} + +public F64 FullSaw(F64 t,F64 period) +{//Plus&Minus Sawtooth. 1.0 - -1.0 think "Sin" + if (period) { + if (t>=0.0) + return 2.0*(t%period/period)-1.0; + else + return 2.0*(t%period/period)+1.0; + } else + return 0.0; +} + +public F64 Caw(F64 t,F64 period) +{//Cawtooth. 1.0 - 0.0 think "(Cos+1)/2" + if (period) { + if (t>=0.0) + return 1.0-t%period/period; + else + return -(t%period)/period; + } else + return 1.0; +} + +public F64 FullCaw(F64 t,F64 period) +{//Plus&Minus Cawtooth. 1.0 - -1.0 think "Cos" + if (period) { + if (t>=0.0) + return -2.0*(t%period/period)+1.0; + else + return -2.0*(t%period/period)-1.0; + } else + return 1.0; +} + +public F64 Tri(F64 t,F64 period) +{//Triangle waveform. 0.0 - 1.0 - 0.0 + if (period) { + t=2.0*(Abs(t)%period)/period; + if (t<=1.0) + return t; + else + return 2.0-t; + } else + return 0.0; +} + +public F64 FullTri(F64 t,F64 period) +{//Plus&Minus Triangle waveform. 0.0 - 1.0 - 0.0 - -1.0 -0.0 + if (period) { + t=4.0*(t%period)/period; + if (t<=-1.0) { + if (t<=-3.0) + return t+4.0; + else + return -2.0-t; + } else { + if (t<=1.0) + return t; + else if (t<=3.0) + return 2.0-t; + else + return t-4.0; + } + } else + return 0.0; +} + +#help_index "Snd/Music" + +public class CMusicGlbls +{ + U8 *cur_song; + CTask *cur_song_task; + I64 octave; + F64 note_len; + U8 note_map[7]; + Bool mute; + I64 meter_top,meter_bottom; + F64 tempo,stacatto_factor; + + //If you wish to sync with a + //note in a Play() string. 0 is the start + I64 play_note_num; + + F64 tM_correction,last_Beat,last_tM; +} music={NULL,NULL,4,1.0,{0,2,3,5,7,8,10},FALSE,4,4,2.5,0.9,0,0,0,0}; + +#help_index "Snd/Music;Time/Seconds" +public F64 tM() +{//Time in seconds synced to music subsystem. + return (cnts.jiffies+music.tM_correction)/JIFFY_FREQ; +} + +public F64 Beat() +{//Time in music beats. + F64 res,cur_tM; + PUSHFD + CLI + if (mp_cnt>1) + while (LBts(&sys_semas[SEMA_TMBEAT],0)) + PAUSE + cur_tM=tM; + res=music.last_Beat; + if (music.tempo) + res+=(cur_tM-music.last_tM)*music.tempo; + music.last_tM=cur_tM; + music.last_Beat=res; + LBtr(&sys_semas[SEMA_TMBEAT],0); + POPFD + return res; +} + +#help_index "Snd/Music" +U8 *MusicSetOctave(U8 *st) +{ + I64 ch; + ch=*st++; + while ('0'<=ch<='9') { + music.octave=ch-'0'; + ch=*st++; + } + return --st; +} + +U8 *MusicSetMeter(U8 *st) +{ + I64 ch; + ch=*st++; + while (ch=='M') { + ch=*st++; + if ('0'<=ch<='9') { + music.meter_top=ch-'0'; + ch=*st++; + } + if (ch=='/') + ch=*st++; + if ('0'<=ch<='9') { + music.meter_bottom=ch-'0'; + ch=*st++; + } + } + return --st; +} + +U8 *MusicSetNoteLen(U8 *st) +{ + Bool cont=TRUE; + do { + switch (*st++) { + case 'w': music.note_len=4.0; break; + case 'h': music.note_len=2.0; break; + case 'q': music.note_len=1.0; break; + case 'e': music.note_len=0.5; break; + case 's': music.note_len=0.25; break; + case 't': music.note_len=2.0*music.note_len/3.0; break; + case '.': music.note_len=1.5*music.note_len; break; + default: + st--; + cont=FALSE; + } + } while (cont); + return st; +} + +public I8 Note2Ona(I64 note,I64 octave=4) +{//Note to ona. Mid C is ona=51, note=3 and octave=4. + if (note<3) + return (octave+1)*12+note; + else + return octave*12+note; +} + +public I8 Ona2Note(I8 ona) +{//Ona to note in octave. Mid C is ona=51, note=3 and octave=4. + return ona%12; +} + +public I8 Ona2Octave(I8 ona) +{//Ona to octave. Mid C is ona=51, note=3 and octave=4. + I64 note=ona%12,octave=ona/12; + if (note<3) + return octave-1; + else + return octave; +} + +public U0 Play(U8 *st,U8 *words=NULL) +{/* Notes are entered with a capital letter. + +Octaves are entered with a digit and +stay set until changed. Mid C is octave 4. + +Durations are entered with +'w' whole note +'h' half note +'q' quarter note +'e' eighth note +'t' sets to 2/3rds the current duration +'.' sets to 1.5 times the current duration +durations stay set until changed. + +'(' tie, placed before the note to be extended + +$LK,"music.meter_top",A="MN:CMusicGlbls"$,$LK,"music.meter_bottom",A="MN:CMusicGlbls"$ is set with +"M3/4" +"M4/4" +etc. + +Sharp and flat are done with '#' or 'b'. + +The var music.stacatto_factor can +be set to a range from 0.0 to 1.0. + +The var music.tempo is quarter-notes +per second. It defaults to +2.5 and gets faster when bigger. +*/ + U8 *word,*last_st; + I64 note,octave,i=0,ona,timeout_val,timeout_val2; + Bool tie; + F64 d,on_jiffies,off_jiffies; + music.play_note_num=0; + while (*st) { + timeout_val=cnts.jiffies; + tie=FALSE; + + do { + last_st=st; + if (*st=='(') { + tie=TRUE; + st++; + } else { + st=MusicSetMeter(st); + st=MusicSetOctave(st); + st=MusicSetNoteLen(st); + } + } while (st!=last_st); + + if (!*st) break; + note=*st++-'A'; + if (note<7) { + note=music.note_map[note]; + octave=music.octave; + if (*st=='b') { + note--; + if (note==2) + octave--; + st++; + } else if (*st=='#') { + note++; + if (note==3) + octave++; + st++; + } + ona=Note2Ona(note,octave); + } else + ona=0; + if (words && (word=LstSub(i++,words)) && StrCmp(word," ")) + "%s",word; + + d=JIFFY_FREQ*music.note_len/music.tempo; + on_jiffies =d*music.stacatto_factor; + off_jiffies =d*(1.0-music.stacatto_factor); + + timeout_val+=on_jiffies; + timeout_val2=timeout_val+off_jiffies; + + if (!music.mute) + Snd(ona); + SleepUntil(timeout_val); + music.tM_correction+=on_jiffies-ToI64(on_jiffies); + + if (!music.mute && !tie) + Snd; + SleepUntil(timeout_val2); + music.tM_correction+=off_jiffies-ToI64(off_jiffies); + + music.play_note_num++; + } +} + +U0 MusicSettingsRst() +{ + music.play_note_num=0; + music.stacatto_factor=0.9; + music.tempo=2.5; + music.octave=4; + music.note_len=1.0; + music.meter_top=4; + music.meter_bottom=4; + SndRst; + PUSHFD + CLI + if (mp_cnt>1) + while (LBts(&sys_semas[SEMA_TMBEAT],0)) + PAUSE + music.last_tM=tM; + music.last_Beat=0.0; + LBtr(&sys_semas[SEMA_TMBEAT],0); + POPFD +} + +MusicSettingsRst; + +U0 CurSongTask() +{ + Fs->task_end_cb=&SndTaskEndCB; + while (TRUE) + Play(music.cur_song); +} + +#help_index "Snd" + +#define SE_NOISE 0 +#define SE_SWEEP 1 + +class CSoundEffectFrame +{ + I32 type; + I8 ona1,ona2; + F64 duration; +}; + +U0 SoundEffectEndTaskCB() +{ + Free(FramePtr("CSoundEffectFrame")); + music.mute--; + SndTaskEndCB; +} + +U0 SoundEffectTask(CSoundEffectFrame *ns) +{ + I64 i,ona; + F64 t0=tS,t,timeout=t0+ns->duration; + FramePtrAdd("CSoundEffectFrame",ns); + Fs->task_end_cb=&SoundEffectEndTaskCB; + switch (ns->type) { + case SE_NOISE: + i=MaxI64(ns->ona2-ns->ona1,1); + while (tSona1; + Snd(ona); + t=Clamp(3000.0/Ona2Freq(ona),1.0,50.0); + if (t+tS>timeout) + t=timeout-tS; + Sleep(t); + } + break; + case SE_SWEEP: + while (tSduration; + ona=(1.0-t)*ns->ona1+t*ns->ona2; + Snd(ona); + t=Clamp(3000.0/Ona2Freq(ona),1.0,50.0); + if (t+tS>timeout) + t=timeout-tS; + Sleep(t); + } + break; + } +} + +public CTask *Noise(I64 mS,F64 min_ona,F64 max_ona) +{//Make white noise for given number of mS. + CSoundEffectFrame *ns; + if (mS>0) { + ns=MAlloc(sizeof(CSoundEffectFrame)); + ns->type=SE_NOISE; + ns->duration=mS/1000.0; + ns->ona1=min_ona; + ns->ona2=max_ona; + music.mute++; + return Spawn(&SoundEffectTask,ns,"Noise",,Fs); + } else + return NULL; +} + +public CTask *Sweep(I64 mS,F64 ona1,F64 ona2) +{//Sweep through freq range in given number of mS. + CSoundEffectFrame *ns; + if (mS>0) { + ns=MAlloc(sizeof(CSoundEffectFrame)); + ns->type=SE_SWEEP; + ns->duration=mS/1000.0; + ns->ona1=ona1; + ns->ona2=ona2; + music.mute++; + return Spawn(&SoundEffectTask,ns,"Noise",,Fs); + } else + return NULL; +} diff --git a/Adam/Gr/GrMV.HC b/Adam/Gr/GrMV.HC new file mode 100644 index 0000000..5ef3639 --- /dev/null +++ b/Adam/Gr/GrMV.HC @@ -0,0 +1,58 @@ +#help_index "Graphics/Device Contexts;Graphics/GR Files" + +#define MV_FILE_MAX 0x007FF000 + +public I64 GR2MV(U8 *print_fmt="VID%03d.MV", + U8 *files_find_mask,U8 *fu_flags=NULL) +{/*Merge GR lst to MV file. +"+d" will delete GR list files. +*/ + I64 fuf_flags=0,file_num=0,size; + CDirEntry *tmpde,*tmpde1; + U8 *base,*dst,*src,*st; + CDC *dc,*dc_base=DCNew(GR_WIDTH,GR_HEIGHT); + CDate cdt; + Bool old_silent; + ScanFlags(&fuf_flags,Define("ST_FILE_UTIL_FLAGS"),"+f+F"); + ScanFlags(&fuf_flags,Define("ST_FILE_UTIL_FLAGS"),fu_flags); + tmpde=tmpde1=FilesFind(files_find_mask,fuf_flags&FUG_FILES_FIND); + if (progress1_max=LinkedLstCnt(tmpde1)) { + dst=base=MAlloc(MV_FILE_MAX); + while (tmpde) { + dc=GRRead(tmpde->full_name); + GrBlot(dc_base,dc->x0,dc->y0,dc); + if (dst+GR_FILE_MAX>base+MV_FILE_MAX) { + st=MStrPrint(print_fmt,file_num++); + FileWrite(st,base,dst-base); + Free(st); + dst=base; + + cdt=dc->cdt; + dc=DCCopy(dc_base); + dc->cdt=cdt; + } + src=DCSave(dc,&size); + DCDel(dc); + MemCpy(dst,src,size); + dst+=size; + Free(src); + if (fuf_flags&FUF_DEL) { + old_silent=Silent; + Del(tmpde->full_name); + Silent(old_silent); + } + progress1++; + tmpde=tmpde->next; + } + if (dst>base) { + st=MStrPrint(print_fmt,file_num++); + FileWrite(st,base,dst-base); + Free(st); + } + Free(base); + } + progress1=progress1_max=0; + DirTreeDel(tmpde1); + DCDel(dc_base); + return file_num; +} diff --git a/Adam/Gr/ScrnCast.HC b/Adam/Gr/ScrnCast.HC new file mode 100644 index 0000000..57bf57c --- /dev/null +++ b/Adam/Gr/ScrnCast.HC @@ -0,0 +1,96 @@ +#help_index "ScrnCast;Graphics/Device Contexts;Graphics/GR Files" + +#define MV_FILE_MAX 0x007FF000 + +public I64 GR2MV(U8 *print_fmt="VID%03d.MV", + U8 *files_find_mask,U8 *fu_flags=NULL) +{/*Merge GR lst to MV file. +"+d" will delete GR list files. +*/ + I64 fuf_flags=0,file_num=0,size; + CDirEntry *tmpde,*tmpde1; + U8 *base,*dst,*src,*st; + CDC *dc,*dc_base=DCNew(GR_WIDTH,GR_HEIGHT); + CDate cdt; + Bool old_silent; + ScanFlags(&fuf_flags,Define("ST_FILE_UTIL_FLAGS"),"+f+F"); + ScanFlags(&fuf_flags,Define("ST_FILE_UTIL_FLAGS"),fu_flags); + tmpde=tmpde1=FilesFind(files_find_mask,fuf_flags&FUG_FILES_FIND); + if (progress1_max=LinkedLstCnt(tmpde1)) { + dst=base=MAlloc(MV_FILE_MAX); + while (tmpde) { + dc=GRRead(tmpde->full_name); + GrBlot(dc_base,dc->x0,dc->y0,dc); + if (dst+GR_FILE_MAX>base+MV_FILE_MAX) { + st=MStrPrint(print_fmt,file_num++); + FileWrite(st,base,dst-base); + Free(st); + dst=base; + + cdt=dc->cdt; + dc=DCCopy(dc_base); + dc->cdt=cdt; + } + src=DCSave(dc,&size); + DCDel(dc); + MemCpy(dst,src,size); + dst+=size; + Free(src); + if (fuf_flags&FUF_DEL) { + old_silent=Silent; + Del(tmpde->full_name); + Silent(old_silent); + } + progress1++; + tmpde=tmpde->next; + } + if (dst>base) { + st=MStrPrint(print_fmt,file_num++); + FileWrite(st,base,dst-base); + Free(st); + } + Free(base); + } + progress1=progress1_max=0; + DirTreeDel(tmpde1); + DCDel(dc_base); + return file_num; +} + +#help_index "ScrnCast;Snd/AU Files" +public U0 SndShift(CSndData *head,F64 dt=0) +{//Shift CSndData in time. + CSndData *tmpsd,*tmpsd1; + if (dt) { + tmpsd=head->next; + while (tmpsd!=head) { + tmpsd1=tmpsd->next; + tmpsd->tS-=dt; + if (tmpsd->tSlast->tS) { + QueRem(tmpsd); + Free(tmpsd); + } + tmpsd=tmpsd1; + } + } +} + +public I64 AUWrite(U8 *filename,CSndData *head,CDate *t0_now,F64 t0_tS) +{//Write AU file. + CSndData *tmpsd; + CAUData *base,*dst; + I64 size=(1+QueCnt(head))*sizeof(CAUData); + U8 *st=ExtDft(filename,"AU"); + base=dst=MAlloc(size); + tmpsd=head; + do { + dst->cdt=t0_now(I64)+ToI64(CDATE_FREQ*(tmpsd->tS-t0_tS)); + dst->ona=tmpsd->ona; + dst++; + tmpsd=tmpsd->next; + } while (tmpsd!=head); + FileWrite(st,base,dst(U8 *)-base(U8 *)); + Free(base); + Free(st); + return size; +} diff --git a/Compiler/Compiler.BIN b/Compiler/Compiler.BIN index d1cdab1f1e3d03049d033c0600956c76f8b13191..c78a7dea776d485e4bf643f62407a6018eeb3c17 100644 GIT binary patch delta 154 zcmbR7n0v-!?hOTsj0~F#6%VB`25mO!xXr}KuvwtnBa(^1Vsq4!#f;OL8kmGP3p|rI zV`SKFAj4Q7H^*)#3&@nD7Af4I^+FV z7SHYj9@7J4n8dcPKFYXFfzfw+(lf?-KSqYh4ZR|h1-5W(|7XIqTAa~*`zjx%&-{!G L+vmkF{h9&*$XPWa delta 150 zcmbR7n0v-!?hOTsjK!M^6%VB`hHp0MxXr})f3rZhM(rgX;pu`I3) zj11EQWSGRZuRhASO@T3Jd(tz;dOuc127Y$NNn0eg|1)7)EzW4WeU%T>XMRTa?ek)o HeoX-Y1iUn# diff --git a/Compiler/CompilerB.HH b/Compiler/CompilerB.HH index 67409e3..166cd12 100644 --- a/Compiler/CompilerB.HH +++ b/Compiler/CompilerB.HH @@ -21,6 +21,7 @@ extern U0 StreamDir(); public extern I64 StreamExePrint(U8 *fmt,...); public extern U0 StreamPrint(U8 *fmt,...); public extern Bool Trace(Bool val=ON); + #help_index "Compiler/Lex" #help_file "::/Doc/Lex" extern U0 ClassMemberLstDel(CHashClass *c); @@ -71,7 +72,6 @@ public extern U0 Ui(U8 *buf,U8 **_rip,I64 seg_size=64, I64 *_jmp_dst=NULL,Bool just_ins=FALSE); public extern I64 Un(U8 *rip,I64 cnt=0x80,I64 seg_size=64); extern CUAsmGlbls uasm; - #help_index "Hash/System" public extern I64 HashEntrySize(CHashSrcSym *tmph); public extern I64 HashEntrySize2(CHashSrcSym *tmph); diff --git a/Demo/AcctExample/AlienProject/AlienMain.HC b/Demo/AcctExample/AlienProject/AlienMain.HC new file mode 100644 index 0000000..2b29070 --- /dev/null +++ b/Demo/AcctExample/AlienProject/AlienMain.HC @@ -0,0 +1,17 @@ + +Cd(__DIR__);; + +#include "AlienWorkingDir" + + + +U0 AlienGame() +{ + "This is our alien game.\n"; + PressAKey; + ShowWorkingDir; +} + + +AlienGame; + diff --git a/Demo/AcctExample/AlienProject/AlienWorkingDir.HC b/Demo/AcctExample/AlienProject/AlienWorkingDir.HC new file mode 100644 index 0000000000000000000000000000000000000000..0236f242f7f90acc411d80c2dcf5a59ee9220800 GIT binary patch literal 309 zcmd;52@cRvvN5z%(sA;%HB{k32cZTE!5R7G;rT_`nR)3hnME3!T-96(3c&?MnI)+j zDxOZr+BL1YxVRJ)lw$G-!SGat#G+J%%shpXjLc$%l+2>kvNw_;tp zw$4DJjJ417Ke3=E+R3=Bdb^8hPPM124N literal 0 HcmV?d00001 diff --git a/Demo/AcctExample/LightTable.HC b/Demo/AcctExample/LightTable.HC new file mode 100644 index 0000000..9a4a08f --- /dev/null +++ b/Demo/AcctExample/LightTable.HC @@ -0,0 +1,90 @@ +#define PTS_NUM 1024 + +U0 LightTable() +{ + I64 msg_code,i,x1,y1,x2,y2,arg1,arg2; + CDC *dc=DCAlias; + CD3I32 *c=MAlloc(PTS_NUM*sizeof(CD3I32)); + + MenuPush( + "File {" + " Restart(,'\n');" + " Abort(,CH_SHIFT_ESC);" + " Exit(,CH_ESC);" + "}" + "Edit {" + " Fill(,CH_SPACE);" + "}" + ); + SettingsPush; //See $LK,"SettingsPush",A="MN:SettingsPush"$ + Fs->win_inhibit=WIG_TASK_DFT-WIF_SELF_FOCUS- + WIF_SELF_BORDER-WIF_FOCUS_TASK_MENU; + Fs->text_attr=BLACK<<4+WHITE; //Current $LK,"CTask",A="MN:CTask"$ is Fs segment register. + AutoComplete; + WinBorder; + WinMax; + DocCursor; + DocClear; + try { + while (TRUE) { + msg_code=GetMsg(&arg1,&arg2, + 1<color=ROP_XOR+LTRED^TRANSPARENT; + do { + GrLine3(dc,x1,y1,0,x2,y2,0); + msg_code=GetMsg(&arg1,&arg2,1<color=ROP_XOR+WHITE^TRANSPARENT; + do { + c[i].x=arg1; c[i].y=arg2; c[i].z=0; + Gr2BSpline(dc,c,i+1); + msg_code=GetMsg(&arg1,&arg2, + 1<pix_left,ms.pos.y-Fs->pix_top); + break; + case '\n': + DCFill; + break; + case CH_ESC: + case CH_SHIFT_ESC: + goto lt_done; + } + break; + } + } +lt_done: + GetMsg(,,1<\"\""$ 170310 Terry $HC,"
\"\"
"$ +$TX,"Linus Torvalds (Dec 28, 1969)",HTML="https://en.wikipedia.org/wiki/Linus_Torvalds"$ +$TX,"John Carmack (Aug 20, 1970)",HTML="https://en.wikipedia.org/wiki/John_Carmack"$ +$TX,"Terry A. Davis (Dec 15, 1969)",HTML="https://motherboard.vice.com/en_us/article/gods-lonely-programmer"$ + $TX,"SimStructure",HTML="http://www.templeos.org/files/SimStrSetUp.zip"$ $TX,"ASU_Transcripts",HTML="http://www.templeos.org/files/ASU_Transcripts.pdf"$ $TX,"ASU Course Catalog (See page 261)",HTML="https://catalog.asu.edu/files/shared/archives/1994-1996/general/UG1994-1996.pdf/1994-1996-UG-241-267.pdf"$ $TX,"Dr. David Pheanis",HTML="https://webapp4.asu.edu/directory/person/77201"$ $TX,"Dr. Konstantinos S. Tsakalis",HTML="http://ecee.engineering.asu.edu/directory/tenured-and-tenure-track-faculty/kostantinos-s-tsakalis"$ $TX,"Dr. Walter Higgins",HTML="https://webapp4.asu.edu/directory/directorysearch?cn=Walter+Higgins"$ @@ -473,6 +477,8 @@ $TX,"Peter Gadwa",HTML="http://www.wired.com/magazine/2010/11/mf_ticketmaster/al $TX,"Tom Foley",HTML="http://web.gccaz.edu/~tfoley/perspage.html"$ $TX,"Graphic Technologies",HTML="https://web.archive.org/web/20020811060541/http://www.graphic-technologies.com/"$ $TX,"Lexmark vs Static Control",HTML="https://en.wikipedia.org/wiki/Lexmark_International,_Inc._v._Static_Control_Components,_Inc."$ + + $TX,"Stephen Davis",HTML="https://photos.google.com/share/AF1QipM4HI3mb_9qe8wDQ--nRfjIzOKyGG8heqWH-tbGBIIoxChWe4GeBegNzgHRy4Z1Qw?key=eGR0R0tyZG5tenRWd0tDN2RHRFRNTmI4NXdhc25B"$ 3qEeEGCAsBABAqFDBeE2G33qEeEGCAsBABAqFDBeE2G33qCsBDBDq2G3s2G3F2G3FqAet2G32G3AEDAqF3qCsBDBDq2G3s2G3F2G3FqAet2G32G3AEDAqF diff --git a/Demo/AcctExample/Registry.HC b/Demo/AcctExample/Registry.HC index 9981ab3..e13bc36 100644 --- a/Demo/AcctExample/Registry.HC +++ b/Demo/AcctExample/Registry.HC @@ -62,7 +62,7 @@ $ID,-2$$TR,"Titanium"$ $ID,2$I64 best_score=16469; $ID,-2$$TR,"TOSRegen"$ $ID,2$progress1_tf=0.000;progress2_tf=0.000; -progress3_tf=0.000;progress4_tf=196.886; +progress3_tf=0.000;progress4_tf=196.786; $ID,-2$$TR,"TempleTetris"$ $ID,2$I64 hiscore=1000; $ID,-2$$ID,-2$$TR,"Once"$ diff --git a/Demo/AcctExample/TOS/TOSTheme.HC b/Demo/AcctExample/TOS/TOSTheme.HC new file mode 100644 index 0000000000000000000000000000000000000000..3e548f47a670200cbd178bbeb4e55071159d6216 GIT binary patch literal 30675 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 pGBEJK3Kj?#d literal 0 HcmV?d00001 diff --git a/Downloads/Linux/TOSZ.CPP b/Downloads/Linux/TOSZ.CPP new file mode 100644 index 0000000..a442cf5 --- /dev/null +++ b/Downloads/Linux/TOSZ.CPP @@ -0,0 +1,1084 @@ +#include +#include +#include +#include + +#pragma pack(1) + +#define TRUE 1 +#define FALSE 0 +#define BYTE_MAX 0xFF +#define CHAR_MIN (-0x80) +#define CHAR_MAX 0x7F +#define SHORT_MIN (-0x8000) +#define SHORT_MAX 0x7FFF +#define INT_MIN (-0x80000000) +#define INT_MAX 0x7FFFFFFF +#define LONG_LONG_MIN (-0x8000000000000000l) +#define LONG_LONG_MAX 0x7FFFFFFFFFFFFFFFl +#define DWORD_MIN 0 +#define DWORD_MAX 0xFFFFFFFF +#define CDATE_FREQ 49710 // Hz + +typedef unsigned char BYTE; +typedef unsigned short WORD; +typedef unsigned int DWORD; +typedef unsigned char BOOL; + +class CDate +{public: + DWORD time; + int date; +}; + +WORD EndianWORD(WORD d) +{ + return ((d&255)<<8)|((d>>8)&255); +} + +DWORD EndianDWORD(DWORD d) +{ + return ((d&255)<<24)|(((d>>8)&255)<<16)| + (((d>>16)&255)<<8)|((d>>24)&255); +} + +DWORD StrOcc(char *src, char ch) +{//Count occurrences of a char. + DWORD i=0; + if (!src) return 0; + while (*src) + if (*src++==ch) + i++; + return i; +} + +void *CAlloc(DWORD size) +{ + BYTE *res=(BYTE *)malloc(size); + memset(res,0,size); + return res; +} + +void Free(void *ptr) +{ + if (ptr) free(ptr); +} + +int FSize(FILE *f) +{ + int res,original=ftell(f); + fseek(f,0,SEEK_END); + res=ftell(f); + fseek(f,original,SEEK_SET); + return res; +} + +class CQue +{public: + CQue *next,*last; +}; + +void QueIns(void *entry,void *pred) +{ + CQue * succ; + succ=((CQue *)pred)->next; + ((CQue *)entry)->last=(CQue *)pred; + ((CQue *)entry)->next=succ; + succ ->last=(CQue *)entry; + ((CQue *)pred)->next=(CQue *)entry; +} + +void QueRem(void *entry) +{ + ((CQue *)entry)->last->next=((CQue *)entry)->next; + ((CQue *)entry)->next->last=((CQue *)entry)->last; +} + +void QueDel(void *head,BOOL querem=FALSE) +{//Free entries in queue, not head. + CQue *tmpq=((CQue *)head)->next,*tmpq1; + while (tmpq!=head) { + tmpq1=((CQue *)tmpq)->next; + if (querem) + QueRem(tmpq); + Free(tmpq); + tmpq=tmpq1; + } +} + +void QueInit(void *head) +{//Free entries in queue, not head. + ((CQue *)head)->next=(CQue *)head; + ((CQue *)head)->last=(CQue *)head; +} + +int QueCnt(CQue *head) +{//Count of nodes in queue, not head. + CQue *tmpq=((CQue *)head)->next; + int res=0; + while (tmpq!=head) { + res++; + tmpq=((CQue *)tmpq)->next; + } + return res; +} + +#define ARC_MAX_BITS 12 + +#define CT_NONE 1 +#define CT_7_BIT 2 +#define CT_8_BIT 3 + +class CArcEntry +{ public: + CArcEntry *next; + WORD basecode; + BYTE ch,pad; +}; + +class CArcCtrl //control structure +{ public: + DWORD src_pos,src_size, + dst_pos,dst_size; + BYTE *src_buf,*dst_buf; + DWORD min_bits,min_table_entry; + CArcEntry *cur_entry,*next_entry; + DWORD cur_bits_in_use,next_bits_in_use; + BYTE *stk_ptr,*stk_base; + DWORD free_idx,free_limit, + saved_basecode, + entry_used, + last_ch; + CArcEntry compress[1<>3; + bit_num&=7; + return (*bit_field & (1<>3; + bit_num&=7; + res=*bit_field & (1<entry_used) { + i=c->free_idx; + + c->entry_used=FALSE; + c->cur_entry=c->next_entry; + c->cur_bits_in_use=c->next_bits_in_use; + if (c->next_bits_in_usenext_entry = &c->compress[i++]; + if (i==c->free_limit) { + c->next_bits_in_use++; + c->free_limit=1<next_bits_in_use; + } + } else { + do if (++i==c->free_limit) i=c->min_table_entry; + while (c->hash[i]); + tmp=&c->compress[i]; + c->next_entry=tmp; + tmp1=(CArcEntry *)&c->hash[tmp->basecode]; + while (tmp1 && tmp1->next!=tmp) + tmp1=tmp1->next; + if (tmp1) + tmp1->next=tmp->next; + } + c->free_idx=i; + } +} + +void ArcExpandBuf(CArcCtrl *c) +{ + BYTE *dst_ptr,*dst_limit; + DWORD basecode,lastcode,code; + CArcEntry *tmp,*tmp1; + + dst_ptr=c->dst_buf+c->dst_pos; + dst_limit=c->dst_buf+c->dst_size; + + while (dst_ptrstk_ptr!=c->stk_base) + *dst_ptr++ = * -- c->stk_ptr; + + if (c->stk_ptr==c->stk_base && dst_ptrsaved_basecode==0xFFFFFFFFl) { + lastcode=BFieldExtDWORD(c->src_buf,c->src_pos, + c->next_bits_in_use); + c->src_pos=c->src_pos+c->next_bits_in_use; + *dst_ptr++=lastcode; + ArcEntryGet(c); + c->last_ch=lastcode; + } else + lastcode=c->saved_basecode; + while (dst_ptrsrc_pos+c->next_bits_in_use<=c->src_size) { + basecode=BFieldExtDWORD(c->src_buf,c->src_pos, + c->next_bits_in_use); + c->src_pos=c->src_pos+c->next_bits_in_use; + if (c->cur_entry==&c->compress[basecode]) { + *c->stk_ptr++=c->last_ch; + code=lastcode; + } else + code=basecode; + while (code>=c->min_table_entry) { + *c->stk_ptr++=c->compress[code].ch; + code=c->compress[code].basecode; + } + *c->stk_ptr++=code; + c->last_ch=code; + + c->entry_used=TRUE; + tmp=c->cur_entry; + tmp->basecode=lastcode; + tmp->ch=c->last_ch; + tmp1=(CArcEntry *)&c->hash[lastcode]; + tmp->next=tmp1->next; + tmp1->next=tmp; + + ArcEntryGet(c); + while (dst_ptrstk_ptr!=c->stk_base) + *dst_ptr++ = * -- c->stk_ptr; + lastcode=basecode; + } + c->saved_basecode=lastcode; + } + c->dst_pos=dst_ptr-c->dst_buf; +} + +CArcCtrl *ArcCtrlNew(DWORD expand,DWORD compression_type) +{ + CArcCtrl *c; + c=(CArcCtrl *)CAlloc(sizeof(CArcCtrl)); + if (expand) { + c->stk_base=(BYTE *)malloc(1<stk_ptr=c->stk_base; + } + if (compression_type==CT_7_BIT) + c->min_bits=7; + else + c->min_bits=8; + c->min_table_entry=1<min_bits; + c->free_idx=c->min_table_entry; + c->next_bits_in_use=c->min_bits+1; + c->free_limit=1<next_bits_in_use; + c->saved_basecode=0xFFFFFFFFl; + c->entry_used=TRUE; + ArcEntryGet(c); + c->entry_used=TRUE; + return c; +} + +void ArcCtrlDel(CArcCtrl *c) +{ + Free(c->stk_base); + Free(c); +} + +BYTE *ExpandBuf(CArcCompress *arc) +{ + CArcCtrl *c; + BYTE *res; + + if (!(CT_NONE<=arc->compression_type && arc->compression_type<=CT_8_BIT) || + arc->expanded_size>=0x20000000l) + return NULL; + + res=(BYTE *)malloc(arc->expanded_size+1); + res[arc->expanded_size]=0; //terminate + switch (arc->compression_type) { + case CT_NONE: + memcpy(res,arc->body,arc->expanded_size); + break; + case CT_7_BIT: + case CT_8_BIT: + c=ArcCtrlNew(TRUE,arc->compression_type); + c->src_size=arc->compressed_size*8; + c->src_pos=(sizeof(CArcCompress)-1)*8; + c->src_buf=(BYTE *)arc; + c->dst_size=arc->expanded_size; + c->dst_buf=res; + c->dst_pos=0; + ArcExpandBuf(c); + ArcCtrlDel(c); + break; + } + return res; +} + +BOOL Cvt(char *in_name,char *out_name,BOOL cvt_ascii) +{ + DWORD out_size,i,j,in_size; + CArcCompress *arc; + BYTE *out_buf; + FILE *io_file; + BOOL okay=FALSE; + if (io_file=fopen(in_name,"rb")) { + in_size=FSize(io_file); + arc=(CArcCompress *)malloc(in_size); + fread(arc,1,in_size,io_file); + out_size=arc->expanded_size; + printf("%-45s %d-->%d\r\n",in_name,(DWORD) in_size,out_size); + fclose(io_file); + if (arc->compressed_size==in_size && + arc->compression_type && arc->compression_type<=3) { + if (out_buf=ExpandBuf(arc)) { + if (cvt_ascii) { + j=0; + for (i=0;isample_rate=sample_rate; + return swc; +} + +void SndWaveAddBuf(CSndWaveCtrl *swc,BYTE *buf,int num_samples, + double _freq,double _amp=1.0) +{ + int i,j,k; + double a,f,amp,phase; + if (!swc) return; + if (!_freq||!_amp) + swc->last_y=swc->phase=0; + else { + phase=swc->phase; + i=0; + if (INT_MAXsample_rate*_freq; + while (phase<0) + phase+=2; + while (phase>=2) + phase-=2; + while (i=1.0) + j=-amp; + else + j=amp; + k=j>>16; + *((short *)buf+i++)+=k; + phase+=f; + while (phase>=2) + phase-=2; + } + swc->phase=phase; + } +} + +#define SNDFILE_SAMPLE_RATE 8000 +//Header for a ".SND" file +class CFileSND +{public: + DWORD signature; //0x646e732e + DWORD offset; //24 + DWORD data_size; + DWORD coding; //3=16bit uncompressed + DWORD sample_rate; //Hz + DWORD channels; //1=mono + short body[1]; +}; + +#define SND_FILE_MAX 0x007FF000 + +int SndFileCreate(CSndData *head,char *print_fmt,double vol=1.0) +{ + int i,i1,k,cnt,cnt2,file_num; + double dt; + CFileSND *s; + CSndWaveCtrl *swc=SndWaveCtrlNew(SNDFILE_SAMPLE_RATE); + CSndData *tmpsd; + char st[512]; + FILE *out_file; + + dt=head->last->tS-head->tS; + if (!dt) return 0; + cnt=dt*SNDFILE_SAMPLE_RATE; + cnt++; //Terminator + + s=(CFileSND *)CAlloc(sizeof(CFileSND)-sizeof(short)+cnt*sizeof(short)); + s->signature=0x646e732e; + s->offset=EndianDWORD(sizeof(CFileSND)-sizeof(short)); + s->coding=EndianDWORD(3); + s->sample_rate=EndianDWORD(SNDFILE_SAMPLE_RATE); + s->channels=EndianDWORD(1); + + k=0; + i=head->tS*SNDFILE_SAMPLE_RATE; + tmpsd=head->next; + while (tmpsd!=head) { + i1=tmpsd->tS*SNDFILE_SAMPLE_RATE; + if (i1-i>0) { + if (k+i1-i>cnt) { + i1=cnt-k+i; + if (i1-i<=0) + break; + } + SndWaveAddBuf(swc,(BYTE *)&s->body[k],i1-i, + Ona2Freq(tmpsd->last->ona),vol); + k+=i1-i; + i=i1; + } + tmpsd=tmpsd->next; + } + + for (i=0;ibody[i]=EndianWORD(s->body[i]); + s->body[cnt-1]=0; + + cnt2=cnt; + file_num=0; + while (cnt2>0) { + i=cnt2; + if (i>SND_FILE_MAX) + i=SND_FILE_MAX; + s->data_size=EndianDWORD(i*sizeof(short)); + memcpy(s->body,&s->body[file_num*SND_FILE_MAX],i*sizeof(short)); + sprintf(st,print_fmt,file_num++); + if (out_file=fopen(st,"wb")) { + fwrite(s,1,sizeof(CFileSND)-sizeof(short)+i*sizeof(short),out_file); + fclose(out_file); + } + cnt2-=i; + } + Free(s); + Free(swc); + return file_num; +} + +void AURead(CSndData *head,char *au_name) +{ + CSndData *tmpsd; + FILE *in_file; + CAUData aud; + long long t0_cdt; + BOOL first=TRUE; + + memset(head,0,sizeof(CSndData)); + QueInit(head); + if (in_file=fopen(au_name,"rb")) { + while (fread(&aud,1,sizeof(CAUData),in_file)) { + if (first) { + tmpsd=head; + t0_cdt=aud.cdt; + first=FALSE; + } else { + tmpsd=(CSndData *)malloc(sizeof(CSndData)); + QueIns(tmpsd,head->last); + } + tmpsd->ona=aud.ona; + tmpsd->tS=1.0*(aud.cdt-t0_cdt)/CDATE_FREQ; + } + fclose(in_file); + } +} + +#define GR_WIDTH 640 +#define GR_HEIGHT 480 +#define COLORS_NUM 16 + +class CBGR24 +{public: + BYTE b,g,r,pad; +}; + +class CBGR48 +{public: + WORD b,g,r,pad; +} gr_palette_std[COLORS_NUM]={ +{0x0000,0x0000,0x0000,0},{0xAAAA,0x0000,0x0000,0}, +{0x0000,0xAAAA,0x0000,0},{0xAAAA,0xAAAA,0x0000,0}, +{0x0000,0x0000,0xAAAA,0},{0xAAAA,0x0000,0xAAAA,0}, +{0x0000,0x5555,0xAAAA,0},{0xAAAA,0xAAAA,0xAAAA,0}, +{0x5555,0x5555,0x5555,0},{0xFFFF,0x5555,0x5555,0}, +{0x5555,0xFFFF,0x5555,0},{0xFFFF,0xFFFF,0x5555,0}, +{0x5555,0x5555,0xFFFF,0},{0xFFFF,0x5555,0xFFFF,0}, +{0x5555,0xFFFF,0xFFFF,0},{0xFFFF,0xFFFF,0xFFFF,0}}; + +#define DCF_COMPRESSED 1 +#define DCF_PALETTE 2 + +class CDC +{public: + long long cdt; + int x0,y0, + width,width_internal, + height, + flags; + CBGR48 palette[COLORS_NUM]; + BYTE *body; +}; + +CDC *DCNew(DWORD width,DWORD height) +{ + CDC *res=(CDC *)CAlloc(sizeof(CDC)); + res->width=width; + res->width_internal=(width+7)&~7; + res->height=height; + res->body=(BYTE *)CAlloc(res->width_internal*res->height); + return res; +} + +void DCDel(CDC *dc) +{//Free dc, image body, rot mat and depth buf. + if (!dc) return; + Free(dc->body); + Free(dc); +} + +CDC *DCLoad(BYTE *src,DWORD *_size) +{//Loads device context from mem. + BYTE *ptr=src; + CArcCompress *arc; + DWORD body_size; + CDC *res=(CDC *)CAlloc(sizeof(CDC)); + memcpy(res,ptr,sizeof(CDC)-sizeof(BYTE *)-COLORS_NUM*sizeof(CBGR48)); + ptr+=sizeof(CDC)-sizeof(BYTE *)-COLORS_NUM*sizeof(CBGR48); + if (res->flags&DCF_PALETTE) { + memcpy(&res->palette,ptr,COLORS_NUM*sizeof(CBGR48)); + ptr+=COLORS_NUM*sizeof(CBGR48); + } else + memcpy(&res->palette,gr_palette_std,sizeof(gr_palette_std)); + + body_size=res->width_internal*res->height; + if (res->flags&DCF_COMPRESSED) { + res->flags&=~DCF_COMPRESSED; + arc=(CArcCompress *)ptr; + res->body=ExpandBuf(arc); + ptr+=arc->compressed_size; + } else { + res->body=(BYTE *)malloc(body_size); + memcpy(res->body,ptr,body_size); + ptr+=body_size; + } + *_size=ptr-src; + return res; +} + +BOOL GrBlot(CDC *dc,int x,int y,CDC *img) +{ + int j,k,k1,w1,h1,w2,h2; + if (x<0) + w1=-x; + else + w1=0; + if (y<0) + h1=-y; + else + h1=0; + w2=img->width; + h2=img->height; + if (x+w2>dc->width) + w2=dc->width-x; + if (y+h2>dc->height) + h2=dc->height-y; + if (w1width && h1

height) { + k = h1 *img ->width_internal+w1; + k1=(h1+y)*dc->width_internal+x+w1; + for (j=h1;jbody+k1,img->body+k,w2-w1); + k +=img->width_internal; + k1+=dc->width_internal; + } + return TRUE; + } else + return FALSE; +} + +#define BMP_COLORS_NUM 16 +class CFileBMP +{public: + WORD type; + DWORD file_size; + DWORD reserved; + DWORD data_offset; + + DWORD header_size; + DWORD width; + DWORD height; + WORD planes; + WORD bit_cnt; + DWORD compression; + DWORD image_size; + DWORD x_pixs_per_meter; + DWORD y_pixs_per_meter; + DWORD colors_used; + DWORD important_colors; + + CBGR24 palette[BMP_COLORS_NUM]; +}; + +CFileBMP *BMPRLE4To(CDC *dc) +{//To Windows RLE4 bit BMP. + BYTE *src,*ptr,*start; + int i,x,y,w=dc->width,cnt,pattern; + CBGR48 palette[COLORS_NUM]; + CFileBMP *bmp =(CFileBMP *)CAlloc(sizeof(CFileBMP)+ + 2*(dc->width+1)*dc->height); + bmp->type ='B'+('M'<<8); + bmp->planes =1; + bmp->data_offset=sizeof(CFileBMP); + bmp->header_size=sizeof(CFileBMP)-BMP_COLORS_NUM*sizeof(CBGR24)-14; + bmp->width =dc->width; + bmp->height =dc->height; + bmp->bit_cnt =4; + bmp->compression=2; //RLE4 + memcpy(&palette,&gr_palette_std,sizeof(gr_palette_std)); + for (i=0;ipalette[i].b=palette[i].b>>8; + bmp->palette[i].g=palette[i].g>>8; + bmp->palette[i].r=palette[i].r>>8; + bmp->palette[i].pad=0; + } + start=ptr=(BYTE *)bmp+bmp->data_offset; + for (y=dc->height-1;y>=0;y--) { + src=y*dc->width_internal+dc->body; + x=0; + while (ximage_size=ptr-start; + bmp->file_size=sizeof(CFileBMP)+bmp->image_size; + return bmp; +} + +void BMPWrite(char *filename,CDC *dc) +{//Window's BMP Files. + CFileBMP *bmp=BMPRLE4To(dc); + FILE *out_file; + if (out_file=fopen(filename,"wb")) { + fwrite(bmp,1,bmp->file_size,out_file); + fclose(out_file); + } + Free(bmp); +} + +int MV2BMPLst(char *mv_print_fmt,char *dir_print_fmt,char *bmp_print_fmt, + char *mp4_print_fmt,char *out_name,double fps=30000.0/1001) +{//Cvt GR list MV file to BMP lst + DWORD bmp_num,size; + BOOL cont=TRUE; + int num=0,remaining,mv_percent_cnt,bmp_percent_cnt,dir_percent_cnt, + mp4_percent_cnt; + CDC *dc,*base; + BYTE *src,*src_base; + char st[512],st_dir[512],st_bmp[512],st_mp4[512]; + long long cdt=LONG_LONG_MIN; + FILE *mv_file,*lst_file=fopen("TOSZTEMP_VID_LIST.TXT","wt"); + + if (mv_print_fmt) + mv_percent_cnt=StrOcc(mv_print_fmt,'%'); + else + mv_percent_cnt=0; + if (bmp_print_fmt) + bmp_percent_cnt=StrOcc(bmp_print_fmt,'%'); + else + bmp_percent_cnt=0; + if (dir_print_fmt) + dir_percent_cnt=StrOcc(dir_print_fmt,'%'); + else + dir_percent_cnt=0; + if (mp4_print_fmt) + mp4_percent_cnt=StrOcc(mp4_print_fmt,'%'); + else + mp4_percent_cnt=0; + do { + if (mv_percent_cnt) + sprintf(st,mv_print_fmt,num); + else + strcpy(st,mv_print_fmt); + if (mv_file=fopen(st,"rb")) { + if (dir_percent_cnt) + sprintf(st_dir,dir_print_fmt,num); + else + strcpy(st_dir,dir_print_fmt); + sprintf(st,"mkdir %s",st_dir); + system(st); + bmp_num=0; + + remaining=FSize(mv_file); + src=src_base=(BYTE *)malloc(remaining+1); + fread(src_base,1,remaining,mv_file); + src_base[remaining]=0; + base=DCNew(GR_WIDTH,GR_HEIGHT); + while (cont && remaining>0) { + dc=DCLoad(src,&size); + if (!size) { + cont=FALSE; + break; + } + GrBlot(base,dc->x0,dc->y0,dc); + if (cdt==LONG_LONG_MIN) + cdt=dc->cdt; + while (cdt<=dc->cdt) { + if (bmp_percent_cnt) + sprintf(st_bmp,bmp_print_fmt,bmp_num); + else + strcpy(st_bmp,bmp_print_fmt); + sprintf(st,"%s/%s",st_dir,st_bmp); + BMPWrite(st,base); + cdt+=(DWORD)(CDATE_FREQ/fps); + if (!bmp_percent_cnt) { + cont=FALSE; + break; + } + bmp_num++; + } + DCDel(dc); + src+=size; + remaining-=size; + } + DCDel(base); + Free(src_base); + fclose(mv_file); + } else + break; + if (mp4_print_fmt) { + if (mp4_percent_cnt) + sprintf(st_mp4,mp4_print_fmt,num); + else + strcpy(st_mp4,mp4_print_fmt); + sprintf(st,"ffmpeg -framerate %0.16f -i %s/%s " + "-c:v libx264 -vf \"scale=2*trunc(iw/2):-2,setsar=1\" " + "-profile:v main -pix_fmt yuv420p %s", + fps,st_dir,bmp_print_fmt,st_mp4); + system(st); + fprintf(lst_file,"file '%s'\r\n",st_mp4); + } + num++; + if (!mv_percent_cnt) + break; + } while (cont); + + if (lst_file) { + fclose(lst_file); + if (num && out_name) { + sprintf(st,"ffmpeg -f concat -i TOSZTEMP_VID_LIST.TXT -c copy %s", + out_name); + system(st); + } + } + system("rm -R TOSZTEMP*"); + return num; +} + +int SND2MP4Lst(char *snd_print_fmt,char *mp4_print_fmt,char *out_name, + int rate=24000) +{//Cvt SND lst to MP4 + int num=0,snd_percent_cnt,mp4_percent_cnt,mkdir_percent_cnt; + char st[512],st_snd[512],st_mp4[512]; + FILE *snd_file,*lst_file=fopen("TOSZTEMP_AUD_LIST.TXT","wt"); + + if (snd_print_fmt) + snd_percent_cnt=StrOcc(snd_print_fmt,'%'); + else + snd_percent_cnt=0; + if (mp4_print_fmt) + mp4_percent_cnt=StrOcc(mp4_print_fmt,'%'); + else + mp4_percent_cnt=0; + + while (TRUE) { + if (snd_percent_cnt) + sprintf(st_snd,snd_print_fmt,num); + else + strcpy(st_snd,snd_print_fmt); + if (snd_file=fopen(st_snd,"rb")) { + fclose(snd_file); + if (mp4_percent_cnt) + sprintf(st_mp4,mp4_print_fmt,num); + else + strcpy(st_mp4,mp4_print_fmt); + sprintf(st,"ffmpeg -i %s -ar %d %s",st_snd,rate,st_mp4); + system(st); + fprintf(lst_file,"file '%s'\r\n",st_mp4); + } else + break; + num++; + if (!snd_percent_cnt) + break; + } + + if (lst_file) { + fclose(lst_file); + if (num && out_name) { + sprintf(st,"ffmpeg -f concat -i TOSZTEMP_AUD_LIST.TXT -c copy %s", + out_name); + system(st); + } + } + system("rm -R TOSZTEMP*"); + return num; +} + +int AU2SNDLst(char *au_name,char *snd_print_fmt, + char *mp4_print_fmt,char *out_name,double vol=1.0,int rate=24000) +{//Cvt AU file to SND lst to MP4 + int num=0,snd_percent_cnt; + FILE *au_file; + CSndData head; + if (snd_print_fmt) + snd_percent_cnt=StrOcc(snd_print_fmt,'%'); + else + snd_percent_cnt=0; + AURead(&head,au_name); + num=SndFileCreate(&head,snd_print_fmt,vol); + QueDel(&head); + return SND2MP4Lst(snd_print_fmt,mp4_print_fmt,out_name,rate); +} + +int main(int argc, char* argv[]) +{ + char *in_name,*out_name,st[256],*mv_print_fmt,*au_name; + BOOL cvt_ascii,del_in=FALSE; + int i=1,l; + double vol=0.1; + if (argc>i && !strcmp(argv[i],"-mp4")) { + i++; + if (argc>i) + mv_print_fmt=argv[i++]; + else + mv_print_fmt=(char *)"VID%03d.MV"; + if (argc>i) + au_name=argv[i++]; + else + au_name=(char *)"AUDIO.AU"; + MV2BMPLst(mv_print_fmt,(char *)"TOSZTEMP%03d", + (char *)"TOSZTEMP%06d.BMP",(char *)"TOSZTEMPVID%03d.MP4", + (char *)"TOSZVIDEO.MP4"); + AU2SNDLst(au_name,(char *)"TOSZTEMP%03d.SND", + (char *)"TOSZTEMPAUD%03d.MP4",(char *)"TOSZAUDIO.MP4",vol); + if (argc>i) + out_name=argv[i++]; + else + out_name=(char *)"MOVIE.MP4"; + sprintf(st,"ffmpeg -i TOSZVIDEO.MP4 -i TOSZAUDIO.MP4 %s",out_name); + system(st); + system("rm TOSZVIDEO.MP4"); + system("rm TOSZAUDIO.MP4"); + } else { + if (argc>i && !strcmp(argv[i],"-ascii")) { + cvt_ascii=TRUE; + i++; + } else + cvt_ascii=FALSE; + if (argc>i) { + in_name=argv[i++]; + if (argc>i) + out_name=argv[i++]; + else { + strcpy(st,in_name); + l=strlen(st); + if (l>2 && st[l-1]=='Z' && st[l-2]=='.') { + st[l-2]=0; + del_in=TRUE; + } + out_name=st; + } + if (argc>i) + out_name=argv[i++]; + else { + strcpy(st,in_name); + l=strlen(st); + if (l>2 && st[l-1]=='Z' && st[l-2]=='.') { + st[l-2]=0; + del_in=TRUE; + } + out_name=st; + } + if (Cvt(in_name,out_name,cvt_ascii)) { + if (del_in) { + sprintf(st,"rm %s",in_name); + system(st); + } + } else + printf("Fail: %s %s\r\n",in_name,out_name); + } else { + puts("TOSZ [-ascii] in_name [out_name]\r\n" + "expands a single TempleOS file. " + "The -ascii flag will convert " + "nonstandard TempleOS ASCII " + "characters to regular ASCII.\r\n\r\n" + "TOSZ -mp4 VID%03d.MV AUDIO.AU MOVIE.MP4\r\n" + "will call ffmpeg to convert MV files and an AU file " + "to a combined MP4 file.\r\n"); + } + } + return EXIT_SUCCESS; +} diff --git a/Downloads/Linux/gw b/Downloads/Linux/gw new file mode 100644 index 0000000..cd180bb --- /dev/null +++ b/Downloads/Linux/gw @@ -0,0 +1,6 @@ +#!/bin/bash + +#This prints random words from the Linux dictionary. + +echo "$(shuf -n 32 /usr/share/dict/words --random-source=/dev/urandom | tr '\n' ' ')" + diff --git a/Downloads/Linux/make_tosz b/Downloads/Linux/make_tosz new file mode 100644 index 0000000..ced04b3 --- /dev/null +++ b/Downloads/Linux/make_tosz @@ -0,0 +1,7 @@ +#!/bin/bash + +#Make TOSZ + +echo Make TOSZ +cc TOSZ.CPP -o TOSZ +chmod 777 TOSZ diff --git a/Downloads/ReadMe.TXT b/Downloads/ReadMe.TXT new file mode 100644 index 0000000..e5a0842 --- /dev/null +++ b/Downloads/ReadMe.TXT @@ -0,0 +1,23 @@ + TempleOS + +You can't do anything until you burn a TempleOS CD/DVD from the ISO file +and boot it, or you aim your virtual machine's CD/DVD at the ISO file +and boot. + +TempleOS is 64-bit and will not run on 32-bit hardware. + +TempleOS requires 512 Meg of RAM minimum and can have 256 Gig of RAM or more! + +TempleOS files are compressed with a nonstandard LZW format and the source +code can only be compiled by the TempleOS compiler because it is HolyC, a +nonstandard C/C++ dialect. You must boot TempleOS. Then, you can compile it +because it is 100% open source and all source present on the distro. + +If attempting to run on native hardware, TempleOS may require you to enter I/O +port addresses for the CD/DVD drive and the hard drive. In Windows, you can +find I/O port info in the Accessories/System Tools/System Info/Hardware +Resources/I/O ports. Look for and write down "IDE", "ATA" or "SATA" port numbers. +In Linux, use "lspci -v". Then, boot the TempleOS CD and try all combinations. +(Sorry, it's too difficult for TempleOS to figure-out port numbers, automatically.) + + diff --git a/Kernel/BlkDev/DskCluster.HC b/Kernel/BlkDev/DskCluster.HC new file mode 100644 index 0000000..0c1b6e8 --- /dev/null +++ b/Kernel/BlkDev/DskCluster.HC @@ -0,0 +1,151 @@ +I64 ClusterNumNext(CDrv *dv,I64 c,I64 cnt=1) +{//Return next cnt'th cluster in chain. + Bool unlock; + DrvChk(dv); + if (cnt<=0) return c; + try { + unlock=DrvLock(dv); + switch (dv->fs_type) { + case FSt_ISO9660: + case FSt_REDSEA: + c+=cnt; + break; + case FSt_FAT32: + while (cnt-->0 && 0cur_fat_blk[c & (BLK_SIZE/4-1)]; + } + if (!(0fs_type) { + case FSt_REDSEA: + return c; + case FSt_ISO9660: + case FSt_FAT32: + return dv->data_area+c*dv->spc; + default: + throw('Drv'); + } +} + +I64 RClustersBlks(CDrv *dv,U8 *buf,I64 c,I64 blks) +{//Accepts blk count, so padding on last cluster is not read. + I64 i; + Bool unlock; + DrvChk(dv); + if (blks<=0) return c; + try { + unlock=DrvLock(dv); + switch (dv->fs_type) { + case FSt_ISO9660: + RBlks(dv,buf,dv->data_area+c*dv->spc,blks); + c+=(blks+dv->spc-1)/dv->spc; + break; + case FSt_REDSEA: + RBlks(dv,buf,c,blks); + c+=blks; + break; + case FSt_FAT32: + while (blks && 0dv->spc) + i=dv->spc; + RBlks(dv,buf,dv->data_area+c*dv->spc,i); + buf+=i<spc); +} + +I64 WClustersBlks(CDrv *dv,U8 *buf,I64 c,I64 blks) +{//Accepts blk count, so padding on last cluster is not written. + I64 i; + Bool unlock; + DrvChk(dv); + if (blks<=0) return c; + try { + unlock=DrvLock(dv); + switch (dv->fs_type) { + case FSt_REDSEA: + WBlks(dv,buf,c,blks); + c=0; + break; + case FSt_FAT32: + while (blks) { + if (!(0dv->spc) + i=dv->spc; + WBlks(dv,buf,dv->data_area+c*dv->spc,i); + buf+=i<spc); +} + +I64 ClustersAlloc(CDrv *dv,I64 c=0,I64 cnt=1,Bool contiguous=FALSE) +{//Alloc cluster cnt into chain. +//c=0 means first cluster in chain + DrvChk(dv); + if (cnt<=0) return c; + switch (dv->fs_type) { + case FSt_REDSEA: + return RedSeaAllocClusters(dv,cnt); + case FSt_FAT32: + if (contiguous) { + if (c) throw('File'); + return FAT32AllocContiguousClusters(dv,cnt); + } else + return FAT32AllocClusters(dv,c,cnt); + default: + throw('Drv'); + } +} diff --git a/Kernel/KMain.HC b/Kernel/KMain.HC new file mode 100644 index 0000000..32bb8b3 --- /dev/null +++ b/Kernel/KMain.HC @@ -0,0 +1,238 @@ +U0 SysGlblsInit() +{ + I64 i,j; + CRAXRBCRCXRDX ee; + + CPUId(0x1,&ee); + sys_cache_line_width=ee.rbx.u8[1]*8; + + sys_focus_task=Fs; + QueInit(&sys_macro_head); + + blkdev.dft_iso_filename =AStrNew(DFT_ISO_FILENAME); + blkdev.dft_iso_c_filename =AStrNew(DFT_ISO_C_FILENAME); + blkdev.tmp_filename =AStrNew("~/Tmp.DD.Z"); + blkdev.dvd_boot_is_good=TRUE; + #exe { + if (!kernel_cfg->mount_ide_auto_hd_let) + kernel_cfg->mount_ide_auto_hd_let='C'; + if (!kernel_cfg->mount_ide_auto_cd_let) + kernel_cfg->mount_ide_auto_cd_let='T'; + StreamPrint("blkdev.first_hd_drv_let=%d;", + kernel_cfg->mount_ide_auto_hd_let); + StreamPrint("blkdev.first_dvd_drv_let=%d;", + kernel_cfg->mount_ide_auto_cd_let); + } + + DbgMode(ON); + rev_bits_table=CAlloc(256); + set_bits_table=CAlloc(256); + for (i=0;i<256;i++) + for (j=0;j<8;j++) { + if (Bt(&i,7-j)) LBts(rev_bits_table+i,j); + if (Bt(&i,j)) set_bits_table[i]++; + } + + ext=CAlloc(EXT_EXTS_NUM*sizeof(U8 *)); + fp_getstr2=&SysGetStr2; + KeyDevInit; + + #exe { + StreamPrint("blkdev.boot_drv_let='%C';",kernel_cfg->boot_drv_let); + StreamPrint("#exe{Option(OPTf_WARN_PAREN,OFF);}"); + StreamPrint("DskCacheInit(%s);",kernel_cfg->dsk_cache_size_exp); + StreamPrint("#exe{Option(OPTf_WARN_PAREN,ON);}"); + }; + + pow10_I64=CAlloc(sizeof(F64)*(308+308+1)); + for (i=-308;i<309;i++) + pow10_I64[i+309]=Pow10(i); + + QueInit(&scrncast.snd_head); + scrncast.t0_now=Now; + scrncast.t0_tS=tS; + scrncast.ona=scrncast.snd_head.ona=0; + + ProgressBarsRst; + + QueInit(&dev.pci_head); + dev.mem64_ptr=mem_mapped_space; + + dbg.fun_seg_cache=CAlloc(FUN_SEG_CACHE_SIZE*sizeof(CFunSegCache)); + dbg.int_fault_code=IntFaultHndlrsNew; +} + +U0 SysGrInit() +{ + text.font=sys_font_std; + text.aux_font=sys_font_cyrillic; + text.vga_alias =dev.uncached_alias+VGAM_GRAPHICS; + text.vga_text_alias =dev.uncached_alias+VGAM_TEXT; + if (!Bt(&sys_run_level,RLf_VGA)) { //if text mode + text.cols=80; + text.rows=25; + MemSet(text.vga_text_alias,0,text.rows*text.cols<<1); + text.border_chars[2] (I64)='ÄͳºÚÉ¿»'; + text.border_chars[10](U32)='ÀÈÙ¼'; + } else { //if 640x480 16 color + text.cols=GR_WIDTH/FONT_WIDTH; + text.rows=GR_HEIGHT/FONT_HEIGHT; + OutU8(VGAP_IDX,VGAR_MAP_MASK); + OutU8(VGAP_DATA,0x0F); + MemSet(text.vga_alias,0,GR_WIDTH*GR_HEIGHT>>3); + text.raw_scrn_image=CAlloc(GR_WIDTH*GR_HEIGHT/8); + text.border_chars[2] (I64)=0x0908070605040302; + text.border_chars[10](U32)=0x0D0C0B0A; + } +} + +U0 TimersInit() +{ + I64 i,*_q; + U32 *_d; + + OutU8(0x43,0x34); + OutU8(0x40,SYS_TIMER0_PERIOD); + OutU8(0x40,SYS_TIMER0_PERIOD>>8); + + //High Precision Event Timer + if (PCIReadU16(0,31,0,0)==0x8086) {//Intel? +//D31 F0, cfg 0xF0=RCBA of PCI-LPC Bridge + _d=PCIReadU32(0,31,0,0xF0)(U8 *)&~0x3FFF+0x3404; //HPET cfg +//7 enable + //1:0 HPET is at 0xFED00000,0xFED01000, 0xFED02000 or 0xFED03000. + *_d=*_d&3|0x80; + } + + _q=dev.uncached_alias+HPET_GCAP_ID; + i=*_q; //i.u32[1]= period in femtoS (10e-15) + if (1000001) + MPHalt; + *0x472(U16 *)=0; + OutU8(0x70,0x8F); + OutU8(0x71,0x00); + OutU8(0x70,0x00); + OutU8(0x92,InU8(0x92)|1); + SysHlt; +} + +U0 KMain() +{//Continued from $LK,"KStart64.HC",A="FF:::/Kernel/KStart64.HC,I32 &KMain"$ + CBlkDev *bd; + OutU8(0x61,InU8(0x61)&~3); //Snd; + adam_task=Fs; + BlkPoolsInit; + SysGlblsInit; + Mem32DevInit; + UncachedAliasAlloc; + LoadKernel; + SysGrInit; + StrCpy(Fs->task_name,"Adam Task CPU00"); + StrCpy(Fs->task_title,Fs->task_name); + Fs->title_src=TTS_TASK_NAME; + Fs->win_right=text.cols-2; + Fs->win_top++; + TaskDerivedValsUpdate; + + SysDefinesLoad; + Core0Init; + IntInit1; + + //Before this point use $LK,"Snd",A="MN:Snd"$() and $LK,"Busy",A="MN:Busy"$() + //to debug. After this point, use $LK,"RawPrint",A="MN:RawPrint"$() + LBts(&sys_run_level,RLf_RAW); + "TempleOS V%5.3f\t%D %T\n\n", + sys_os_version,sys_compile_time,sys_compile_time; + + TimersInit; + if (BIOSTotalMemhome_dir, + blkdev.ins_base0,blkdev.ins_base1,blkdev.ins_unit); + } + Gs->idle_task->cur_dv=blkdev.let_to_drv[*blkdev.home_dir-'A']; + DrvRep; + if (blkdev.dvd_boot_is_good) { + bd=Let2BlkDev(':'); + if (bd->type==BDT_ATAPI) { + blkdev.ins_base0=bd->base0; + blkdev.ins_base1=bd->base1; + blkdev.ins_unit =bd->unit; + } + } + LBts(&sys_run_level,RLf_BLKDEV); + + #exe { + if (!kernel_cfg->opts[CFG_NO_MP]) + StreamPrint("\"MultiCore Start\\n\\n\";" + "Core0StartMP;" + "LBts(&sys_run_level,RLf_MP);"); + }; + + KbdMsInit; + MsInit; + KbdInit; + Spawn(&MsHardDrvrInstall); + + "Loading Compiler\n"; + Cd("/Compiler"); + Load("Compiler",LDF_SILENT); + LBts(&sys_run_level,RLf_COMPILER); + + DbgMode(OFF); + cnts.time_stamp_freq_initial=TimeCal; + Cd("/"); + try ExeFile("StartOS"); //Continues $LK,"/StartOS.HC",A="FL:/StartOS.HC,1"$ + catch { + Raw(ON); + Silent(OFF); + GetOutOfDollar; + PutExcept; + Dbg; + } + + LBts(&sys_run_level,RLf_ADAM_SERVER); + SrvTaskCont; //Never to return +} + +asm { ALIGN 16,OC_NOP +SYS_KERNEL_END:: +#exe { + if (kernel_cfg->opts[CFG_DBG_DISTRO]) + StreamPrint("DU8 0x%X-(SYS_KERNEL_END-SYS_KERNEL+" + "BOOT_RAM_BASE+sizeof(CBinFile)) DUP (0);" + "BINFILE \"%s\";",kernel_cfg->dbg_distro_start, + kernel_cfg->dbg_distro_file); +}; +} diff --git a/Linux/TOSZ b/Linux/TOSZ new file mode 100644 index 0000000000000000000000000000000000000000..8b56deeeab6b41623138921622d2dc30f3882e0c GIT binary patch literal 26912 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 NfDSBxuplJ5egLQ6i!J~F literal 0 HcmV?d00001 diff --git a/Linux/gw b/Linux/gw new file mode 100644 index 0000000..cd180bb --- /dev/null +++ b/Linux/gw @@ -0,0 +1,6 @@ +#!/bin/bash + +#This prints random words from the Linux dictionary. + +echo "$(shuf -n 32 /usr/share/dict/words --random-source=/dev/urandom | tr '\n' ' ')" + diff --git a/Linux/make_tosz b/Linux/make_tosz new file mode 100644 index 0000000..118782a --- /dev/null +++ b/Linux/make_tosz @@ -0,0 +1,9 @@ +#!/bin/bash + +#Make TOSZ + +echo Make TOSZ +cc TOSZ.CPP -o TOSZ +chmod 777 TOSZ + +