abr00kx commited on
Commit
7807aaa
·
verified ·
1 Parent(s): 8763117

TempleOS source with 480x640 portrait screen

Browse files
This view is limited to 50 files because it contains too many changes.   See raw diff
Files changed (50) hide show
  1. Adam/ABlkDev/ADskA.HC +3 -252
  2. Adam/ABlkDev/ADskB.HC +3 -191
  3. Adam/ABlkDev/ChkDsk.HC +3 -444
  4. Adam/ABlkDev/DskChk.HC +3 -444
  5. Adam/ABlkDev/DskPrt.HC +3 -167
  6. Adam/ABlkDev/FileMgr.HC +3 -791
  7. Adam/ABlkDev/MakeABlkDev.HC +3 -8
  8. Adam/ABlkDev/Mount.HC +3 -159
  9. Adam/ABlkDev/PrtDsk.HC +3 -167
  10. Adam/ADbg.HC +3 -270
  11. Adam/ADefine.HC +3 -38
  12. Adam/AExts.HC +3 -95
  13. Adam/AHash.HC +3 -431
  14. Adam/AMath.HC +3 -135
  15. Adam/AMathODE.HC +3 -688
  16. Adam/AMem.HC +3 -179
  17. Adam/AMouse.HC +0 -0
  18. Adam/ARegistry.HC +3 -203
  19. Adam/ASnd.HC +3 -409
  20. Adam/AutoComplete/ACDictGen.HC +3 -261
  21. Adam/AutoComplete/ACFill.HC +3 -226
  22. Adam/AutoComplete/ACInit.HC +3 -169
  23. Adam/AutoComplete/ACTask.HC +3 -283
  24. Adam/AutoComplete/MakeAC.HC +3 -6
  25. Adam/CPURep.HC +3 -72
  26. Adam/Ctrls/CtrlsA.HC +3 -388
  27. Adam/Ctrls/CtrlsBttn.HC +3 -91
  28. Adam/Ctrls/CtrlsSlider.HC +3 -214
  29. Adam/Ctrls/MakeCtrls.HC +3 -8
  30. Adam/DevInfo.HC +3 -220
  31. Adam/DolDoc/DocBin.HC +3 -142
  32. Adam/DolDoc/DocChar.HC +3 -652
  33. Adam/DolDoc/DocClipBoard.HC +3 -125
  34. Adam/DolDoc/DocCodeTools.HC +3 -658
  35. Adam/DolDoc/DocDblBuf.HC +3 -110
  36. Adam/DolDoc/DocEd.HC +3 -265
  37. Adam/DolDoc/DocExt.HC +3 -14
  38. Adam/DolDoc/DocFile.HC +3 -357
  39. Adam/DolDoc/DocFind.HC +3 -584
  40. Adam/DolDoc/DocForm.HC +3 -344
  41. Adam/DolDoc/DocGet.HC +3 -243
  42. Adam/DolDoc/DocGr.HC +3 -163
  43. Adam/DolDoc/DocHighlight.HC +3 -160
  44. Adam/DolDoc/DocInit.HC +3 -112
  45. Adam/DolDoc/DocLink.HC +3 -358
  46. Adam/DolDoc/DocMacro.HC +3 -211
  47. Adam/DolDoc/DocNew.HC +3 -385
  48. Adam/DolDoc/DocPlain.HC +3 -611
  49. Adam/DolDoc/DocPopUp.HC +3 -317
  50. Adam/DolDoc/DocPutKey.HC +3 -729
Adam/ABlkDev/ADskA.HC CHANGED
@@ -1,252 +1,3 @@
1
- #help_index "File/Cmd Line (Typically);Cmd Line (Typically)"
2
- public U8 *DBlk(I64 blk,Bool write=FALSE)
3
- {//Dump disk block. Optionally, write.
4
- //If you set write to TRUE, the block will
5
- //be written when you press <ESC>.
6
- //See $LK,"::/Demo/Dsk/DskRaw.HC"$.
7
- U8 *buf=MAlloc(BLK_SIZE);
8
-
9
- BlkRead(Fs->cur_dv,buf,blk,1);
10
- DocD(buf,BLK_SIZE);
11
- if (write) {
12
- "Edit and press <ESC> to write or <SHIFT-ESC>\n";
13
- if (View) {
14
- "Write\n";
15
- BlkWrite(Fs->cur_dv,buf,blk,1);
16
- }
17
- }
18
- return buf;
19
- }
20
-
21
- public U8 *DClus(I64 c,Bool write=FALSE,I64 num=0)
22
- {//Dump disk clus. Optionally, write.
23
- //If you set write to TRUE, the clus will
24
- //be written when you press <ESC>.
25
- //See $LK,"::/Demo/Dsk/DskRaw.HC"$.
26
- //Do $LK,"Dir",A="MN:Dir"$("*",TRUE); to get clus numbers of files.
27
- U8 *buf=MAlloc(Fs->cur_dv->spc<<BLK_SIZE_BITS);
28
- c=ClusNumNext(Fs->cur_dv,c,num);
29
- ClusRead(Fs->cur_dv,buf,c,1);
30
- "Clus:%X\n",c;
31
- DocD(buf,Fs->cur_dv->spc<<BLK_SIZE_BITS);
32
- if (write) {
33
- "Edit and press <ESC> to write or <SHIFT-ESC>\n";
34
- if (View) {
35
- "Write\n";
36
- ClusWrite(Fs->cur_dv,buf,c,1);
37
- }
38
- }
39
- return buf;
40
- }
41
-
42
- public U8 *Dump(U8 *filename,Bool write=FALSE)
43
- {//Dump file. Optionally, write.
44
- //If you set write to TRUE, the file will
45
- //be written when you press <ESC>.
46
- U8 *buf;
47
- I64 size;
48
- if (buf=FileRead(filename,&size)) {
49
- DocD(buf,size);
50
- if (write) {
51
- "Edit and press <ESC> to write or <SHIFT-ESC>\n";
52
- if (View) {
53
- "Write\n";
54
- FileWrite(filename,buf,size);
55
- }
56
- }
57
- }
58
- return buf;
59
- }
60
-
61
- public Bool Copy(U8 *src_files_find_mask,U8 *dst_files_find_mask=".")
62
- {//Copy files.
63
- //If the name ends in ".Z", it will
64
- //be stored compressed. If not ".Z"
65
- //it will be stored uncompressed.
66
- Bool res=TRUE;
67
- CDirContext *dirc;
68
- CDirEntry *tmpde,*tmpde1;
69
- U8 *st;
70
- if (!(tmpde1=FilesFind(src_files_find_mask,FUF_CLUS_ORDER)))
71
- return FALSE;
72
- if (IsDir(dst_files_find_mask)) {
73
- if (dirc=DirContextNew(dst_files_find_mask,TRUE)) {
74
- tmpde=tmpde1;
75
- while (tmpde) {
76
- if (!(tmpde->attr & RS_ATTR_DIR)) {
77
- st=FileNameAbs(tmpde->name);
78
- if (!CopySingle(tmpde->full_name,st))
79
- res=FALSE;
80
- Free(st);
81
- }
82
- tmpde=tmpde->next;
83
- }
84
- DirContextDel(dirc);
85
- }
86
- DirTreeDel(tmpde1);
87
- return res;
88
- } else {
89
- DirTreeDel(tmpde1);
90
- return CopySingle(src_files_find_mask,dst_files_find_mask);
91
- }
92
- }
93
-
94
- public Bool Move(U8 *f1,U8 *f2)
95
- {//Move files from one location to another or rename.
96
- if (Copy(f1,f2)) {
97
- Del(f1);
98
- return TRUE;
99
- }
100
- return FALSE;
101
- }
102
-
103
- I64 CopyTree2(CDirEntry *tmpde,I64 src_dir_len,I64 dst_dir_len,U8 *dst_dir)
104
- {
105
- U8 *st;
106
- I64 res=1;
107
- while (tmpde) {
108
- st=MAlloc(StrLen(tmpde->full_name)+dst_dir_len+2);
109
- MemCpy(st,dst_dir,dst_dir_len);
110
- StrCpy(st+dst_dir_len,tmpde->full_name+src_dir_len);
111
- if (tmpde->attr & RS_ATTR_DIR) {
112
- DirMk(st,LinkedLstCnt(tmpde->sub));
113
- res+=CopyTree2(tmpde->sub,src_dir_len,dst_dir_len,dst_dir);
114
- } else
115
- if (CopySingle(tmpde->full_name,st))
116
- res++;
117
- Free(st);
118
- tmpde=tmpde->next;
119
- }
120
- return res;
121
- }
122
- public I64 CopyTree(U8 *src_files_find_mask,U8 *dst_files_find_mask,
123
- Bool no_mask=TRUE)
124
- {//Copy directory tree.
125
- //Returns the count of copied files (not dirs).
126
- CDirContext *dirc;
127
- CDirEntry *tmpde=NULL;
128
- I64 res=0,i1,i2;
129
- U8 *st1,*st2;
130
-
131
- st1=DirNameAbs(src_files_find_mask);
132
- st2=DirNameAbs(dst_files_find_mask);
133
- i1=StrLen(st1);
134
- if (!StrNCmp(st1,st2,i1) && (st2[i1]=='/' || !st2[i1]) ) {
135
- Free(st1);
136
- Free(st2);
137
- return 0;
138
- }
139
- Free(st1);
140
- Free(st2);
141
- if (dirc=DirContextNew(src_files_find_mask,TRUE,,no_mask)) {
142
- tmpde=FilesFind(dirc->mask,FUF_RECURSE);
143
- st1=DirCur;
144
- DirContextDel(dirc);
145
- i1=StrLen(st1);
146
- if (i1==3) i1--;
147
- if (dirc=DirContextNew(dst_files_find_mask,TRUE,TRUE)) {
148
- st2=DirCur;
149
- i2=StrLen(st2);
150
- if (i2==3) i2--;
151
- res=CopyTree2(tmpde,i1,i2,st2);
152
- DirContextDel(dirc);
153
- Free(st2);
154
- }
155
- DirTreeDel(tmpde);
156
- Free(st1);
157
- }
158
- return res;
159
- }
160
-
161
- I64 DelTreeDirs(CDirEntry *tmpde1)
162
- {
163
- I64 res=0;
164
- CDirEntry *tmpde2;
165
- while (tmpde1) {
166
- tmpde2=tmpde1->next;
167
- if (tmpde1->attr & RS_ATTR_DIR) {
168
- if (tmpde1->sub)
169
- res+=DelTreeDirs(tmpde1->sub);
170
- res+=Del(tmpde1->full_name,TRUE,TRUE);
171
- }
172
- DirEntryDel(tmpde1);
173
- tmpde1=tmpde2;
174
- }
175
- return res;
176
- }
177
- I64 DelTreeFiles(CDirEntry *tmpde1)
178
- {
179
- I64 res=0;
180
- CDirEntry *tmpde2;
181
- while (tmpde1) {
182
- tmpde2=tmpde1->next;
183
- if (tmpde1->attr & RS_ATTR_DIR) {
184
- if (tmpde1->sub)
185
- res+=DelTreeFiles(tmpde1->sub);
186
- } else
187
- res+=Del(tmpde1->full_name,FALSE,TRUE);
188
- DirEntryDel(tmpde1);
189
- tmpde1=tmpde2;
190
- }
191
- return res;
192
- }
193
- public I64 DelTree(U8 *files_find_mask,U8 *fu_flags=NULL)
194
- {//Delete directory tree.
195
- I64 res=0,fuf_flags=0;
196
- ScanFlags(&fuf_flags,Define("ST_FILE_UTIL_FLAGS"),"+r");
197
- ScanFlags(&fuf_flags,Define("ST_FILE_UTIL_FLAGS"),fu_flags);
198
- if (IsDir(files_find_mask)) {
199
- res=DelTreeDirs(FilesFind(files_find_mask,fuf_flags));
200
- res+=Del(files_find_mask,TRUE,TRUE);
201
- res+=Del(files_find_mask,FALSE,TRUE);
202
- } else
203
- res=DelTreeFiles(FilesFind(files_find_mask,fuf_flags));
204
- return res;
205
- }
206
-
207
- U0 TouchFile(U8 *filename,U8 *attr,CDate cdt=I64_MIN)
208
- {
209
- CDrv *dv=Let2Drv(*filename);
210
- CDirEntry de;
211
- U8 *cur_dir=StrNew(filename),buf[STR_LEN];
212
- if (FileFind(filename,&de,FUF_JUST_FILES)) {
213
- Free(de.full_name);
214
- if (!StrCmp(attr,"+?"))
215
- "%-48ts %s\n",filename,StrPrintFlags(buf,Define("ST_FILE_ATTRS"),de.attr);
216
- else {
217
- StrFirstRem(cur_dir,":");
218
- StrLastRem(cur_dir,"/");
219
- if (!*cur_dir)
220
- StrCpy(cur_dir,"/");
221
- ScanFlags(&de.attr,Define("ST_FILE_ATTRS"),attr);
222
- if (cdt==I64_MIN)
223
- de.datetime=Now;
224
- else
225
- de.datetime=cdt;
226
- DirNew(dv,cur_dir,&de,FALSE);
227
- }
228
- } else
229
- PrintErr("File not found: \"%s\".\n",filename);
230
- Free(cur_dir);
231
- }
232
- public U0 Touch(U8 *files_find_mask="*",U8 *attr="+?",
233
- U8 *fu_flags=NULL,CDate cdt=I64_MIN)
234
- {/*Touch file attributes and DateTime.
235
- Default lists attributes.
236
- attr: "+?" =show current
237
- "+T" =resident
238
- $LK,"RS_ATTR_READ_ONLY",A="MN:RS_ATTR_READ_ONLY"$ $LK,"ST_FILE_ATTRS",A="MN:ST_FILE_ATTRS"$
239
- To Set DateL:
240
- Touch(filename,"",,datetime);
241
- */
242
- I64 fuf_flags=0;
243
- CDirEntry *tmpde,*tmpde1;
244
- ScanFlags(&fuf_flags,Define("ST_FILE_UTIL_FLAGS"),"+f+F");
245
- ScanFlags(&fuf_flags,Define("ST_FILE_UTIL_FLAGS"),fu_flags);
246
- tmpde=tmpde1=FilesFind(files_find_mask,fuf_flags);
247
- while (tmpde) {
248
- TouchFile(tmpde->full_name,attr,cdt);
249
- tmpde=tmpde->next;
250
- }
251
- DirTreeDel(tmpde1);
252
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:4319e1763f8ed703cef8e870a1bb641b3c88f9a01379d66217bdcb0598a85a2b
3
+ size 6514
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/ABlkDev/ADskB.HC CHANGED
@@ -1,191 +1,3 @@
1
- #help_index "File/Internal"
2
- I64 DirTreeSerializeSize(CDirEntry *tmpde)
3
- {
4
- I64 res=0;
5
- while (tmpde) {
6
- res+=CDIR_SIZE+1;
7
- if (tmpde->attr & RS_ATTR_DIR)
8
- res+=DirTreeSerializeSize(tmpde->sub);
9
- tmpde=tmpde->next;
10
- }
11
- return res+1;
12
- }
13
- I64 DirTreeSerializeFill(CDirEntry *tmpde,U8 *dst)
14
- {
15
- I64 res=0,i;
16
- while (tmpde) {
17
- *dst++=1;
18
- res++;
19
- MemCpy(dst,&tmpde->start,CDIR_SIZE);
20
- dst+=CDIR_SIZE;
21
- res+=CDIR_SIZE;
22
- if (tmpde->attr & RS_ATTR_DIR) {
23
- i=DirTreeSerializeFill(tmpde->sub,dst);
24
- dst+=i;
25
- res+=i;
26
- }
27
- tmpde=tmpde->next;
28
- }
29
- *dst=0;
30
- return res+1;
31
- }
32
- public U8 *DirTreeSerialize(CDirEntry *tmpde,I64 *_size=NULL)
33
- {//Serialize tree returned from $LK,"FilesFind",A="MN:FilesFind"$() into a one contiguous U8 array.
34
- I64 size=DirTreeSerializeSize(tmpde);
35
- U8 *buf=MAlloc(size);
36
- DirTreeSerializeFill(tmpde,buf);
37
- if (_size) *_size=size;
38
- return buf;
39
- }
40
-
41
- U8 *DirTreeUnserialize2(U8 *src,CDirEntry **tmpde)
42
- {
43
- CDirEntry *tmpde1;
44
- if (*src++) {
45
- tmpde1=CAlloc(sizeof(CDirEntry));
46
- *tmpde=tmpde1;
47
- MemCpy(&tmpde1->start,src,CDIR_SIZE);
48
- src+=CDIR_SIZE;
49
- if (tmpde1->attr & RS_ATTR_DIR)
50
- src=DirTreeUnserialize2(src,&tmpde1->sub);
51
- src=DirTreeUnserialize2(src,&tmpde1->next);
52
- } else
53
- *tmpde=NULL;
54
- return src;
55
- }
56
- public CDirEntry *DirTreeUnserialize(U8 *src)
57
- {//Unserialize tree to make it like a tree returned from $LK,"FilesFind",A="MN:FilesFind"$().
58
- CDirEntry *tmpde=NULL;
59
- DirTreeUnserialize2(src,&tmpde);
60
- return tmpde;
61
- }
62
-
63
- #help_index "File/Program Routines"
64
- U0 FOFlatten(CDirEntry *tmpde,CDirEntry **a,I64 *i)
65
- {
66
- CDirEntry *tmpde1;
67
- while (tmpde) {
68
- tmpde1=tmpde->next;
69
- if (tmpde->attr&RS_ATTR_DIR) {
70
- FOFlatten(tmpde->sub,a,i);
71
- DirEntryDel(tmpde);
72
- } else {
73
- a[*i]=tmpde;
74
- *i=*i+1;
75
- }
76
- tmpde=tmpde1;
77
- }
78
- }
79
-
80
- I64 Size1(CDirEntry *tmpde,I64 *_fuf_flags,I64 round_to)
81
- {
82
- U8 buf[BLK_SIZE];
83
- I64 res=0,i;
84
- CDrv *dv;
85
- while (tmpde) {
86
- if ((i=tmpde->size) && Bt(_fuf_flags,FUf_EXPAND) &&
87
- !(tmpde->attr&RS_ATTR_DIR) &&
88
- FileAttr(tmpde->name)&RS_ATTR_COMPRESSED) {
89
- dv=Let2Drv(*tmpde->full_name);
90
- BlkRead(dv,buf,Clus2Blk(dv,tmpde->clus),1);
91
- i=(&buf)(CArcCompress *)->expanded_size;
92
- }
93
- if (round_to)
94
- i=CeilU64(tmpde->size,round_to);
95
- if (tmpde->attr&RS_ATTR_DIR)
96
- i+=Size1(tmpde->sub,_fuf_flags,round_to);
97
- tmpde->user_data=i;
98
- res+=i;
99
- tmpde=tmpde->next;
100
- }
101
- return res;
102
- }
103
- public I64 Size(U8 *files_find_mask="/*",U8 *fu_flags=NULL,I64 round_to=0)
104
- {//Total size of files in mask. "+x" for expanded size.
105
- //Does not include directory size of base directory, but
106
- //does include size of sub directories.
107
- I64 fuf_flags=0,res=0;
108
- CDirEntry *tmpde1=NULL;
109
- ScanFlags(&fuf_flags,Define("ST_FILE_UTIL_FLAGS"),"+r");
110
- ScanFlags(&fuf_flags,Define("ST_FILE_UTIL_FLAGS"),fu_flags);
111
- if (tmpde1=FilesFind(files_find_mask,fuf_flags&FUG_FILES_FIND)) {
112
- fuf_flags&=FUF_EXPAND;
113
- res=Size1(tmpde1,&fuf_flags,round_to);
114
- DirTreeDel(tmpde1);
115
- }
116
- return res;
117
- }
118
-
119
- public I64 FileCnt(CDirEntry *tmpde)
120
- {//Cnt of files in $LK,"CDirEntry",A="MN:CDirEntry"$ tree.
121
- I64 cnt=0;
122
- while (tmpde) {
123
- if (tmpde->attr&RS_ATTR_DIR)
124
- cnt+=FileCnt(tmpde->sub);
125
- else
126
- cnt++;
127
- tmpde=tmpde->next;
128
- }
129
- return cnt;
130
- }
131
-
132
- #help_index "File/Cmd Line (Typically);Cmd Line (Typically)"
133
- public I64 FF(U8 *files_find_mask,U8 *fu_flags=NULL)
134
- {//Files find. List files matching mask.
135
- I64 cnt=0,fuf_flags=0;
136
- CDirEntry *tmpde,*tmpde1;
137
- ScanFlags(&fuf_flags,Define("ST_FILE_UTIL_FLAGS"),"+r+f+F");
138
- ScanFlags(&fuf_flags,Define("ST_FILE_UTIL_FLAGS"),fu_flags);
139
- tmpde=tmpde1=FilesFind(files_find_mask,fuf_flags);
140
- while (tmpde) {
141
- PutFileLink(tmpde->full_name);
142
- '\n';
143
- cnt++;
144
- tmpde=tmpde->next;
145
- }
146
- DirTreeDel(tmpde1);
147
- return cnt;
148
- }
149
-
150
- public I64 Zip(U8 *files_find_mask="*",U8 *fu_flags=NULL)
151
- {//Compress files by moving to .Z filename.
152
- U8 *st;
153
- CDirEntry *tmpde,*tmpde1;
154
- I64 res=0,fuf_flags=0;
155
- ScanFlags(&fuf_flags,Define("ST_FILE_UTIL_FLAGS"),"+r+f+F+O");
156
- ScanFlags(&fuf_flags,Define("ST_FILE_UTIL_FLAGS"),fu_flags);
157
- tmpde=tmpde1=FilesFind(files_find_mask,fuf_flags);
158
- while (tmpde) {
159
- if (!IsDotZ(tmpde->full_name)) {
160
- st=MStrPrint("%s.Z",tmpde->full_name);
161
- res+=Move(tmpde->full_name,st);
162
- Free(st);
163
- }
164
- tmpde=tmpde->next;
165
- }
166
- DirTreeDel(tmpde1);
167
- return res;
168
- }
169
-
170
- public I64 Unzip(U8 *files_find_mask="*.Z",U8 *fu_flags=NULL)
171
- {//Uncompress files by moving to not .Z filename.
172
- //You don't have to do this for normal operation.
173
- //It automatically unzips ".Z" files.
174
- U8 *st;
175
- CDirEntry *tmpde,*tmpde1;
176
- I64 res=0,fuf_flags=0;
177
- ScanFlags(&fuf_flags,Define("ST_FILE_UTIL_FLAGS"),"+r+f+F+O");
178
- ScanFlags(&fuf_flags,Define("ST_FILE_UTIL_FLAGS"),fu_flags);
179
- tmpde=tmpde1=FilesFind(files_find_mask,fuf_flags);
180
- while (tmpde) {
181
- if (IsDotZ(tmpde->full_name)) {
182
- st=StrNew(tmpde->full_name);
183
- StrLastRem(st,".");
184
- res+=Move(tmpde->full_name,st);
185
- Free(st);
186
- }
187
- tmpde=tmpde->next;
188
- }
189
- DirTreeDel(tmpde1);
190
- return res;
191
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:d78cf30e58aabc4638532f6504e0eeb9879deafe4a6d9e00ea3ffc7836ded98d
3
+ size 5093
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/ABlkDev/ChkDsk.HC CHANGED
@@ -1,444 +1,3 @@
1
- #help_index "Info;File/Cmd Line (Typically);Cmd Line (Typically)"
2
- Bool ChkDskConfirm(Bool *_fix,Bool *_confirm)
3
- {
4
- if (*_fix && *_confirm) {
5
- "Fix ";
6
- if (!YorN)
7
- *_fix=FALSE;
8
- *_confirm=FALSE;
9
- }
10
- return *_fix;
11
- }
12
-
13
- I64 RedSeaChkDskLst(CDrv *dv,CDirEntry *tmpde1,
14
- U8 *bits,U8 *bits2,I64 size,I64 bpc)
15
- {
16
- CDirEntry *tmpde2;
17
- I64 i,j,errs=0;
18
- while (tmpde1) {
19
- tmpde2=tmpde1->next;
20
- if (tmpde1->attr & RS_ATTR_DIR && tmpde1->sub)
21
- errs+=RedSeaChkDskLst(dv,tmpde1->sub,bits,bits2,size,bpc);
22
- j=(tmpde1->size+bpc-1)/bpc;
23
- for (i=0;i<j;i++) {
24
- if (i+tmpde1->cluster-dv->data_area>size) {
25
- PrintErr("Invalid Cluster:%s Cluster:%X\n",tmpde1->full_name,
26
- i+tmpde1->cluster);
27
- errs++;
28
- break;
29
- }
30
- if (LBts(bits,i+tmpde1->cluster-dv->data_area)) {
31
- PrintErr("Dbl Alloc:%s Cluster:%X\n",tmpde1->full_name,
32
- i+tmpde1->cluster);
33
- errs++;
34
- }
35
- if (!LBtr(bits2,i+tmpde1->cluster-dv->data_area)) {
36
- PrintErr("UnAlloc:%s Cluster:%X\n",tmpde1->full_name,
37
- i+tmpde1->cluster);
38
- errs++;
39
- }
40
- }
41
- DirEntryDel(tmpde1);
42
- tmpde1=tmpde2;
43
- }
44
- return errs;
45
- }
46
-
47
- I64 RedSeaChkDsk(U8 drv_let,Bool *_fix,Bool *_confirm)
48
- {
49
- I64 i,j,bpc,size,errs=0;
50
- CDrv *dv=Let2Drv(drv_let),*old_dv=Fs->cur_dv;
51
- U8 *files_find_mask=MStrPrint("%c:/*",Drv2Let(dv)),
52
- *old_dir=StrNew(Fs->cur_dir),
53
- *bits,*bits2;
54
- CDirEntry *ptr,*ptr2;
55
-
56
- Drv(drv_let);
57
- "Scanning...\n";
58
- size=(dv->size-(dv->data_area-dv->drv_offset))/dv->spc;
59
- bpc=dv->spc<<BLK_SIZE_BITS;
60
- bits=CAlloc((size+7)>>3);
61
- bits2=CAlloc((size+7)>>3+BLK_SIZE);
62
- RBlks(dv,bits2,dv->fat1,((size+7)>>3+BLK_SIZE-1)>>BLK_SIZE_BITS);
63
-
64
- //Get Root Dir size
65
- ptr2=MAlloc(bpc);
66
- RBlks(dv,ptr2,dv->root_cluster,1);
67
- ptr=ptr2(U8 *)-offset(CDirEntry.start);
68
- j=(ptr->size+bpc-1)/bpc;
69
- Free(ptr2);
70
-
71
- for (i=0;i<j;i++) {
72
- if (i+dv->root_cluster-dv->data_area>size) {
73
- PrintErr("Invalid Cluster: RootDir Cluster:%X\n",i+dv->root_cluster);
74
- errs++;
75
- break;
76
- }
77
- if (LBts(bits,i+dv->root_cluster-dv->data_area)) {
78
- PrintErr("Dbl Alloc: RootDir Cluster:%X\n",i+dv->root_cluster);
79
- errs++;
80
- }
81
- if (!LBtr(bits2,i+dv->root_cluster-dv->data_area)) {
82
- PrintErr("UnAlloc: RootDir Cluster:%X\n",i+dv->root_cluster);
83
- errs++;
84
- }
85
- }
86
-
87
- errs+=RedSeaChkDskLst(dv,FilesFind(files_find_mask,FUF_RECURSE),
88
- bits,bits2,size,bpc);
89
- for (i=1;i<size;i++)
90
- if (Bt(bits2,i)) {
91
- PrintWarn("Shouldn't Alloc Cluster:%0X\n",i+dv->data_area);
92
- errs++;
93
- if (ChkDskConfirm(_fix,_confirm))
94
- RedSeaFreeClusters(dv,i+dv->data_area,1);
95
- }
96
-
97
- Free(files_find_mask);
98
- Free(bits);
99
- Free(bits2);
100
- Drv(Drv2Let(old_dv));
101
- Cd(old_dir);
102
- Free(old_dir);
103
- return errs;
104
- }
105
-
106
- I64 FAT32ChkDskLst(CDrv *dv,CDirEntry *tmpde1,
107
- U8 *bits,U32 *bits2,I64 size,I64 bpc)
108
- {
109
- CDirEntry *tmpde2;
110
- I64 i,c,errs=0;
111
- while (tmpde1) {
112
- tmpde2=tmpde1->next;
113
- if (tmpde1->attr & RS_ATTR_DIR && tmpde1->sub)
114
- errs+=FAT32ChkDskLst(dv,tmpde1->sub,bits,bits2,size,bpc);
115
- i=0;
116
- c=tmpde1->cluster;
117
- while (0<c<0x0FFFFFF8) {
118
- if (c>size) {
119
- PrintErr("Invalid Cluster:%s Cluster:%X\n",tmpde1->full_name,c);
120
- errs++;
121
- break;
122
- }
123
- if (LBts(bits,c)) {
124
- PrintErr("Dbl Alloc:%s Cluster:%X\n",tmpde1->full_name,c);
125
- errs++;
126
- }
127
- if (!bits2[c]) {
128
- PrintErr("UnAlloc:%s Cluster:%X\n",tmpde1->full_name,c);
129
- errs++;
130
- } else
131
- bits2[c]=0;
132
- c=ClusterNumNext(dv,c);
133
- i++;
134
- }
135
- if (!(tmpde1->attr & RS_ATTR_DIR)) {
136
- i*=bpc;
137
- if (tmpde1->size>i) {
138
- PrintErr("Alloced File Too Short:%s\n",tmpde1->full_name);
139
- errs++;
140
- }
141
- if (i>tmpde1->size+bpc-1) {
142
- PrintWarn("Alloced File Too Long:%s\n",tmpde1->full_name);
143
- errs++;
144
- }
145
- }
146
- DirEntryDel(tmpde1);
147
- tmpde1=tmpde2;
148
- }
149
- return errs;
150
- }
151
-
152
- I64 FAT32ChkDsk(U8 drv_let,Bool *_fix,Bool *_confirm)
153
- {
154
- I64 i,bpc,size,c,errs=0;
155
- CDrv *dv=Let2Drv(drv_let),*old_dv=Fs->cur_dv;
156
- U8 *files_find_mask=MStrPrint("%c:/*",Drv2Let(dv)),
157
- *old_dir=StrNew(Fs->cur_dir),
158
- *bits;
159
- U32 *bits2;
160
- Drv(drv_let);
161
- "Scanning...\n";
162
- size=(dv->size-(dv->data_area-dv->drv_offset))/dv->spc;
163
- bpc=dv->spc<<BLK_SIZE_BITS;
164
- bits=CAlloc((size+7)>>3);
165
- bits2=CAlloc(size*4+BLK_SIZE);
166
- RBlks(dv,bits2,dv->fat1,(size*4+BLK_SIZE-1)>>BLK_SIZE_BITS);
167
-
168
- c=dv->root_cluster;
169
- while (0<c<0x0FFFFFF8) {
170
- if (c>size) {
171
- PrintErr("Invalid Cluster: RootDir Cluster:%X\n",c);
172
- errs++;
173
- break;
174
- }
175
- if (LBts(bits,c)) {
176
- PrintErr("Dbl Alloc: RootDir Cluster:%X\n",c);
177
- errs++;
178
- }
179
- if (!bits2[c]) {
180
- PrintErr("UnAlloc: RootDir Cluster:%X\n",c);
181
- errs++;
182
- } else
183
- bits2[c]=0;
184
- c=ClusterNumNext(dv,c);
185
- }
186
-
187
- errs+=FAT32ChkDskLst(dv,FilesFind(files_find_mask,FUF_RECURSE),
188
- bits,bits2,size,bpc);
189
-
190
- bits2[1]=0; //See $LK,"FAT32Fmt",A="MN:FAT32Fmt"$()
191
- for (i=1;i<size;i++)
192
- if (bits2[i]) {
193
- PrintWarn("Shouldn't Alloc Cluster:%0X\n",i);
194
- errs++;
195
- if (ChkDskConfirm(_fix,_confirm))
196
- FAT32FreeClusters(dv,i);
197
- }
198
- Free(files_find_mask);
199
- Free(bits);
200
- Free(bits2);
201
- Drv(Drv2Let(old_dv));
202
- Cd(old_dir);
203
- Free(old_dir);
204
- return errs;
205
- }
206
-
207
- public I64 ChkDsk(U8 drv_let=0,Bool fix=FALSE,Bool confirm=TRUE)
208
- {//Check disk for allocation errors and, optionally, fix.
209
- //You probably want to reformat and reinstall.
210
- I64 errs=0;
211
- CDrv *dv=Let2Drv(drv_let);
212
- switch (dv->fs_type) {
213
- case FSt_REDSEA:
214
- errs=RedSeaChkDsk(drv_let,&fix,&confirm);
215
- break;
216
- case FSt_FAT32:
217
- errs=FAT32ChkDsk(drv_let,&fix,&confirm);
218
- break;
219
- default:
220
- PrintErr("File System Not Supported\n");
221
- }
222
- if (errs) {
223
- if (fix)
224
- "It might be a little better. ";
225
- "Copy files to another partition or CD/DVD, "
226
- "reformat, and copy back. "
227
- "Or, copy from a back-up.\n";
228
- }
229
- return errs;
230
- }
231
-
232
- U0 RedSeaDrvView(U8 drv_let=0)
233
- {
234
- CDrv *dv=Let2Drv(drv_let);
235
- I64 lohi,c1,i,x,y,l=(GR_HEIGHT-3*FONT_HEIGHT)*(GR_WIDTH-FONT_WIDTH<<1),
236
- s=dv->size+dv->drv_offset-dv->data_area;
237
- U8 *bitmap;
238
- CDC *dc=DCAlias;
239
-
240
- SettingsPush; //See $LK,"SettingsPush",A="MN:SettingsPush"$
241
- WinMax;
242
- WinBorder(ON);
243
- DocCursor;
244
- DocClear;
245
- DCFill;
246
- try {
247
- i=((s+7)>>3+BLK_SIZE-1)>>BLK_SIZE_BITS;
248
- bitmap=MAlloc(i<<BLK_SIZE_BITS);
249
- RBlks(dv,bitmap,dv->fat1,i);
250
- i=0;
251
- for (y=0;y<GR_HEIGHT-3*FONT_HEIGHT;y++) {
252
- if (ScanKey)
253
- break;
254
- for (x=0;x<GR_WIDTH-FONT_WIDTH<<1;x++) {
255
- lohi=i*s;
256
- c1=lohi/l;
257
- if (Bt(bitmap,c1))
258
- dc->color=ROP_XOR+BLUE^TRANSPARENT;
259
- else
260
- dc->color=ROP_XOR+WHITE^TRANSPARENT;
261
- GrPlot(dc,x,y);
262
- i++;
263
- }
264
- }
265
- Free(bitmap);
266
- } catch
267
- DrvUnlock(dv);
268
- GetChar;
269
-
270
- SettingsPop;
271
- DCFill;
272
- DCDel(dc);
273
- }
274
- U0 FAT32DrvView(U8 drv_let=0)
275
- {
276
- CDrv *dv=Let2Drv(drv_let);
277
- I64 lohi,c1,i,x,y,l=(GR_HEIGHT-3*FONT_HEIGHT)*(GR_WIDTH-FONT_WIDTH<<1),
278
- s=(dv->size+dv->spc-1)/dv->spc-(2+dv->data_area-dv->drv_offset);
279
- U32 *bitmap;
280
- CDC *dc=DCAlias;
281
-
282
- SettingsPush; //See $LK,"SettingsPush",A="MN:SettingsPush"$
283
- WinMax;
284
- WinBorder(ON);
285
- DocCursor;
286
- DocClear;
287
- DCFill;
288
- try {
289
- i=(s*4+BLK_SIZE-1)>>BLK_SIZE_BITS;
290
- bitmap=MAlloc(i<<BLK_SIZE_BITS);
291
- RBlks(dv,bitmap,dv->fat1,i);
292
- i=0;
293
- for (y=0;y<GR_HEIGHT-3*FONT_HEIGHT;y++) {
294
- if (ScanKey)
295
- break;
296
- for (x=0;x<GR_WIDTH-FONT_WIDTH<<1;x++) {
297
- lohi=i*s;
298
- c1=lohi/l;
299
- if (bitmap[c1])
300
- dc->color=ROP_XOR+BLUE^TRANSPARENT;
301
- else
302
- dc->color=ROP_XOR+WHITE^TRANSPARENT;
303
- GrPlot(dc,x,y);
304
- i++;
305
- }
306
- }
307
- Free(bitmap);
308
- } catch
309
- DrvUnlock(dv);
310
- GetChar;
311
-
312
- SettingsPop;
313
- DCFill;
314
- DCDel(dc);
315
- }
316
- public U0 DrvView(U8 drv_let=0)
317
- {//Drive view. Graph the allocation map's fragmentation.
318
- CDrv *dv=Let2Drv(drv_let),*old_dv=Fs->cur_dv;
319
- Drv(drv_let);
320
- switch (dv->fs_type) {
321
- case FSt_REDSEA:
322
- RedSeaDrvView(drv_let);
323
- break;
324
- case FSt_FAT32:
325
- FAT32DrvView(drv_let);
326
- break;
327
- default:
328
- PrintErr("File System Not Supported\n");
329
- }
330
- Drv(Drv2Let(old_dv));
331
- }
332
-
333
- public U0 DskView(U8 drv_let=0)
334
- {//Disk view. Pie chart of partition sizes.
335
- I64 i,j,attr,
336
- h=Fs->pix_width,
337
- v=Fs->pix_height,
338
- radius;
339
- CDrv *dv;
340
- CBlkDev *bd=Let2BlkDev(drv_let);
341
- CDC *dc=DCAlias;
342
- F64 sect_start,sect_end;
343
-
344
- SettingsPush; //See $LK,"SettingsPush",A="MN:SettingsPush"$
345
- DocCursor;
346
- DocClear;
347
- DCFill;
348
- if (h<v)
349
- radius=0.4*h;
350
- else
351
- radius=0.4*v;
352
- dc->color=BLACK;
353
- GrCircle(dc,h>>1,v>>1,radius);
354
-
355
- j=1;
356
- for (i=0;i<DRVS_NUM;i++) {
357
- dv=&blkdev.drvs[i];
358
- if (bd==dv->bd && dv->fs_type) {
359
- sect_start=-(dv->drv_offset*2*�/(bd->max_blk+1));
360
- sect_end =-((dv->drv_offset+dv->size)*2*�/(bd->max_blk+1));
361
- dc->color=BLACK;
362
- GrLine(dc,h>>1,v>>1,
363
- h>>1+radius*Cos(sect_start),
364
- v>>1+radius*Sin(sect_start));
365
- GrLine(dc,h>>1,v>>1,
366
- h>>1+radius*Cos(sect_end),
367
- v>>1+radius*Sin(sect_end));
368
-
369
- attr=DrvTextAttrGet(Drv2Let(dv));
370
- dc->color=attr&15;
371
- GrPrint(dc,0,v-FONT_HEIGHT*j,"%C %-8Z",Drv2Let(dv),
372
- dv->fs_type,"ST_DRV_TYPES");
373
- dc->color.c1=attr>>4;
374
- dc->color|=ROPF_DITHER;
375
- GrFloodFill(dc,
376
- h>>1+(radius-4)*Cos((sect_start+sect_end)/2),
377
- v>>1+(radius-4)*Sin((sect_start+sect_end)/2),FALSE);
378
- j++;
379
- }
380
- }
381
-
382
- GetChar(,FALSE);
383
- SettingsPop;
384
- DCFill;
385
- DCDel(dc);
386
- }
387
-
388
- I64 RedSeaUnusedDrvSpace(U8 drv_let=0)
389
- {
390
- CDrv *dv=Let2Drv(drv_let);
391
- I64 res=0,i,l;
392
- U8 *bitmap;
393
- try {
394
- l=dv->size+dv->drv_offset-dv->data_area;
395
- i=((l+7)>>3+BLK_SIZE-1)>>BLK_SIZE_BITS;
396
- bitmap=MAlloc(i<<BLK_SIZE_BITS);
397
- RBlks(dv,bitmap,dv->fat1,i);
398
- for (i=0;i<l;i++)
399
- if (!Bt(bitmap,i))
400
- res++;
401
- Free(bitmap);
402
- } catch
403
- DrvUnlock(dv);
404
- return res*BLK_SIZE*dv->spc;
405
- }
406
- I64 FAT32UnusedDrvSpace(U8 drv_let=0)
407
- {
408
- CDrv *dv=Let2Drv(drv_let);
409
- I64 res=0,i,l;
410
- U32 *bitmap;
411
- try {
412
- l=(dv->size+dv->spc-1)/dv->spc-(2+dv->data_area-dv->drv_offset);
413
- i=(l*4+BLK_SIZE-1)>>BLK_SIZE_BITS;
414
- bitmap=MAlloc(i<<BLK_SIZE_BITS);
415
- RBlks(dv,bitmap,dv->fat1,i);
416
- for (i=0;i<l;i++)
417
- if (!bitmap[i])
418
- res++;
419
- Free(bitmap);
420
- } catch
421
- DrvUnlock(dv);
422
- return res*BLK_SIZE*dv->spc;
423
- }
424
- public I64 UnusedDrvSpace(U8 drv_let=0)
425
- {//Returns unused size in bytes.
426
- CDrv *dv=Let2Drv(drv_let),*old_dv=Fs->cur_dv;
427
- U8 *old_dir=StrNew(Fs->cur_dir);
428
- I64 res=0;
429
- Drv(drv_let);
430
- switch (dv->fs_type) {
431
- case FSt_REDSEA:
432
- res=RedSeaUnusedDrvSpace(drv_let);
433
- break;
434
- case FSt_FAT32:
435
- res=FAT32UnusedDrvSpace(drv_let);
436
- break;
437
- default:
438
- PrintErr("File System Not Supported\n");
439
- }
440
- Drv(Drv2Let(old_dv));
441
- Cd(old_dir);
442
- Free(old_dir);
443
- return res;
444
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:82c57c13b0ab8f0177225f7031a59eaecce56e6c61179b0b517f97213a230a5f
3
+ size 10515
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/ABlkDev/DskChk.HC CHANGED
@@ -1,444 +1,3 @@
1
- #help_index "Info;File/Cmd Line (Typically);Cmd Line (Typically)"
2
- Bool ChkDskConfirm(Bool *_fix,Bool *_confirm)
3
- {
4
- if (*_fix && *_confirm) {
5
- "Fix ";
6
- if (!YorN)
7
- *_fix=FALSE;
8
- *_confirm=FALSE;
9
- }
10
- return *_fix;
11
- }
12
-
13
- I64 RedSeaChkDskLst(CDrv *dv,CDirEntry *tmpde1,
14
- U8 *bits,U8 *bits2,I64 size,I64 bpc)
15
- {
16
- CDirEntry *tmpde2;
17
- I64 i,j,errs=0;
18
- while (tmpde1) {
19
- tmpde2=tmpde1->next;
20
- if (tmpde1->attr & RS_ATTR_DIR && tmpde1->sub)
21
- errs+=RedSeaChkDskLst(dv,tmpde1->sub,bits,bits2,size,bpc);
22
- j=(tmpde1->size+bpc-1)/bpc;
23
- for (i=0;i<j;i++) {
24
- if (i+tmpde1->clus-dv->data_area>size) {
25
- PrintErr("Invalid Clus:%s Clus:%X\n",tmpde1->full_name,
26
- i+tmpde1->clus);
27
- errs++;
28
- break;
29
- }
30
- if (LBts(bits,i+tmpde1->clus-dv->data_area)) {
31
- PrintErr("Dbl Alloc:%s Clus:%X\n",tmpde1->full_name,
32
- i+tmpde1->clus);
33
- errs++;
34
- }
35
- if (!LBtr(bits2,i+tmpde1->clus-dv->data_area)) {
36
- PrintErr("UnAlloc:%s Clus:%X\n",tmpde1->full_name,
37
- i+tmpde1->clus);
38
- errs++;
39
- }
40
- }
41
- DirEntryDel(tmpde1);
42
- tmpde1=tmpde2;
43
- }
44
- return errs;
45
- }
46
-
47
- I64 RedSeaChkDsk(U8 drv_let,Bool *_fix,Bool *_confirm)
48
- {
49
- I64 i,j,bpc,size,errs=0;
50
- CDrv *dv=Let2Drv(drv_let),*old_dv=Fs->cur_dv;
51
- U8 *files_find_mask=MStrPrint("%c:/*",Drv2Let(dv)),
52
- *old_dir=StrNew(Fs->cur_dir),
53
- *bits,*bits2;
54
- CDirEntry *ptr,*ptr2;
55
-
56
- Drv(drv_let);
57
- "Scanning...\n";
58
- size=(dv->size-(dv->data_area-dv->drv_offset))/dv->spc;
59
- bpc=dv->spc<<BLK_SIZE_BITS;
60
- bits=CAlloc((size+7)>>3);
61
- bits2=CAlloc((size+7)>>3+BLK_SIZE);
62
- BlkRead(dv,bits2,dv->fat1,((size+7)>>3+BLK_SIZE-1)>>BLK_SIZE_BITS);
63
-
64
- //Get Root Dir size
65
- ptr2=MAlloc(bpc);
66
- BlkRead(dv,ptr2,dv->root_clus,1);
67
- ptr=ptr2(U8 *)-offset(CDirEntry.start);
68
- j=(ptr->size+bpc-1)/bpc;
69
- Free(ptr2);
70
-
71
- for (i=0;i<j;i++) {
72
- if (i+dv->root_clus-dv->data_area>size) {
73
- PrintErr("Invalid Clus: RootDir Clus:%X\n",i+dv->root_clus);
74
- errs++;
75
- break;
76
- }
77
- if (LBts(bits,i+dv->root_clus-dv->data_area)) {
78
- PrintErr("Dbl Alloc: RootDir Clus:%X\n",i+dv->root_clus);
79
- errs++;
80
- }
81
- if (!LBtr(bits2,i+dv->root_clus-dv->data_area)) {
82
- PrintErr("UnAlloc: RootDir Clus:%X\n",i+dv->root_clus);
83
- errs++;
84
- }
85
- }
86
-
87
- errs+=RedSeaChkDskLst(dv,FilesFind(files_find_mask,FUF_RECURSE),
88
- bits,bits2,size,bpc);
89
- for (i=1;i<size;i++)
90
- if (Bt(bits2,i)) {
91
- PrintWarn("Shouldn't Alloc Clus:%0X\n",i+dv->data_area);
92
- errs++;
93
- if (ChkDskConfirm(_fix,_confirm))
94
- RedSeaFreeClus(dv,i+dv->data_area,1);
95
- }
96
-
97
- Free(files_find_mask);
98
- Free(bits);
99
- Free(bits2);
100
- Drv(Drv2Let(old_dv));
101
- Cd(old_dir);
102
- Free(old_dir);
103
- return errs;
104
- }
105
-
106
- I64 FAT32ChkDskLst(CDrv *dv,CDirEntry *tmpde1,
107
- U8 *bits,U32 *bits2,I64 size,I64 bpc)
108
- {
109
- CDirEntry *tmpde2;
110
- I64 i,c,errs=0;
111
- while (tmpde1) {
112
- tmpde2=tmpde1->next;
113
- if (tmpde1->attr & RS_ATTR_DIR && tmpde1->sub)
114
- errs+=FAT32ChkDskLst(dv,tmpde1->sub,bits,bits2,size,bpc);
115
- i=0;
116
- c=tmpde1->clus;
117
- while (0<c<0x0FFFFFF8) {
118
- if (c>size) {
119
- PrintErr("Invalid Clus:%s Clus:%X\n",tmpde1->full_name,c);
120
- errs++;
121
- break;
122
- }
123
- if (LBts(bits,c)) {
124
- PrintErr("Dbl Alloc:%s Clus:%X\n",tmpde1->full_name,c);
125
- errs++;
126
- }
127
- if (!bits2[c]) {
128
- PrintErr("UnAlloc:%s Clus:%X\n",tmpde1->full_name,c);
129
- errs++;
130
- } else
131
- bits2[c]=0;
132
- c=ClusNumNext(dv,c);
133
- i++;
134
- }
135
- if (!(tmpde1->attr & RS_ATTR_DIR)) {
136
- i*=bpc;
137
- if (tmpde1->size>i) {
138
- PrintErr("Alloced File Too Short:%s\n",tmpde1->full_name);
139
- errs++;
140
- }
141
- if (i>tmpde1->size+bpc-1) {
142
- PrintWarn("Alloced File Too Long:%s\n",tmpde1->full_name);
143
- errs++;
144
- }
145
- }
146
- DirEntryDel(tmpde1);
147
- tmpde1=tmpde2;
148
- }
149
- return errs;
150
- }
151
-
152
- I64 FAT32ChkDsk(U8 drv_let,Bool *_fix,Bool *_confirm)
153
- {
154
- I64 i,bpc,size,c,errs=0;
155
- CDrv *dv=Let2Drv(drv_let),*old_dv=Fs->cur_dv;
156
- U8 *files_find_mask=MStrPrint("%c:/*",Drv2Let(dv)),
157
- *old_dir=StrNew(Fs->cur_dir),
158
- *bits;
159
- U32 *bits2;
160
- Drv(drv_let);
161
- "Scanning...\n";
162
- size=(dv->size-(dv->data_area-dv->drv_offset))/dv->spc;
163
- bpc=dv->spc<<BLK_SIZE_BITS;
164
- bits=CAlloc((size+7)>>3);
165
- bits2=CAlloc(size*4+BLK_SIZE);
166
- BlkRead(dv,bits2,dv->fat1,(size*4+BLK_SIZE-1)>>BLK_SIZE_BITS);
167
-
168
- c=dv->root_clus;
169
- while (0<c<0x0FFFFFF8) {
170
- if (c>size) {
171
- PrintErr("Invalid Clus: RootDir Clus:%X\n",c);
172
- errs++;
173
- break;
174
- }
175
- if (LBts(bits,c)) {
176
- PrintErr("Dbl Alloc: RootDir Clus:%X\n",c);
177
- errs++;
178
- }
179
- if (!bits2[c]) {
180
- PrintErr("UnAlloc: RootDir Clus:%X\n",c);
181
- errs++;
182
- } else
183
- bits2[c]=0;
184
- c=ClusNumNext(dv,c);
185
- }
186
-
187
- errs+=FAT32ChkDskLst(dv,FilesFind(files_find_mask,FUF_RECURSE),
188
- bits,bits2,size,bpc);
189
-
190
- bits2[1]=0; //See $LK,"FAT32Fmt",A="MN:FAT32Fmt"$()
191
- for (i=1;i<size;i++)
192
- if (bits2[i]) {
193
- PrintWarn("Shouldn't Alloc Clus:%0X\n",i);
194
- errs++;
195
- if (ChkDskConfirm(_fix,_confirm))
196
- FAT32FreeClus(dv,i);
197
- }
198
- Free(files_find_mask);
199
- Free(bits);
200
- Free(bits2);
201
- Drv(Drv2Let(old_dv));
202
- Cd(old_dir);
203
- Free(old_dir);
204
- return errs;
205
- }
206
-
207
- public I64 DskChk(U8 drv_let=0,Bool fix=FALSE,Bool confirm=TRUE)
208
- {//Check disk for allocation errors and, optionally, fix.
209
- //You probably want to reformat and reinstall.
210
- I64 errs=0;
211
- CDrv *dv=Let2Drv(drv_let);
212
- switch (dv->fs_type) {
213
- case FSt_REDSEA:
214
- errs=RedSeaChkDsk(drv_let,&fix,&confirm);
215
- break;
216
- case FSt_FAT32:
217
- errs=FAT32ChkDsk(drv_let,&fix,&confirm);
218
- break;
219
- default:
220
- PrintErr("File System Not Supported\n");
221
- }
222
- if (errs) {
223
- if (fix)
224
- "It might be a little better. ";
225
- "Copy files to another partition or CD/DVD, "
226
- "reformat, and copy back. "
227
- "Or, copy from a back-up.\n";
228
- }
229
- return errs;
230
- }
231
-
232
- U0 RedSeaDrvView(U8 drv_let=0)
233
- {
234
- CDrv *dv=Let2Drv(drv_let);
235
- I64 lohi,c1,i,x,y,l=(GR_HEIGHT-3*FONT_HEIGHT)*(GR_WIDTH-FONT_WIDTH<<1),
236
- s=dv->size+dv->drv_offset-dv->data_area;
237
- U8 *bitmap;
238
- CDC *dc=DCAlias;
239
-
240
- SettingsPush; //See $LK,"SettingsPush",A="MN:SettingsPush"$
241
- WinMax;
242
- WinBorder(ON);
243
- DocCursor;
244
- DocClear;
245
- DCFill;
246
- try {
247
- i=((s+7)>>3+BLK_SIZE-1)>>BLK_SIZE_BITS;
248
- bitmap=MAlloc(i<<BLK_SIZE_BITS);
249
- BlkRead(dv,bitmap,dv->fat1,i);
250
- i=0;
251
- for (y=0;y<GR_HEIGHT-3*FONT_HEIGHT;y++) {
252
- if (ScanKey)
253
- break;
254
- for (x=0;x<GR_WIDTH-FONT_WIDTH<<1;x++) {
255
- lohi=i*s;
256
- c1=lohi/l;
257
- if (Bt(bitmap,c1))
258
- dc->color=ROP_XOR+BLUE^TRANSPARENT;
259
- else
260
- dc->color=ROP_XOR+WHITE^TRANSPARENT;
261
- GrPlot(dc,x,y);
262
- i++;
263
- }
264
- }
265
- Free(bitmap);
266
- } catch
267
- DrvUnlock(dv);
268
- GetChar;
269
-
270
- SettingsPop;
271
- DCFill;
272
- DCDel(dc);
273
- }
274
- U0 FAT32DrvView(U8 drv_let=0)
275
- {
276
- CDrv *dv=Let2Drv(drv_let);
277
- I64 lohi,c1,i,x,y,l=(GR_HEIGHT-3*FONT_HEIGHT)*(GR_WIDTH-FONT_WIDTH<<1),
278
- s=(dv->size+dv->spc-1)/dv->spc-(2+dv->data_area-dv->drv_offset);
279
- U32 *bitmap;
280
- CDC *dc=DCAlias;
281
-
282
- SettingsPush; //See $LK,"SettingsPush",A="MN:SettingsPush"$
283
- WinMax;
284
- WinBorder(ON);
285
- DocCursor;
286
- DocClear;
287
- DCFill;
288
- try {
289
- i=(s*4+BLK_SIZE-1)>>BLK_SIZE_BITS;
290
- bitmap=MAlloc(i<<BLK_SIZE_BITS);
291
- BlkRead(dv,bitmap,dv->fat1,i);
292
- i=0;
293
- for (y=0;y<GR_HEIGHT-3*FONT_HEIGHT;y++) {
294
- if (ScanKey)
295
- break;
296
- for (x=0;x<GR_WIDTH-FONT_WIDTH<<1;x++) {
297
- lohi=i*s;
298
- c1=lohi/l;
299
- if (bitmap[c1])
300
- dc->color=ROP_XOR+BLUE^TRANSPARENT;
301
- else
302
- dc->color=ROP_XOR+WHITE^TRANSPARENT;
303
- GrPlot(dc,x,y);
304
- i++;
305
- }
306
- }
307
- Free(bitmap);
308
- } catch
309
- DrvUnlock(dv);
310
- GetChar;
311
-
312
- SettingsPop;
313
- DCFill;
314
- DCDel(dc);
315
- }
316
- public U0 DrvView(U8 drv_let=0)
317
- {//Drive view. Graph the allocation map's fragmentation.
318
- CDrv *dv=Let2Drv(drv_let),*old_dv=Fs->cur_dv;
319
- Drv(drv_let);
320
- switch (dv->fs_type) {
321
- case FSt_REDSEA:
322
- RedSeaDrvView(drv_let);
323
- break;
324
- case FSt_FAT32:
325
- FAT32DrvView(drv_let);
326
- break;
327
- default:
328
- PrintErr("File System Not Supported\n");
329
- }
330
- Drv(Drv2Let(old_dv));
331
- }
332
-
333
- public U0 DskView(U8 drv_let=0)
334
- {//Disk view. Pie chart of partition sizes.
335
- I64 i,j,attr,
336
- h=Fs->pix_width,
337
- v=Fs->pix_height,
338
- radius;
339
- CDrv *dv;
340
- CBlkDev *bd=Let2BlkDev(drv_let);
341
- CDC *dc=DCAlias;
342
- F64 sect_start,sect_end;
343
-
344
- SettingsPush; //See $LK,"SettingsPush",A="MN:SettingsPush"$
345
- DocCursor;
346
- DocClear;
347
- DCFill;
348
- if (h<v)
349
- radius=0.4*h;
350
- else
351
- radius=0.4*v;
352
- dc->color=BLACK;
353
- GrCircle(dc,h>>1,v>>1,radius);
354
-
355
- j=1;
356
- for (i=0;i<DRVS_NUM;i++) {
357
- dv=&blkdev.drvs[i];
358
- if (bd==dv->bd && dv->fs_type) {
359
- sect_start=-(dv->drv_offset*2*�/(bd->max_blk+1));
360
- sect_end =-((dv->drv_offset+dv->size)*2*�/(bd->max_blk+1));
361
- dc->color=BLACK;
362
- GrLine(dc,h>>1,v>>1,
363
- h>>1+radius*Cos(sect_start),
364
- v>>1+radius*Sin(sect_start));
365
- GrLine(dc,h>>1,v>>1,
366
- h>>1+radius*Cos(sect_end),
367
- v>>1+radius*Sin(sect_end));
368
-
369
- attr=DrvTextAttrGet(Drv2Let(dv));
370
- dc->color=attr&15;
371
- GrPrint(dc,0,v-FONT_HEIGHT*j,"%C %-8Z",Drv2Let(dv),
372
- dv->fs_type,"ST_DRV_TYPES");
373
- dc->color.c1=attr>>4;
374
- dc->color|=ROPF_DITHER;
375
- GrFloodFill(dc,
376
- h>>1+(radius-4)*Cos((sect_start+sect_end)/2),
377
- v>>1+(radius-4)*Sin((sect_start+sect_end)/2),FALSE);
378
- j++;
379
- }
380
- }
381
-
382
- GetChar(,FALSE);
383
- SettingsPop;
384
- DCFill;
385
- DCDel(dc);
386
- }
387
-
388
- I64 RedSeaUnusedDrvSpace(U8 drv_let=0)
389
- {
390
- CDrv *dv=Let2Drv(drv_let);
391
- I64 res=0,i,l;
392
- U8 *bitmap;
393
- try {
394
- l=dv->size+dv->drv_offset-dv->data_area;
395
- i=((l+7)>>3+BLK_SIZE-1)>>BLK_SIZE_BITS;
396
- bitmap=MAlloc(i<<BLK_SIZE_BITS);
397
- BlkRead(dv,bitmap,dv->fat1,i);
398
- for (i=0;i<l;i++)
399
- if (!Bt(bitmap,i))
400
- res++;
401
- Free(bitmap);
402
- } catch
403
- DrvUnlock(dv);
404
- return res*BLK_SIZE*dv->spc;
405
- }
406
- I64 FAT32UnusedDrvSpace(U8 drv_let=0)
407
- {
408
- CDrv *dv=Let2Drv(drv_let);
409
- I64 res=0,i,l;
410
- U32 *bitmap;
411
- try {
412
- l=(dv->size+dv->spc-1)/dv->spc-(2+dv->data_area-dv->drv_offset);
413
- i=(l*4+BLK_SIZE-1)>>BLK_SIZE_BITS;
414
- bitmap=MAlloc(i<<BLK_SIZE_BITS);
415
- BlkRead(dv,bitmap,dv->fat1,i);
416
- for (i=0;i<l;i++)
417
- if (!bitmap[i])
418
- res++;
419
- Free(bitmap);
420
- } catch
421
- DrvUnlock(dv);
422
- return res*BLK_SIZE*dv->spc;
423
- }
424
- public I64 DrvUnused(U8 drv_let=0)
425
- {//Returns unused size in bytes.
426
- CDrv *dv=Let2Drv(drv_let),*old_dv=Fs->cur_dv;
427
- U8 *old_dir=StrNew(Fs->cur_dir);
428
- I64 res=0;
429
- Drv(drv_let);
430
- switch (dv->fs_type) {
431
- case FSt_REDSEA:
432
- res=RedSeaUnusedDrvSpace(drv_let);
433
- break;
434
- case FSt_FAT32:
435
- res=FAT32UnusedDrvSpace(drv_let);
436
- break;
437
- default:
438
- PrintErr("File System Not Supported\n");
439
- }
440
- Drv(Drv2Let(old_dv));
441
- Cd(old_dir);
442
- Free(old_dir);
443
- return res;
444
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:a6ad79956be3cd6858f3a544244fa8d982d14ce4507de943ac61a5b7bd299c75
3
+ size 10411
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/ABlkDev/DskPrt.HC CHANGED
@@ -1,167 +1,3 @@
1
- #help_index "Install;File/Cmd Line (Typically);Cmd Line (Typically)"
2
-
3
- #define ROUND_DRV_TO (63*255)
4
- #define DRV_HEADER 63
5
-
6
- class CPlannedDrv
7
- {
8
- CPlannedDrv *next,*last;
9
- I64 size;
10
- Bool pri;
11
- };
12
-
13
- public I64 DskPrt(U8 drv_let=0,...)
14
- {/*Partition the disk containing partition drv_let.
15
-
16
- drv_let=0 means add new drive that is not already mounted.
17
-
18
- >DskPrt('C',0.5,0.25,0.25); //Make three. 50% C, 25% D, 25% E, round-up to blk.
19
-
20
- */
21
- CBlkDev *bd;
22
- CPlannedDrv head,*tmppp;
23
- CMasterBoot mbr;
24
- Bool pri=TRUE;
25
- I64 ext_base,drv_let2,pri_cnt=0,i,start_offset,offset,
26
- total,remaining,cur_arg=0;
27
- "This command does not play well\n"
28
- "with other operating systems.\n"
29
- "You really should use another\n"
30
- "operating system's partitioner.\n"
31
- "If you use this, it may, in fact,\n"
32
- "make your hard drive impossible\n"
33
- "to repartition with other operating\n"
34
- "until you set block zero to zero\n"
35
- "with $$LK,\"BootMHDZero\",\"MN:BootMHDZero\"$$()\n\n\n"
36
- "Continue";
37
- if (argc<=cur_arg && !YorN)
38
- return 0;
39
- '\n';
40
-
41
- if (drv_let && !Let2BlkDev(drv_let,FALSE))
42
- drv_let=0;
43
- if (!drv_let && !(drv_let=Mount(TRUE)) ||
44
- !(bd=Let2BlkDev(drv_let,FALSE)) || bd->type!=BDT_ATA)
45
- return 0;
46
-
47
- total=bd->max_blk+1;
48
- QueInit(&head);
49
- drv_let2=bd->first_drv_let;
50
- remaining=FloorU64(bd->max_blk+1,ROUND_DRV_TO);
51
- while (FloorU64(remaining,ROUND_DRV_TO)>=ROUND_DRV_TO) {
52
- tmppp=MAlloc(sizeof(CPlannedDrv));
53
- do {
54
- "$$RED$$Partition %C$$FG$$\n",drv_let2;
55
- tmppp->pri=FALSE;
56
- if (pri) {
57
- "Primary Partition";
58
- if (argc>cur_arg || YorN) {
59
- pri_cnt++;
60
- tmppp->pri=TRUE;
61
- if (pri_cnt==3)
62
- pri=FALSE;
63
- } else
64
- pri=FALSE;
65
- }
66
- "\nBlocks Remaining:%d (0x%X)\n",
67
- remaining-DRV_HEADER,remaining-DRV_HEADER;
68
- if (argc>cur_arg)
69
- tmppp->size=MinI64(CeilU64(MaxI64(remaining,DRV_HEADER),ROUND_DRV_TO),
70
- CeilU64(argv[cur_arg++](F64)*total,ROUND_DRV_TO));
71
- else
72
- tmppp->size=CeilU64(GetI64("Size in Blocks :",
73
- remaining-DRV_HEADER)+DRV_HEADER,ROUND_DRV_TO);
74
- } while (!(ROUND_DRV_TO<=tmppp->size<=FloorU64(remaining,ROUND_DRV_TO)));
75
- QueIns(tmppp,head.last);
76
- remaining-=tmppp->size;
77
- drv_let2++;
78
- }
79
-
80
- "\n\n!!! Repartition Drive !!!\n\n";
81
- tmppp=head.next;
82
- drv_let2=bd->first_drv_let;
83
- while (tmppp!=&head) {
84
- "Drive %C:%08X ",drv_let2,tmppp->size;
85
- if (tmppp->pri)
86
- "Primary\n";
87
- else
88
- "Logical\n";
89
- tmppp=tmppp->next;
90
- drv_let2++;
91
- }
92
- if (!argc && !AreYouSure)
93
- goto pd_done;
94
-
95
- remaining=FloorU64(bd->max_blk+1,ROUND_DRV_TO)-ROUND_DRV_TO;
96
- tmppp=head.next;
97
- MemSet(&mbr,0,BLK_SIZE);
98
- mbr.signature=0xAA55;
99
- offset=0;
100
- for (i=0;i<pri_cnt;i++) {
101
- mbr.p[i].active=0x80;
102
- mbr.p[i].start_head=0;
103
- mbr.p[i].start_cyl=0x101;
104
- mbr.p[i].type=1; //Will get set different.
105
- mbr.p[i].end_head=0xFE;
106
- mbr.p[i].end_cyl=0xFFFF;
107
- mbr.p[i].offset=DRV_HEADER+offset;
108
- mbr.p[i].size=tmppp->size-DRV_HEADER;
109
- offset+=tmppp->size;
110
- remaining-=tmppp->size;
111
- tmppp=tmppp->next;
112
- }
113
- if (!i) i++;
114
- if (tmppp!=&head) {
115
- mbr.p[i].active=0x80;
116
- mbr.p[i].start_head=0;
117
- mbr.p[i].start_cyl=0x101;
118
- mbr.p[i].type=0xF;
119
- mbr.p[i].end_head=0xFE;
120
- mbr.p[i].end_cyl=0xFFFF;
121
- mbr.p[i].offset=offset;
122
- mbr.p[i].size=remaining;
123
- ext_base=offset;
124
- }
125
- ATAWriteBlks(bd,&mbr,0,1);
126
-
127
- while (tmppp!=&head) {
128
- start_offset=offset;
129
- MemSet(&mbr,0,BLK_SIZE);
130
- mbr.signature=0xAA55;
131
-
132
- mbr.p[0].active=0x80;
133
- mbr.p[0].start_head=1;
134
- mbr.p[0].start_cyl=0x101;
135
- mbr.p[0].type=1; //Will get set different.
136
- mbr.p[0].end_head=0xFE;
137
- mbr.p[0].end_cyl=0xFFFF;
138
- mbr.p[0].offset=DRV_HEADER;
139
- mbr.p[0].size=tmppp->size-DRV_HEADER;
140
- offset+=tmppp->size;
141
- tmppp=tmppp->next;
142
- if (tmppp!=&head) {
143
- mbr.p[1].active=0x80;
144
- mbr.p[1].start_head=0;
145
- mbr.p[1].start_cyl=0x101;
146
- mbr.p[1].type=5;
147
- mbr.p[1].end_head=0xFE;
148
- mbr.p[1].end_cyl=0xFFFF;
149
- mbr.p[1].offset=offset-ext_base;
150
- mbr.p[1].size=tmppp->size;
151
- }
152
- ATAWriteBlks(bd,&mbr,start_offset,1);
153
- }
154
-
155
- bd->flags&=~(BDF_INITIALIZED | BDF_INIT_IN_PROGRESS);
156
- BlkDevAdd(bd,,FALSE,TRUE);
157
- for (i=bd->first_drv_let;i<drv_let2;i++)
158
- Fmt(i,,FALSE);
159
-
160
- pd_done:
161
- while (head.next!=&head) {
162
- tmppp=head.next;
163
- QueRem(tmppp);
164
- Free(tmppp);
165
- }
166
- return total;
167
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:a9b59f979b7e30f079c996c351cc616daa09a94be0d46b22e6ba5d6e5c92df21
3
+ size 4323
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/ABlkDev/FileMgr.HC CHANGED
@@ -1,791 +1,3 @@
1
- #help_index "DolDoc/Output;StdOut/DolDoc"
2
- U0 DirFileDoc(CDoc *doc,CDirEntry *tmpde)
3
- {
4
- while (tmpde) {
5
- if (tmpde->attr & RS_ATTR_DIR) {
6
- tmpde->user_data=DocPrint(doc,"$$TR,\"%s\",U=0x%X$$",tmpde->name,tmpde);
7
- DocPrint(doc,"\n$$ID,+2$$");
8
- if (tmpde->sub)
9
- DirFileDoc(doc,tmpde->sub);
10
- DocPrint(doc,"$$ID,-2$$");
11
- } else {
12
- tmpde->user_data=DocPrint(doc,"$$MU,\"%s\",U=0x%X$$",tmpde->name,tmpde);
13
- DocPrint(doc,"\n");
14
- }
15
- tmpde=tmpde->next;
16
- }
17
- }
18
-
19
- #help_index "File/Cmd Line (Typically);Cmd Line (Typically)"
20
-
21
- #define FM_NORMAL 0
22
- #define FM_PICK_FILE 1
23
- #define FM_PICK_DIR 2
24
-
25
- class CFMUncollapsedLst
26
- {
27
- CFMUncollapsedLst *next;
28
- U8 *name;
29
- };
30
-
31
- CFMUncollapsedLst *FMCollectUncollapsedLst(CDoc *doc)
32
- {
33
- CDocEntry *doc_e=doc->head.next;
34
- CFMUncollapsedLst *res=NULL,*tmpc;
35
- CDirEntry *tmpde;
36
- while (doc_e!=doc) {
37
- if (doc_e->type_u8==DOCT_TREE) {
38
- if (!(doc_e->de_flags&DOCEF_CHECKED_COLLAPSED)) {
39
- if (tmpde=doc_e->user_data) {
40
- tmpc=MAlloc(sizeof(CFMUncollapsedLst));
41
- tmpc->next=res;
42
- res=tmpc;
43
- tmpc->name=StrNew(tmpde->full_name);
44
- }
45
- }
46
- }
47
- doc_e=doc_e->next;
48
- }
49
- return res;
50
- }
51
-
52
- U0 FMMarkUncollapsed(CDoc *doc,CFMUncollapsedLst *tmpc,
53
- U8 *cur_entry,U8 *next_entry)
54
- {
55
- CDocEntry *doc_e=doc->head.next;
56
- CFMUncollapsedLst *tmpc1;
57
- CDirEntry *tmpde;
58
- while (doc_e!=doc) {
59
- if (doc_e->type_u8==DOCT_TREE) {
60
- tmpde=doc_e->user_data;
61
- tmpc1=tmpc;
62
- while (tmpc1) {
63
- if (!StrCmp(tmpc1->name,tmpde->full_name)) {
64
- doc_e->de_flags&=~DOCEF_CHECKED_COLLAPSED;
65
- break;
66
- }
67
- tmpc1=tmpc1->next;
68
- }
69
- if (cur_entry) {
70
- if (!StrNCmp(cur_entry,tmpde->full_name,StrLen(tmpde->full_name))) {
71
- doc->cur_entry=doc_e;
72
- if (StrLen(tmpde->full_name)==StrLen(cur_entry))
73
- cur_entry=NULL;
74
- } else if (next_entry) {
75
- if (!StrNCmp(next_entry,
76
- tmpde->full_name,StrLen(tmpde->full_name))) {
77
- doc->cur_entry=doc_e;
78
- if (StrLen(tmpde->full_name)==StrLen(next_entry))
79
- cur_entry=NULL;
80
- }
81
- }
82
- }
83
- } else if (doc_e->type_u8==DOCT_MENU_VAL) {
84
- tmpde=doc_e->user_data;
85
- if (cur_entry) {
86
- if (!StrNCmp(cur_entry,tmpde->full_name,StrLen(tmpde->full_name))) {
87
- doc->cur_entry=doc_e;
88
- if (StrLen(tmpde->full_name)==StrLen(cur_entry))
89
- cur_entry=NULL;
90
- } else if (next_entry) {
91
- if (!StrNCmp(next_entry,
92
- tmpde->full_name,StrLen(tmpde->full_name))) {
93
- doc->cur_entry=doc_e;
94
- if (StrLen(tmpde->full_name)==StrLen(next_entry))
95
- cur_entry=NULL;
96
- }
97
- }
98
- }
99
- }
100
- doc_e=doc_e->next;
101
- }
102
- }
103
-
104
- U0 FMDelUncollapsedLst(CFMUncollapsedLst *tmpc)
105
- {
106
- CFMUncollapsedLst *tmpc1;
107
- while (tmpc) {
108
- tmpc1=tmpc->next;
109
- Free(tmpc->name);
110
- Free(tmpc);
111
- tmpc=tmpc1;
112
- }
113
- }
114
-
115
- CDirEntry *FMRebuildDocDrv(U8 drv_let,CDoc *doc,CDirEntry **_head,Bool init)
116
- {
117
- CDirEntry *tmpde,*tmpde1;
118
- U8 *st;
119
- tmpde=CAlloc(sizeof(CDirEntry));
120
- tmpde->full_name=MStrPrint("%C:/",drv_let);
121
- tmpde->attr=RS_ATTR_DIR;
122
- st=MStrPrint("%c:/*",drv_let);
123
- if (init)
124
- tmpde->sub=tmpde1=FilesFind(st,FUF_RECURSE);
125
- else
126
- tmpde1=NULL;
127
- Free(st);
128
- tmpde->user_data=DocPrint(doc,"$$TR,\"%s\",U=0x%X$$",tmpde->full_name,tmpde);
129
- tmpde->next=*_head;
130
- *_head=tmpde;
131
- DocPrint(doc,"\n$$ID,+2$$");
132
- DocBottom(doc);
133
- if (init) {
134
- DirFileDoc(doc,tmpde1);
135
- while (tmpde1) {
136
- tmpde1->parent=tmpde;
137
- tmpde1=tmpde1->next;
138
- }
139
- }
140
- DocPrint(doc,"$$ID,-2$$");
141
- return tmpde;
142
- }
143
-
144
- #define DEF2_PROCESSED 1
145
- #define DEF2_NOT_INITIALIZED 2
146
-
147
- U0 FMRebuildDoc(CDoc **_doc,CDirEntry **_head,I64 mode)
148
- {
149
- CDrv *dv;
150
- I64 i;
151
- CDoc *doc=*_doc,*doc2=sys_clip_doc,*parent_doc;
152
- CFMUncollapsedLst *tmpc=NULL;
153
- U8 *cur_entry=NULL,*next_entry=NULL;
154
- CDocEntry *doc_ce;
155
- CDirEntry *tmpde,*tmpde1,*cur_tree_entry;
156
- if (!doc)
157
- parent_doc=DocPut;
158
- else {
159
- parent_doc=doc->parent_doc;
160
- Fs->put_doc=Fs->display_doc=NULL;
161
- DocUnlock(doc);
162
- Refresh;
163
- DocLock(doc);
164
- cur_tree_entry=NULL;
165
- doc_ce=doc->cur_entry;
166
- if (doc_ce->type_u8==DOCT_TREE || doc_ce->type_u8==DOCT_MENU_VAL)
167
- cur_tree_entry=doc_ce->user_data;
168
- if (cur_tree_entry)
169
- cur_entry=StrNew(cur_tree_entry->full_name);
170
- tmpde=NULL;
171
- if (doc_ce!=doc)
172
- doc_ce=doc_ce->next;
173
- while (doc_ce!=doc) {
174
- if (doc_ce->type_u8==DOCT_TREE || doc_ce->type_u8==DOCT_MENU_VAL)
175
- tmpde=doc_ce->user_data;
176
- else
177
- tmpde=NULL;
178
- if (tmpde) {
179
- tmpde1=tmpde->parent;
180
- while (tmpde1) {
181
- if (tmpde1==cur_tree_entry) {
182
- tmpde=NULL;
183
- break;
184
- } else
185
- tmpde1=tmpde1->parent;
186
- }
187
- if (tmpde)
188
- break;
189
- }
190
- doc_ce=doc_ce->next;
191
- }
192
- if (tmpde)
193
- next_entry=StrNew(tmpde->full_name);
194
-
195
- tmpc=FMCollectUncollapsedLst(doc);
196
- DocDel(doc);
197
- }
198
- if (*_head) {
199
- DirTreeDel(*_head);
200
- *_head=NULL;
201
- }
202
- doc=DocNew;
203
- doc->desc='FileMan';
204
- doc->parent_doc=parent_doc;
205
- doc->flags|=DOCF_FORM;
206
- switch (mode) {
207
- case FM_NORMAL:
208
- DocPrint(doc,"$$PURPLE$$File Manager\n\n"
209
- "$$LK,\"Click for Help\",A=\"FI:::/Doc/FileMgr.DD\"$$\n\n");
210
- break;
211
- case FM_PICK_FILE:
212
- DocPrint(doc,"$$PURPLE$$Pick file and press <ESC>\n\n");
213
- doc->flags|=DOCF_SIZE_MIN;
214
- break;
215
- case FM_PICK_DIR:
216
- DocPrint(doc,"$$PURPLE$$Pick directory and press <ESC>\n\n");
217
- doc->flags|=DOCF_SIZE_MIN;
218
- break;
219
- }
220
- DocPrint(doc,"$$LTBLUE$$");
221
- for (i=0;i<DRVS_NUM;i++) {
222
- dv=&blkdev.drvs[i];
223
- if (dv->bd->type==BDT_ATAPI) {
224
- if (dv->bd->flags&BDF_INITIALIZED)
225
- tmpde=FMRebuildDocDrv(Drv2Let(dv),doc,_head,TRUE);
226
- else {
227
- tmpde=FMRebuildDocDrv(Drv2Let(dv),doc,_head,FALSE);
228
- tmpde->user_data2|=DEF2_NOT_INITIALIZED;
229
- }
230
- } else if (dv->fs_type==FSt_REDSEA || dv->fs_type==FSt_FAT32)
231
- FMRebuildDocDrv(Drv2Let(dv),doc,_head,TRUE);
232
- }
233
- DocTop(doc);
234
- FMMarkUncollapsed(doc,tmpc,cur_entry,next_entry);
235
- DocCenter(doc);
236
- DocRst(doc2,TRUE);
237
- FMDelUncollapsedLst(tmpc);
238
- Free(cur_entry);
239
- Free(next_entry);
240
- *_doc=doc;
241
- DocLock(doc);
242
- Fs->put_doc=Fs->display_doc=doc;
243
- }
244
-
245
- U0 FMRename(CDoc *doc)
246
- {
247
- CEdFileName fn;
248
- CDocEntry *doc_e=doc->cur_entry;
249
- CDirEntry *tmpde=NULL,*parent;
250
- if (doc_e->type_u8==DOCT_MENU_VAL) {
251
- tmpde=doc_e->user_data;
252
- if (parent=tmpde->parent) {
253
- Cd(parent->full_name);
254
- StrCpy(fn.name,tmpde->name);
255
- if (DocForm(&fn)) {
256
- Silent;
257
- Move(tmpde->name,fn.name);
258
- Silent(OFF);
259
- }
260
- }
261
- } else if (doc_e->type_u8==DOCT_TREE) {
262
- tmpde=doc_e->user_data;
263
- if (parent=tmpde->parent) {
264
- Cd(parent->full_name);
265
- StrCpy(fn.name,tmpde->name);
266
- if (DocForm(&fn)) {
267
- if (StrCmp(tmpde->name,fn.name)) {
268
- Silent;
269
- if (CopyTree(tmpde->name,fn.name))
270
- DelTree(tmpde->name);
271
- Silent(OFF);
272
- }
273
- }
274
- }
275
- }
276
- }
277
-
278
- U0 FMMkDir(CDoc *doc)
279
- {
280
- CEdFileName fn;
281
- CDocEntry *doc_e=doc->cur_entry;
282
- CDirEntry *tmpde=NULL,*parent;
283
- *fn.name=0;
284
- if (doc_e->type_u8==DOCT_MENU_VAL) {
285
- tmpde=doc_e->user_data;
286
- if (parent=tmpde->parent) {
287
- Cd(parent->full_name);
288
- if (DocForm(&fn)) {
289
- Silent;
290
- DirMk(fn.name);
291
- Silent(OFF);
292
- }
293
- }
294
- } else if (doc_e->type_u8==DOCT_TREE) {
295
- tmpde=doc_e->user_data;
296
- Cd(tmpde->full_name);
297
- if (DocForm(&fn)) {
298
- Silent;
299
- DirMk(fn.name);
300
- Silent(OFF);
301
- }
302
- }
303
- }
304
-
305
- U0 FMDelete(CDoc *doc)
306
- {
307
- U8 *st;
308
- CDocEntry *doc_ce=doc->cur_entry;
309
- CDirEntry *tmpde;
310
- if (doc_ce->type_u8==DOCT_MENU_VAL) {
311
- tmpde=doc_ce->user_data;
312
- Silent;
313
- st=MStrPrint("Delete: %s",tmpde->full_name);
314
- if (PopUpCancelOk(st))
315
- Del(tmpde->full_name);
316
- Free(st);
317
- Silent(OFF);
318
- } else if (doc_ce->type_u8==DOCT_TREE) {
319
- tmpde=doc_ce->user_data;
320
- Silent;
321
- st=MStrPrint("Delete: %s",tmpde->full_name);
322
- if (PopUpCancelOk(st))
323
- DelTree(tmpde->full_name);
324
- Free(st);
325
- Silent(OFF);
326
- }
327
- }
328
-
329
- U0 FMChgDsk(CDoc *doc)
330
- {
331
- CDocEntry *doc_ce=doc->cur_entry;
332
- CDirEntry *tmpde;
333
- if (doc_ce->type_u8==DOCT_TREE || doc_ce->type_u8==DOCT_MENU_VAL)
334
- tmpde=doc_ce->user_data;
335
- else
336
- tmpde=NULL;
337
- if (tmpde) {
338
- while (tmpde->parent)
339
- tmpde=tmpde->parent;
340
- Silent;
341
- DskChg(*tmpde->full_name);
342
- Silent(OFF);
343
- }
344
- }
345
-
346
- U0 FMMountISO(CDoc *doc)
347
- {
348
- CDocEntry *doc_ce=doc->cur_entry;
349
- CDirEntry *tmpde;
350
- if (doc_ce->type_u8==DOCT_MENU_VAL && (tmpde=doc_ce->user_data))
351
- MountFile(tmpde->full_name);
352
- }
353
-
354
- U0 FMUnmount(CDoc *doc)
355
- {
356
- CDocEntry *doc_ce=doc->cur_entry;
357
- CDirEntry *tmpde;
358
- I64 drv_let;
359
- if (doc_ce->type_u8==DOCT_TREE || doc_ce->type_u8==DOCT_MENU_VAL)
360
- tmpde=doc_ce->user_data;
361
- else
362
- tmpde=NULL;
363
- if (tmpde) {
364
- while (tmpde->parent)
365
- tmpde=tmpde->parent;
366
- drv_let=*tmpde->full_name;
367
- if (Let2BlkDev(drv_let)!=Let2BlkDev(':'))
368
- Unmount(drv_let);
369
- }
370
- }
371
-
372
- U0 FMFmtDrv(CDoc *doc)
373
- {
374
- CDocEntry *doc_ce=doc->cur_entry;
375
- CDirEntry *tmpde;
376
- U8 *st=NULL;
377
- if (doc_ce->type_u8==DOCT_TREE || doc_ce->type_u8==DOCT_MENU_VAL)
378
- tmpde=doc_ce->user_data;
379
- else
380
- tmpde=NULL;
381
- if (tmpde) {
382
- while (tmpde->parent)
383
- tmpde=tmpde->parent;
384
- st=MStrPrint("Format Drive '%c'?\nAre You Sure?\n",*tmpde->full_name);
385
- if (PopUpCancelOk(st)) {
386
- Silent;
387
- Fmt(*tmpde->full_name,,FALSE);
388
- Silent(OFF);
389
- }
390
- }
391
- Free(st);
392
- }
393
-
394
- U0 FMMakeISO(CDoc *doc)
395
- {
396
- CDocEntry *doc_ce=doc->cur_entry;
397
- CDirEntry *tmpde;
398
- if (doc_ce->type_u8==DOCT_TREE || doc_ce->type_u8==DOCT_MENU_VAL)
399
- tmpde=doc_ce->user_data;
400
- else
401
- tmpde=NULL;
402
- if (tmpde) {
403
- if (doc_ce->type_u8==DOCT_MENU_VAL)
404
- tmpde=tmpde->parent;
405
- if (tmpde && *tmpde->full_name) {
406
- Silent;
407
- RedSeaISO(,tmpde->full_name);
408
- Silent(OFF);
409
- }
410
- }
411
- }
412
-
413
- U0 FMBurnISO(CDoc *doc)
414
- {
415
- CDocEntry *doc_ce=doc->cur_entry;
416
- CDirEntry *tmpde;
417
- if (doc_ce->type_u8==DOCT_TREE || doc_ce->type_u8==DOCT_MENU_VAL)
418
- tmpde=doc_ce->user_data;
419
- else
420
- tmpde=NULL;
421
- if (tmpde) {
422
- while (tmpde->parent)
423
- tmpde=tmpde->parent;
424
- Silent;
425
- DVDImageWrite(*tmpde->full_name);
426
- Silent(OFF);
427
- }
428
- }
429
-
430
- U0 FMCopy(CDoc *doc)
431
- {
432
- CDoc *doc2=sys_clip_doc;
433
- U8 *st;
434
- CDocEntry *doc_ce=doc->cur_entry,*doc_e;
435
- CDirEntry *tmpde,*tmpde1=NULL,*tmpde2;
436
- Bool unlock_doc2=DocLock(doc2);
437
- doc_e=doc2->head.next;
438
-
439
- tmpde1=doc_ce->user_data;
440
- if (doc_ce->type_u8==DOCT_MENU_VAL)
441
- tmpde1=tmpde1->parent;
442
- else if (doc_ce->type_u8!=DOCT_TREE)
443
- tmpde1=NULL;
444
- if (tmpde1) {
445
- while (doc_e!=doc2) {
446
- if (doc_e->type_u8==DOCT_MENU_VAL) {
447
- tmpde=doc_e->user_data;
448
- tmpde->user_data2|=DEF2_PROCESSED;
449
- tmpde2=tmpde->parent;
450
- if (!tmpde2 || !(tmpde2->user_data2&DEF2_PROCESSED)) {
451
- Silent;
452
- Copy(tmpde->full_name,tmpde1->full_name);
453
- Silent(OFF);
454
- }
455
- } else if (doc_e->type_u8==DOCT_TREE) {
456
- tmpde=doc_e->user_data;
457
- tmpde->user_data2|=DEF2_PROCESSED;
458
- tmpde2=tmpde->parent;
459
- if (!tmpde2 || !(tmpde2->user_data2&DEF2_PROCESSED)) {
460
- Silent;
461
- if (*tmpde1->name)
462
- st=MStrPrint("%s/%s",tmpde1->full_name,tmpde->name);
463
- else
464
- st=MStrPrint("%s%s",tmpde1->full_name,tmpde->name);
465
- CopyTree(tmpde->full_name,st);
466
- Free(st);
467
- Silent(OFF);
468
- }
469
- }
470
- doc_e=doc_e->next;
471
- }
472
- }
473
- if (unlock_doc2)
474
- DocUnlock(doc2);
475
- }
476
-
477
- #define FMR_INCLUDE 0
478
- #define FMR_ADAM_INCLUDE 1
479
- #define FMR_DELETE 2
480
- #define FMR_RENAME 3
481
- #define FMR_MKDIR 4
482
- #define FMR_PLAIN 5
483
- #define FMR_PASTE 6
484
- #define FMR_CHG_DSK 7
485
- #define FMR_FORMAT 8
486
- #define FMR_MOUNT_REDSEA_ISO_C 9
487
- #define FMR_UNMOUNT 10
488
- #define FMR_MAKE_REDSEA_ISO_C 11
489
- #define FMR_BURN_ISO 12
490
- #define FMR_HELP 13
491
-
492
- I64 PopUpFMRight(U8 *header=NULL,U8 *footer=NULL)
493
- {
494
- I64 i;
495
- CDoc *doc=DocNew;
496
- if (header) DocPrint(doc,"%s",header);
497
- DocPrint(doc,"$$CM+LX,1,1 $$$$BT,\"INCLUDE \",LE=FMR_INCLUDE$$"
498
- "$$CM+LX,29,0$$$$BT,\"ADAM INCLUDE \",LE=FMR_ADAM_INCLUDE$$"
499
- "$$CM+LX,1,3 $$$$BT,\"DELETE \",LE=FMR_DELETE$$"
500
- "$$CM+LX,29,0$$$$BT,\"RENAME \",LE=FMR_RENAME$$"
501
- "$$CM+LX,1,3 $$$$BT,\"MAKE DIRECTORY \",LE=FMR_MKDIR$$"
502
- "$$CM+LX,29,0$$$$BT,\"PLAIN-TEXT EDIT \",LE=FMR_PLAIN$$"
503
- "$$CM+LX,1,3 $$$$BT,\"PASTE CLIP FILES \",LE=FMR_PASTE$$"
504
- "$$CM+LX,29,0$$$$BT,\"CHANGE DISK(MOUNT IT) \",LE=FMR_CHG_DSK$$"
505
- "$$CM+LX,1,3 $$$$BT,\"FORMAT \",LE=FMR_FORMAT$$"
506
- "$$CM+LX,1,3 $$$$BT,\"MOUNT ISO.C FILE \","
507
- "LE=FMR_MOUNT_REDSEA_ISO_C$$"
508
- "$$CM+LX,29,0$$$$BT,\"UNMOUNT \",LE=FMR_UNMOUNT$$"
509
- "$$CM+LX,1,3 $$$$BT,\"MAKE ISO.C (CD/DVD) FILE\",LE=FMR_MAKE_REDSEA_ISO_C$$"
510
- "$$CM+LX,29,0$$$$BT,\"BURN ISO (CD/DVD) FILE \",LE=FMR_BURN_ISO$$"
511
- "$$CM+LX,1,3 $$$$BT,\"HELP \",LE=FMR_HELP$$"
512
- "$$CM+LX,29,0$$$$BT,\"CANCEL \",LE=DOCM_CANCEL$$\n");
513
- if (footer) DocPrint(doc,"%s",footer);
514
- i=PopUpMenu(doc);
515
- DocDel(doc);
516
- return i;
517
- }
518
-
519
- U0 FMRightClick()
520
- {
521
- switch (PopUpFMRight) {
522
- case FMR_INCLUDE:
523
- Msg(MSG_KEY_DOWN,0,0x3F0000003F);
524
- break;
525
- case FMR_ADAM_INCLUDE:
526
- Msg(MSG_KEY_DOWN,0,0x23F0000023F);
527
- break;
528
- case FMR_DELETE:
529
- Msg(MSG_KEY_DOWN,CH_CTRLY,0);
530
- break;
531
- case FMR_RENAME:
532
- Msg(MSG_KEY_DOWN,'r',0);
533
- break;
534
- case FMR_MKDIR:
535
- Msg(MSG_KEY_DOWN,'d',0);
536
- break;
537
- case FMR_PLAIN:
538
- Msg(MSG_KEY_DOWN,CH_SHIFT_SPACE,0);
539
- break;
540
- case FMR_PASTE:
541
- Msg(MSG_KEY_DOWN,0,SC_INS+SCF_SHIFT);
542
- break;
543
- case FMR_CHG_DSK:
544
- Msg(MSG_KEY_DOWN,'c',0);
545
- break;
546
- case FMR_FORMAT:
547
- Msg(MSG_KEY_DOWN,'f',0);
548
- break;
549
- case FMR_MOUNT_REDSEA_ISO_C:
550
- Msg(MSG_KEY_DOWN,'i',0);
551
- break;
552
- case FMR_UNMOUNT:
553
- Msg(MSG_KEY_DOWN,'u',0);
554
- break;
555
- case FMR_MAKE_REDSEA_ISO_C:
556
- Msg(MSG_KEY_DOWN,'m',0);
557
- break;
558
- case FMR_BURN_ISO:
559
- Msg(MSG_KEY_DOWN,'B',0);
560
- break;
561
- case FMR_HELP:
562
- Msg(MSG_KEY_DOWN,CH_CTRLM,0x43200000432);
563
- break;
564
- }
565
- }
566
-
567
- U8 *fm_ms_str=NULL;
568
- U0 (*fp_old_final_scrn_update)(CDC *dc);
569
-
570
- U0 FMFinalScrnUpdate(CDC *dc)
571
- {
572
- if (fm_ms_str) {
573
- dc->color=LTRED;
574
- GrPrint(dc,ms.pos.x,ms.pos.y,"%s",fm_ms_str);
575
- }
576
- (*fp_old_final_scrn_update)(dc);
577
- }
578
-
579
- public U8 *FileMgr(I64 mode=FM_NORMAL,CTask *mem_task=NULL)
580
- {//File manager. Also, used to choose files and dirs.
581
- CDirEntry *head=NULL,*tmpde,*tmpde1,*tmpde2;
582
- I64 sc,ch,arg1,arg2,msg_code;
583
- CDoc *doc=NULL,*old_put_doc=DocPut,*old_display_doc=DocDisplay;
584
- U8 *res=NULL,*st,*st2,*old_cur_dir=DirCur;
585
- CDocEntry *doc_ce=NULL,*doc_e;
586
- Bool okay;
587
-
588
- SettingsPush; //See $LK,"SettingsPush",A="MN:SettingsPush"$
589
- fp_old_final_scrn_update=gr.fp_final_scrn_update;
590
- MenuFilePush("::/Doc/FileMgrPullDown.DD");
591
- FMRebuildDoc(&doc,&head,mode);
592
- if (tmpde1=Cd2DirEntry(head,old_cur_dir))
593
- doc->cur_entry=tmpde1->user_data;
594
- while (tmpde1) {
595
- if (tmpde1->attr&RS_ATTR_DIR)
596
- tmpde1->user_data(CDocEntry *)->de_flags&=~DOCEF_CHECKED_COLLAPSED;
597
- tmpde1=tmpde1->parent;
598
- }
599
- do {
600
- DocUnlock(doc);
601
- do msg_code=GetMsg(&arg1,&arg2,
602
- 1<<MSG_KEY_DOWN|1<<MSG_MS_L_DOWN|1<<MSG_MS_L_UP|1<<MSG_MS_R_UP);
603
- while (Fs!=sys_focus_task);
604
- DocLock(doc);
605
- switch (msg_code) {
606
- case MSG_MS_R_UP:
607
- DocUnlock(doc);
608
- FMRightClick;
609
- DocLock(doc);
610
- break;
611
- case MSG_MS_L_DOWN:
612
- doc_ce=doc->cur_entry;
613
- fm_ms_str=doc_ce->tag;
614
- gr.fp_final_scrn_update=&FMFinalScrnUpdate;
615
- break;
616
- case MSG_MS_L_UP:
617
- if (doc_ce) {
618
- gr.fp_final_scrn_update=fp_old_final_scrn_update;
619
- if (WinCursorPosSet(Fs,arg1+Fs->pix_left+Fs->scroll_x,
620
- arg2+Fs->pix_top+Fs->scroll_y,TRUE)) {
621
- doc_e=doc->cur_entry;
622
- if (doc_e!=doc_ce) {
623
- st2=NULL;
624
- if (doc_e->type_u8==DOCT_MENU_VAL) {
625
- tmpde1=doc_e->user_data;
626
- if (tmpde1=tmpde1->parent)
627
- st2=StrNew(tmpde1->full_name);
628
- } else if (doc_e->type_u8==DOCT_TREE) {
629
- tmpde1=doc_e->user_data;
630
- st2=StrNew(tmpde1->full_name);
631
- }
632
- if (st2 && doc_ce->type_u8==DOCT_MENU_VAL) {
633
- tmpde=doc_ce->user_data;
634
- Silent;
635
- Move(tmpde->full_name,st2);
636
- Silent(OFF);
637
- FMRebuildDoc(&doc,&head,mode);
638
- } else if (st2 && doc_ce->type_u8==DOCT_TREE) {
639
- tmpde=doc_ce->user_data;
640
- okay=TRUE;
641
- tmpde2=tmpde1;
642
- while (tmpde2) {
643
- if (tmpde2!=tmpde)
644
- tmpde2=tmpde2->parent;
645
- else {
646
- okay=FALSE;
647
- break;
648
- }
649
- }
650
- if (okay) {
651
- if (*tmpde1->name)
652
- st=MStrPrint("%s/%s",tmpde1->full_name,tmpde->name);
653
- else
654
- st=MStrPrint("%s%s",tmpde1->full_name,tmpde->name);
655
- if (StrCmp(tmpde->full_name,st)) {
656
- Silent;
657
- CopyTree(tmpde->full_name,st);
658
- DelTree(tmpde->full_name);
659
- Silent(OFF);
660
- FMRebuildDoc(&doc,&head,mode);
661
- }
662
- Free(st);
663
- }
664
- }
665
- Free(st2);
666
- FlushMsgs;
667
- } else
668
- if (doc_e->type_u8==DOCT_MENU_VAL) {
669
- DocUnlock(doc);
670
- Ed(doc_e->user_data(CDirEntry *)->full_name);
671
- DocLock(doc);
672
- }
673
- doc_ce=NULL;
674
- }
675
- }
676
- break;
677
- case MSG_KEY_DOWN:
678
- doc_ce=NULL;
679
- ch=arg1; sc=arg2;
680
- if (sc.u8[0]==SC_DELETE && !(sc&(SCF_SHIFT|SCF_CTRL)))
681
- ch=CH_CTRLY;
682
- if (ch && sc&SCF_ALT) goto fm_regular_key;
683
- switch (ch) {
684
- case '\n':
685
- DocUnlock(doc);
686
- FMRightClick;
687
- DocLock(doc);
688
- break;
689
- start:
690
- DocUnlock(doc);
691
- case CH_CTRLV:
692
- FMCopy(doc);
693
- break;
694
- case 'r':
695
- FMRename(doc);
696
- break;
697
- case 'd':
698
- FMMkDir(doc);
699
- break;
700
- case CH_CTRLY:
701
- FMDelete(doc);
702
- break;
703
- case 'c':
704
- FMChgDsk(doc);
705
- break;
706
- case 'i':
707
- FMMountISO(doc);
708
- break;
709
- case 'u':
710
- FMUnmount(doc);
711
- break;
712
- case 'm':
713
- FMMakeISO(doc);
714
- break;
715
- case 'B':
716
- FMBurnISO(doc);
717
- break;
718
- case 'f':
719
- FMFmtDrv(doc);
720
- break;
721
- end:
722
- FMRebuildDoc(&doc,&head,mode);
723
- break;
724
- case CH_SHIFT_ESC:
725
- break;
726
- case CH_SPACE:
727
- if (doc->cur_entry->type_u8==DOCT_MENU_VAL) {
728
- DocUnlock(doc);
729
- Ed(doc->cur_entry->user_data(CDirEntry *)->full_name);
730
- DocLock(doc);
731
- } else
732
- goto fm_regular_key;
733
- break;
734
- case CH_SHIFT_SPACE:
735
- if (doc->cur_entry->type_u8==DOCT_MENU_VAL) {
736
- DocUnlock(doc);
737
- Plain(doc->cur_entry->user_data(CDirEntry *)->full_name);
738
- DocLock(doc);
739
- } else
740
- goto fm_regular_key;
741
- break;
742
- case CH_ESC:
743
- doc_ce=doc->cur_entry;
744
- tmpde=doc_ce->user_data;
745
- if (mode==FM_PICK_FILE && doc_ce->type_u8==DOCT_MENU_VAL)
746
- res=StrNew(tmpde->full_name,mem_task);
747
- else if (mode==FM_PICK_DIR) {
748
- if (doc_ce->type_u8==DOCT_TREE)
749
- res=StrNew(tmpde->full_name,mem_task);
750
- else if (doc_ce->type_u8==DOCT_MENU_VAL &&
751
- (tmpde=tmpde->parent))
752
- res=StrNew(tmpde->full_name,mem_task);
753
- }
754
- break;
755
- default:
756
- if (sc.u8[0]==SC_INS && sc&SCF_SHIFT && !(sc&SCF_CTRL)) {
757
- FMCopy(doc);
758
- FMRebuildDoc(&doc,&head,mode);
759
- } else if (sc.u8[0]==SC_F5) {
760
- if (doc->cur_entry->type_u8==DOCT_MENU_VAL) {
761
- tmpde=doc->cur_entry->user_data;
762
- DocUnlock(doc);
763
- if (sc&SCF_SHIFT)
764
- AdamFile(tmpde->full_name);
765
- else
766
- PopUpFile(tmpde->full_name);
767
- DocLock(doc);
768
- }
769
- } else {
770
- fm_regular_key:
771
- DocUnlock(doc);
772
- PutKey(ch,sc);
773
- DocLock(doc);
774
- }
775
- }
776
- break;
777
- }
778
- } while (ch!=CH_ESC && ch!=CH_SHIFT_ESC);
779
- gr.fp_final_scrn_update=fp_old_final_scrn_update;
780
- Fs->put_doc =old_put_doc;
781
- Fs->display_doc=old_display_doc;
782
- SettingsPop;
783
- DocDel(doc);
784
- DirTreeDel(head);
785
- Cd(old_cur_dir);
786
- Free(old_cur_dir);
787
- if (mode!=FM_NORMAL && !res)
788
- res=StrNew("",mem_task);
789
- MenuPop;
790
- return res;
791
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:8fe0172a212c48d38bd6bb43562045afe87484dd270949e6fc7dd2294e5905fd
3
+ size 19295
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/ABlkDev/MakeABlkDev.HC CHANGED
@@ -1,8 +1,3 @@
1
- Cd(__DIR__);;
2
- #include "ADskA"
3
- #include "ADskB"
4
- #include "DskPrt"
5
- #include "Mount"
6
- #include "DskChk"
7
- #include "FileMgr"
8
- Cd("..");;
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:03651e2c62712d77d1146985f14eda511f7e2b654f664edff2f1bbce71a5fd14
3
+ size 131
 
 
 
 
 
Adam/ABlkDev/Mount.HC CHANGED
@@ -1,159 +1,3 @@
1
- #help_index "Install;File/Cmd Line (Typically);Cmd Line (Typically);"
2
- U8 Mount2(U8 boot_drv_let,CDoc *_doc,Bool _caller_is_prtdsk)
3
- {//If _doc, called by $LK,"::/Kernel/KCfg.HC"$ else called by $LK,"Mount",A="MN:Mount"$().
4
- I64 cnt,total=0,num_hints,drv_let,type,unit,prt_num;
5
- U8 blks_buf[STR_LEN],addr_buf[STR_LEN],base0_buf[STR_LEN],base1_buf[STR_LEN],
6
- *filename=NULL,*filename2=NULL,res=0;
7
- CATARep *head=NULL,*tmpha;
8
- Bool whole_drv,make_free;
9
- CDoc *doc;
10
- if (boot_drv_let)
11
- boot_drv_let=Let2Let(boot_drv_let);
12
- do {
13
- cnt=0;
14
- if (!_doc)
15
- DrvRep;
16
- "\n****** Mount Drives ******\n"
17
- "$$GREEN$$A$$FG$$-$$GREEN$$B$$FG$$ are RAM drives.\n"
18
- "$$GREEN$$C$$FG$$-$$GREEN$$L$$FG$$ are ATA hard drives.\n"
19
- "$$GREEN$$M$$FG$$-$$GREEN$$P$$FG$$ are ISO file read drives.\n"
20
- "$$GREEN$$Q$$FG$$-$$GREEN$$S$$FG$$ are ISO file write drives.\n"
21
- "$$GREEN$$T$$FG$$-$$GREEN$$Z$$FG$$ are ATAPI CD/DVD drives.\n"
22
- "\nDrive Letter ($$PURPLE$$<ENTER>$$FG$$ to exit):";
23
- drv_let=Let2Let(GetChar);
24
- '\n';
25
- if (type=Let2BlkDevType(drv_let)) {
26
- whole_drv=FALSE;
27
- if (_doc) { //Called by $LK,"::/Kernel/KCfg.HC"$
28
- doc=_doc;
29
- make_free=FALSE;
30
- } else { //Called by $LK,"Mount",A="MN:Mount"$()
31
- doc=DocNew;
32
- DocPrint(doc,"CBlkDev *bd;\n");
33
- make_free=TRUE;
34
- }
35
- unit=0;
36
- prt_num=I64_MIN;
37
- switch (type) {
38
- case BDT_RAM:
39
- "Addr of RAM disk ($$PURPLE$$<ENTER>$$FG$$ to MAlloc):";
40
- GetS(addr_buf,STR_LEN);
41
- case BDT_ISO_FILE_WRITE:
42
- "Blks of 512 bytes:";
43
- GetS(blks_buf,STR_LEN);
44
- break;
45
- case BDT_ISO_FILE_READ:
46
- filename=GetStr("File Name:");
47
- break;
48
- case BDT_ATA:
49
- prt_num=GetI64("Partition Num (Default=All):",prt_num);
50
- case BDT_ATAPI:
51
- num_hints=ATARep(,,&head);
52
- if (type==BDT_ATAPI && boot_drv_let)
53
- "<ENTER> to use booted CD/DVD\n"; //Only $LK,"::/Kernel/KCfg.HC"$
54
- do {
55
- if (num_hints)
56
- "Enter dev number or\nport with $$PURPLE$$0x$$FG$$ prefix.\n"
57
- "I/O Port Base0:\n";
58
- else
59
- "Include $$PURPLE$$0x$$FG$$ prefix.\nI/O Port Base0:\n";
60
- GetS(base0_buf,STR_LEN);
61
- } while (!Str2I64(base0_buf) && (type!=BDT_ATAPI || !boot_drv_let));
62
- if (1<=Str2I64(base0_buf)<=num_hints) {
63
- tmpha=ATARepFind(head,Str2I64(base0_buf));
64
- StrPrint(base0_buf,"0x%X",tmpha->base0);
65
- StrPrint(base1_buf,"0x%X",tmpha->base1);
66
- unit=tmpha->unit;
67
- } else if (type!=BDT_ATAPI || *base0_buf) {
68
- if (type==BDT_ATAPI)
69
- StrCpy(base1_buf,"0");
70
- else
71
- do {
72
- "I/O Port Base1:\n";
73
- GetS(base1_buf,STR_LEN);
74
- } while (!Str2I64(base1_buf));
75
- do {
76
- "\t$$PURPLE$$0$$FG$$=Master\n\t$$PURPLE$$1$$FG$$=Slave\nUnit:";
77
- unit=GetChar-'0';
78
- } while (!(0<=unit<=1));
79
- '\n';
80
- }
81
- LinkedLstDel(head);
82
- break;
83
- }
84
- DocPrint(doc,"bd=BlkDevNextFreeSlot(\'%C\',%d);bd->unit=%d;\n",
85
- drv_let,type,unit);
86
- switch (type) {
87
- case BDT_RAM:
88
- if (!*addr_buf) StrCpy(addr_buf,"0");
89
- DocPrint(doc,"bd->RAM_dsk=%s;\n",addr_buf);
90
- case BDT_ISO_FILE_WRITE:
91
- if (!*blks_buf) StrCpy(blks_buf,"0");
92
- DocPrint(doc,"bd->max_blk=(%s)-1;\n",blks_buf);
93
- DocPrint(doc,"bd->drv_offset=19<<2+"
94
- "(DVD_BLK_SIZE*2+DVD_BOOT_LOADER_SIZE)/BLK_SIZE;\n");
95
- break;
96
- case BDT_ISO_FILE_READ:
97
- filename2=FileNameAbs(filename);
98
- DocPrint(doc,"bd->file_dsk_name=AStrNew(\"%s\");\n",filename2);
99
- DocPrint(doc,"bd->drv_offset=19<<2+"
100
- "(DVD_BLK_SIZE*2+DVD_BOOT_LOADER_SIZE)/BLK_SIZE;\n");
101
- break;
102
- case BDT_ATA:
103
- case BDT_ATAPI:
104
- if (type==BDT_ATAPI && !*base0_buf) {
105
- DocPrint(doc,"GetBaseUnit(bd);\n"); //Only $LK,"::/Kernel/KCfg.HC"$
106
- if (drv_let==boot_drv_let)
107
- make_free=TRUE;
108
- } else
109
- DocPrint(doc,"bd->base0=%s;bd->base1=%s;\n",base0_buf,base1_buf);
110
- if (type==BDT_ATA && _caller_is_prtdsk) {
111
- "\nReformat WHOLE drive!";
112
- whole_drv=YorN;
113
- }
114
- break;
115
- }
116
- DocPrint(doc,"BlkDevAdd(bd,%d,%d,%d);\n",prt_num,whole_drv,make_free);
117
- if (_doc) //Called by $LK,"::/Kernel/KCfg.HC"$
118
- cnt++;
119
- else { //Called by $LK,"Mount",A="MN:Mount"$()
120
- if ((cnt=ExeDoc(doc)) && whole_drv) {
121
- if (_caller_is_prtdsk) {
122
- res=drv_let;
123
- DskPrt(drv_let,1.0); //First mount whole drive.
124
- } else
125
- DskPrt(drv_let);
126
- }
127
- DocDel(doc);
128
- }
129
- }
130
- total+=cnt;
131
- } while (cnt && !_caller_is_prtdsk ||
132
- !total && _doc); //At least 1 if Called by $LK,"::/Kernel/KCfg.HC"$
133
- Free(filename);
134
- Free(filename2);
135
- return res;
136
- }
137
-
138
- public U8 Mount(Bool caller_is_prtdsk=FALSE)
139
- {//Mount drives. Called from $LK,"DskPrt(Mount)",A="FF:::/Adam/ABlkDev/DskPrt.HC,Mount("$.
140
- return Mount2(0,NULL,caller_is_prtdsk);
141
- }
142
-
143
- public U0 Unmount(U8 drv_let=0)
144
- {//Unmount drive(s).
145
- BlkDevDel(Let2BlkDev(drv_let));
146
- }
147
-
148
- public U8 MountFile(U8 *filename)
149
- {//Mount ISO.C file.
150
- U8 *filename2=ExtDft(filename,"ISO.C"),*filename3=FileNameAbs(filename2);
151
- CDrv *dv=DrvMakeFreeSlot(DrvNextFreeLet('M')); //First $LK,"BDT_ISO_FILE_READ",A="MN:BDT_ISO_FILE_READ"$
152
- CBlkDev *bd=BlkDevNextFreeSlot(dv->drv_let,BDT_ISO_FILE_READ);
153
- bd->drv_offset=19<<2+(DVD_BLK_SIZE*2+DVD_BOOT_LOADER_SIZE)/BLK_SIZE;
154
- bd->file_dsk_name=AStrNew(filename3);
155
- BlkDevAdd(bd,,TRUE,TRUE);
156
- Free(filename3);
157
- Free(filename2);
158
- return dv->drv_let;
159
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:43dfccd66a66946ab250f9aab4644977e084a07ee8dd4bf3d27abea6cc47ac7e
3
+ size 5188
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/ABlkDev/PrtDsk.HC CHANGED
@@ -1,167 +1,3 @@
1
- #help_index "Install;File/Cmd Line (Typically);Cmd Line (Typically)"
2
-
3
- #define ROUND_DRV_TO (63*255)
4
- #define DRV_HEADER 63
5
-
6
- class CPlannedDrv
7
- {
8
- CPlannedDrv *next,*last;
9
- I64 size;
10
- Bool pri;
11
- };
12
-
13
- public I64 PrtDsk(U8 drv_let=0,...)
14
- {/*Partition the disk containing partition drv_let.
15
-
16
- drv_let=0 means add new drive that is not already mounted.
17
-
18
- >PrtDsk('C',0.5,0.25,0.25); //Make three. 50% C, 25% D, 25% E, round-up to blk.
19
-
20
- */
21
- CBlkDev *bd;
22
- CPlannedDrv head,*tmppp;
23
- CMasterBoot mbr;
24
- Bool pri=TRUE;
25
- I64 ext_base,drv_let2,pri_cnt=0,i,start_offset,offset,
26
- total,remaining,cur_arg=0;
27
- "This command does not play well\n"
28
- "with other operating systems.\n"
29
- "You really should use another\n"
30
- "operating system's partitioner.\n"
31
- "If you use this, it may, in fact,\n"
32
- "make your hard drive impossible\n"
33
- "to repartition with other operating\n"
34
- "until you set block zero to zero\n"
35
- "with $$LK,\"BootMHDZero\",\"MN:BootMHDZero\"$$()\n\n\n"
36
- "Continue";
37
- if (argc<=cur_arg && !YorN)
38
- return 0;
39
- '\n';
40
-
41
- if (drv_let && !Let2BlkDev(drv_let,FALSE))
42
- drv_let=0;
43
- if (!drv_let && !(drv_let=Mount(TRUE)) ||
44
- !(bd=Let2BlkDev(drv_let,FALSE)) || bd->type!=BDT_ATA)
45
- return 0;
46
-
47
- total=bd->max_blk+1;
48
- QueInit(&head);
49
- drv_let2=bd->first_drv_let;
50
- remaining=FloorU64(bd->max_blk+1,ROUND_DRV_TO);
51
- while (FloorU64(remaining,ROUND_DRV_TO)>=ROUND_DRV_TO) {
52
- tmppp=MAlloc(sizeof(CPlannedDrv));
53
- do {
54
- "$$RED$$Partition %C$$FG$$\n",drv_let2;
55
- tmppp->pri=FALSE;
56
- if (pri) {
57
- "Primary Partition";
58
- if (argc>cur_arg || YorN) {
59
- pri_cnt++;
60
- tmppp->pri=TRUE;
61
- if (pri_cnt==3)
62
- pri=FALSE;
63
- } else
64
- pri=FALSE;
65
- }
66
- "\nBlocks Remaining:%d (0x%X)\n",
67
- remaining-DRV_HEADER,remaining-DRV_HEADER;
68
- if (argc>cur_arg)
69
- tmppp->size=MinI64(CeilU64(MaxI64(remaining,DRV_HEADER),ROUND_DRV_TO),
70
- CeilU64(argv[cur_arg++](F64)*total,ROUND_DRV_TO));
71
- else
72
- tmppp->size=CeilU64(GetI64("Size in Blocks :",
73
- remaining-DRV_HEADER)+DRV_HEADER,ROUND_DRV_TO);
74
- } while (!(ROUND_DRV_TO<=tmppp->size<=FloorU64(remaining,ROUND_DRV_TO)));
75
- QueIns(tmppp,head.last);
76
- remaining-=tmppp->size;
77
- drv_let2++;
78
- }
79
-
80
- "\n\n!!! Repartition Drive !!!\n\n";
81
- tmppp=head.next;
82
- drv_let2=bd->first_drv_let;
83
- while (tmppp!=&head) {
84
- "Drive %C:%08X ",drv_let2,tmppp->size;
85
- if (tmppp->pri)
86
- "Primary\n";
87
- else
88
- "Logical\n";
89
- tmppp=tmppp->next;
90
- drv_let2++;
91
- }
92
- if (!argc && !AreYouSure)
93
- goto pd_done;
94
-
95
- remaining=FloorU64(bd->max_blk+1,ROUND_DRV_TO)-ROUND_DRV_TO;
96
- tmppp=head.next;
97
- MemSet(&mbr,0,BLK_SIZE);
98
- mbr.signature=0xAA55;
99
- offset=0;
100
- for (i=0;i<pri_cnt;i++) {
101
- mbr.p[i].active=0x80;
102
- mbr.p[i].start_head=0;
103
- mbr.p[i].start_cyl=0x101;
104
- mbr.p[i].type=1; //Will get set different.
105
- mbr.p[i].end_head=0xFE;
106
- mbr.p[i].end_cyl=0xFFFF;
107
- mbr.p[i].offset=DRV_HEADER+offset;
108
- mbr.p[i].size=tmppp->size-DRV_HEADER;
109
- offset+=tmppp->size;
110
- remaining-=tmppp->size;
111
- tmppp=tmppp->next;
112
- }
113
- if (!i) i++;
114
- if (tmppp!=&head) {
115
- mbr.p[i].active=0x80;
116
- mbr.p[i].start_head=0;
117
- mbr.p[i].start_cyl=0x101;
118
- mbr.p[i].type=0xF;
119
- mbr.p[i].end_head=0xFE;
120
- mbr.p[i].end_cyl=0xFFFF;
121
- mbr.p[i].offset=offset;
122
- mbr.p[i].size=remaining;
123
- ext_base=offset;
124
- }
125
- ATAWriteBlks(bd,&mbr,0,1);
126
-
127
- while (tmppp!=&head) {
128
- start_offset=offset;
129
- MemSet(&mbr,0,BLK_SIZE);
130
- mbr.signature=0xAA55;
131
-
132
- mbr.p[0].active=0x80;
133
- mbr.p[0].start_head=1;
134
- mbr.p[0].start_cyl=0x101;
135
- mbr.p[0].type=1; //Will get set different.
136
- mbr.p[0].end_head=0xFE;
137
- mbr.p[0].end_cyl=0xFFFF;
138
- mbr.p[0].offset=DRV_HEADER;
139
- mbr.p[0].size=tmppp->size-DRV_HEADER;
140
- offset+=tmppp->size;
141
- tmppp=tmppp->next;
142
- if (tmppp!=&head) {
143
- mbr.p[1].active=0x80;
144
- mbr.p[1].start_head=0;
145
- mbr.p[1].start_cyl=0x101;
146
- mbr.p[1].type=5;
147
- mbr.p[1].end_head=0xFE;
148
- mbr.p[1].end_cyl=0xFFFF;
149
- mbr.p[1].offset=offset-ext_base;
150
- mbr.p[1].size=tmppp->size;
151
- }
152
- ATAWriteBlks(bd,&mbr,start_offset,1);
153
- }
154
-
155
- bd->flags&=~(BDF_INITIALIZED | BDF_INIT_IN_PROGRESS);
156
- BlkDevAdd(bd,,FALSE,TRUE);
157
- for (i=bd->first_drv_let;i<drv_let2;i++)
158
- Fmt(i,,FALSE);
159
-
160
- pd_done:
161
- while (head.next!=&head) {
162
- tmppp=head.next;
163
- QueRem(tmppp);
164
- Free(tmppp);
165
- }
166
- return total;
167
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:3bcc8994a6d501d5b81abd6a0dcfb44970c42e3b47e806cf027bc19bf060110a
3
+ size 4323
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/ADbg.HC CHANGED
@@ -1,270 +1,3 @@
1
- #help_index "Debugging/Dump"
2
- Bool ClassRep2(CDoc *doc,U8 *_d,U8 *class_name=lastclass,
3
- I64 depth,I64 max_depth,Bool dynamic,I64 types=HTT_CLASS,I64 offset=0)
4
- {//See $LK,"::/Demo/LastClass.HC"$.
5
- I64 i,j,stars,*ptr;
6
- CMemberLst *ml;
7
- CDocEntry *doc_e;
8
- Bool unlock;
9
- CHashClass *tmpc,*tmpc2;
10
- if (depth>=max_depth) return TRUE;
11
- if (!(tmpc=HashFind(class_name,Fs->hash_table,types))) {
12
- DocPrint(doc,"Class Not Found.\n");
13
- return FALSE;
14
- }
15
- if (!ChkPtr(_d) || !ChkPtr(_d(U8 *)+tmpc->size)) {
16
- DocPrint(doc,"Bad Ptr:%016X\n",_d);
17
- return FALSE;
18
- }
19
- if (tmpc->base_class && !ClassRep2(doc,_d,tmpc->base_class->str,
20
- depth,max_depth,dynamic,types,offset))
21
- return FALSE;
22
- unlock=DocLock(doc);
23
- DocPrint(doc,"Class:\"%s\"\n",class_name);
24
- ml=tmpc->member_lst_and_root;
25
- while (ml) {
26
- tmpc2=ml->member_class;
27
- ptr=_d(U8 *)+ml->offset;
28
- DocPrint(doc,"%08X ",ptr(U8 *)+offset);
29
- stars=tmpc2->ptr_stars_cnt;
30
- tmpc2=OptClassFwd(tmpc2);
31
- tmpc2-=tmpc2->ptr_stars_cnt;
32
- if (tmpc2->type & HTT_INTERNAL_TYPE) {
33
- DocPrint(doc,"$$GREEN$$%-20ts:$$FG$$",ml->str);
34
- if (stars==1 && (tmpc2->raw_type==RT_I8 || tmpc2->raw_type==RT_U8)) {
35
- ptr=*ptr;
36
- if (ChkPtr(ptr)) {
37
- if (dynamic) {
38
- doc_e=DocPrint(doc,"$$DA-TRM-P+RD,LEN=64,A=\"%%40ts\"$$\n");
39
- doc_e->data=ptr;
40
- DocDataFmt(doc,doc_e);
41
- } else
42
- DocPrint(doc,"%40ts\n",ptr);
43
- }
44
- } else if (!stars) {
45
- j=MinI64(ml->dim.total_cnt,32);
46
- if (tmpc2->raw_type==RT_I8 || tmpc2->raw_type==RT_U8) {
47
- if (j==1) {
48
- if (dynamic) {
49
- doc_e=DocPrint(doc,"$$DA-TRM+RD+UD,RT=U8,A=\"%%c\"$$\n");
50
- doc_e->data=ptr;
51
- } else
52
- DocPrint(doc,"%c\n",*ptr(U8 *));
53
- } else {
54
- if (dynamic) {
55
- doc_e=DocPrint(doc,"$$DA-TRM-P+RD,LEN=64,A=\"%%40ts\"$$\n");
56
- doc_e->data=ptr;
57
- DocDataFmt(doc,doc_e);
58
- } else
59
- DocPrint(doc,"%40ts\n",ptr);
60
- }
61
- }
62
- for (i=0;i<j;i++) {
63
- switch (tmpc2->raw_type) {
64
- case RT_I0:
65
- case RT_U0:
66
- break;
67
- case RT_I8:
68
- if (dynamic) {
69
- doc_e=DocPrint(doc,"$$DA-TRM+RD+UD,RT=I8,A=\"%%02X\"$$ ");
70
- doc_e->data=ptr(I8 *)++;
71
- } else
72
- DocPrint(doc,"%02X ",*ptr(I8 *)++);
73
- break;
74
- case RT_U8:
75
- if (dynamic) {
76
- doc_e=DocPrint(doc,"$$DA-TRM+RD+UD,RT=U8,A=\"%%02X\"$$ ");
77
- doc_e->data=ptr(U8 *)++;
78
- } else
79
- DocPrint(doc,"%02X ",*ptr(U8 *)++);
80
- break;
81
- case RT_I16:
82
- if (dynamic) {
83
- doc_e=DocPrint(doc,"$$DA-TRM+RD+UD,RT=I16,A=\"%%04X\"$$ ");
84
- doc_e->data=ptr(I16 *)++;
85
- } else
86
- DocPrint(doc,"%04X ",*ptr(I16 *)++);
87
- break;
88
- case RT_U16:
89
- if (dynamic) {
90
- doc_e=DocPrint(doc,"$$DA-TRM+RD+UD,RT=U16,A=\"%%04X\"$$ ");
91
- doc_e->data=ptr(U16 *)++;
92
- } else
93
- DocPrint(doc,"%04X ",*ptr(U16 *)++);
94
- break;
95
- case RT_I32:
96
- if (dynamic) {
97
- doc_e=DocPrint(doc,"$$DA-TRM+RD+UD,RT=I32,A=\"%%08X\"$$ ");
98
- doc_e->data=ptr(I32 *)++;
99
- } else
100
- DocPrint(doc,"%08X ",*ptr(I32 *)++);
101
- break;
102
- case RT_U32:
103
- if (dynamic) {
104
- doc_e=DocPrint(doc,"$$DA-TRM+RD+UD,RT=U32,A=\"%%08X\"$$ ");
105
- doc_e->data=ptr(U32 *)++;
106
- } else
107
- DocPrint(doc,"%08X ",*ptr(U32 *)++);
108
- break;
109
- case RT_U64:
110
- if (dynamic) {
111
- doc_e=DocPrint(doc,"$$DA-TRM+RD+UD,RT=U64,A=\"%%08X\"$$ ");
112
- doc_e->data=ptr(U64 *)++;
113
- } else
114
- DocPrint(doc,"%08X ",*ptr(U64 *)++);
115
- break;
116
- case RT_F64:
117
- if (dynamic) {
118
- doc_e=DocPrint(doc,"$$DA-TRM+RD+UD,RT=F64,A=\"%%16g\"$$ ");
119
- doc_e->data=ptr(F64 *)++;
120
- } else
121
- DocPrint(doc,"%16g ",*ptr(I64 *)++);
122
- break;
123
- default:
124
- if (dynamic) {
125
- doc_e=DocPrint(doc,"$$DA-TRM+RD+UD,A=\"%%016X\"$$ ");
126
- doc_e->data=ptr(I64 *)++;
127
- } else
128
- DocPrint(doc,"%016X ",*ptr(I64 *)++);
129
- }
130
- if (dynamic)
131
- DocDataFmt(doc,doc_e);
132
- }
133
- if (j<ml->dim.total_cnt)
134
- DocPrint(doc,"...");
135
- } else
136
- DocPrint(doc,"%016X",*ptr);
137
- DocPrint(doc,"\n");
138
- } else {
139
- if (depth<2) {
140
- if (stars==1 && !ChkPtr(*ptr))
141
- DocPrint(doc,"%-20ts:%016X\n",ml->str,*ptr);
142
- else {
143
- DocPrint(doc,"$$TR,\"%s\"$$\n",ml->str);
144
- DocPrint(doc,"$$ID,2$$");
145
- if (!stars)
146
- ClassRep2(doc,ptr,tmpc2->str,depth+1,max_depth,dynamic);
147
- else if (stars==1)
148
- ClassRep2(doc,*ptr,tmpc2->str,depth+1,max_depth,dynamic);
149
- DocPrint(doc,"$$ID,-2$$");
150
- }
151
- } else
152
- DocPrint(doc,"%-20ts\n",ml->str);
153
- }
154
- ml=ml->next;
155
- }
156
- if (unlock)
157
- DocUnlock(doc);
158
- return TRUE;
159
- }
160
-
161
- public U0 ClassRep(U8 *_d,U8 *class_name=lastclass,
162
- I64 max_depth=2,Bool fun=FALSE,I64 offset=0)
163
- {//Displays members of a record by using the compiler's info.
164
- CDoc *doc;
165
- if (IsRaw)
166
- doc=DocNew;
167
- else {
168
- DocMax;
169
- doc=DocPut;
170
- }
171
- if (fun)
172
- ClassRep2(doc,_d,class_name,0,max_depth,FALSE,HTT_FUN,offset);
173
- else
174
- ClassRep2(doc,_d,class_name,0,max_depth,FALSE,HTT_CLASS,offset);
175
- DocPrint(doc,"\n");
176
- DocRecalc(doc);
177
- if (IsRaw) {
178
- DocDump(doc,100000);
179
- DocDel(doc);
180
- }
181
- }
182
-
183
- public U0 ClassRepD(U8 *_d,U8 *class_name=lastclass,
184
- I64 max_depth=2,Bool fun=FALSE,I64 offset=0)
185
- {//Dynamic ClassRep. Uses hex_ed widgit for live changes.
186
- CDoc *doc;
187
- if (IsRaw)
188
- doc=DocNew;
189
- else {
190
- DocMax;
191
- doc=DocPut;
192
- }
193
- if (fun)
194
- ClassRep2(doc,_d,class_name,0,max_depth,TRUE,HTT_FUN,offset);
195
- else
196
- ClassRep2(doc,_d,class_name,0,max_depth,TRUE,HTT_CLASS,offset);
197
- DocPrint(doc,"\n");
198
- DocRecalc(doc);
199
- if (IsRaw) {
200
- DocDump(doc,100000);
201
- DocDel(doc);
202
- }
203
- }
204
-
205
- U0 UpdateRegVarImg(CHashFun *tmpf,U8 *_b,CTask *task)
206
- {
207
- CMemberLst *ml;
208
- CHashClass *tmpc;
209
- ml=tmpf->member_lst_and_root;
210
- while (ml) {
211
- if (ml->reg!=REG_NONE) {
212
- tmpc=OptClassFwd(ml->member_class);
213
- MemCpy(_b+ml->offset,TaskRegAddr(task,ml->reg),tmpc->size);
214
- }
215
- ml=ml->next;
216
- }
217
- }
218
-
219
- public U0 FunRep(U8 *st,U8 *rbp=NULL,I64 max_depth=2,CTask *task=NULL)
220
- {//Shows names and vals of a fun's local vars using compiler's info.
221
- I64 size;
222
- U8 *img;
223
- CHashFun *tmpf=HashFind(st,Fs->hash_table,HTT_FUN);
224
- CMemberLst *tmpm;
225
- if (tmpf) {
226
- if (rbp) {
227
- if (task) {
228
- //tmpf->size is negative. It's the bottom
229
- //of the fun local var space relative to RBP .
230
- size=tmpf->arg_cnt*8-tmpf->size+16;
231
-
232
- img=MAlloc(size);
233
- MemCpy(img,rbp+tmpf->size,size);
234
- UpdateRegVarImg(tmpf,img-tmpf->size,task);
235
- ClassRep(img-tmpf->size,st,max_depth,TRUE,rbp-img+tmpf->size);
236
- Free(img);
237
- } else
238
- ClassRep(rbp,st,max_depth,TRUE);
239
- } else {
240
- tmpm=tmpf->member_lst_and_root;
241
- while (tmpm) {
242
- if (0<=tmpm->reg<REG_REGS_NUM)
243
- "%08Z %s\n",tmpm->reg,"ST_U64_REGS",tmpm->str;
244
- else
245
- "%08tX %s\n",tmpm->offset,tmpm->str;
246
- tmpm=tmpm->next;
247
- }
248
- "%08tX Stk Size\n",tmpf->size;
249
- }
250
- }
251
- }
252
-
253
- #help_index "Debugging/Unassemble"
254
- public U0 Uf(U8 *st)
255
- {//Unassembles a named fun
256
- I64 i;
257
- CHashSrcSym *tmpf;
258
- CDbgInfo *dbg_info;
259
- if (tmpf=HashFind(st,Fs->hash_table,HTT_FUN|HTT_EXPORT_SYS_SYM)) {
260
- if (tmpf->type&HTT_FUN)
261
- FunRep(st);
262
- if (dbg_info=tmpf->dbg_info) {
263
- i=dbg_info->body[dbg_info->max_line+1-dbg_info->min_line]
264
- -dbg_info->body[0];
265
- Un(dbg_info->body[0],i);
266
- "Code Size:%04X\n",i;
267
- } else
268
- U(HashVal(tmpf));
269
- }
270
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:1a152987b857a13547d2ff3517d60ee8ee9a36901ccc438795396cd493b1dbde
3
+ size 7110
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/ADefine.HC CHANGED
@@ -1,38 +1,3 @@
1
- #help_index "Define;Char/Define"
2
-
3
- U0 LoadDocDefines()
4
- {
5
- CBinFile *bfh=mem_boot_base-sizeof(CBinFile);
6
-
7
- DefinePrint("DD_OS_NAME_VERSION","TempleOS V%0.2f",sys_os_version);
8
- DefinePrint("DD_TEMPLEOS_AGE","%0.1f",
9
- (Now-Str2Date("8/1/2003"))/ToF64(1<<32)/CDATE_YEAR_DAYS);
10
-
11
- DefinePrint("DD_KERNEL","%08X",bfh);
12
- bfh(I64)+=bfh->file_size-1;
13
- DefinePrint("DD_KERNEL_END","%08X",bfh);
14
-
15
- //$LK,"DD_BOOT_HIGH_LOC_DVD",A="FF:::/Adam/Opt/Boot/BootDVD.HC,DD_BOOT_HIGH_LOC_DVD"$
16
-
17
- $TR,"LineRep"$
18
- $ID,2$DefinePrint("DD_TEMPLEOS_LOC","80,849");
19
- $ID,-2$
20
- DefinePrint("DD_MP_VECT","%08X",MP_VECT_ADDR);
21
- DefinePrint("DD_MP_VECT_END","%08X",
22
- MP_VECT_ADDR+COREAP_16BIT_INIT_END-COREAP_16BIT_INIT-1);
23
-
24
- DefinePrint("DD_SYS_FIXED_AREA_BASE","%08X",SYS_FIXED_AREA);
25
- DefinePrint("DD_SYS_FIXED_AREA_END","%08X",
26
- SYS_FIXED_AREA+sizeof(CSysFixedArea)-1);
27
- DefinePrint("DD_MEM_HEAP_BASE","%08X",mem_heap_base);
28
- DefinePrint("DD_MEM_HEAP_LIMIT","%08X",mem_heap_limit);
29
- DefinePrint("DD_MEM_MIN_MEG","%dMeg",MEM_MIN_MEG);
30
- DefinePrint("DD_UNCACHED_ALIAS","%010X",dev.uncached_alias);
31
- DefinePrint("DD_PHYSICAL_SPACE_END","%010X",
32
- mem_physical_space-1);
33
- DefinePrint("DD_MAPPED_SPACE_END","%010X",
34
- mem_mapped_space-1);
35
- DefinePrint("DD_JIFFY_HZ","%dHz",JIFFY_FREQ);
36
- }
37
-
38
- LoadDocDefines;
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:30bed21fff4a6302c876576568c13ff12e030d8a849bdeca7424a480b14e48f3
3
+ size 1281
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/AExts.HC CHANGED
@@ -1,95 +1,3 @@
1
- extern U0 ACDDef(I64 n,CTask *parent=NULL);
2
- extern U0 ACDDefsPut(CDoc *doc=NULL,U8 *st,I64 num=-1);
3
- extern U0 ACDFillin(I64 n);
4
- extern U0 ACFillIn(I64 n);
5
- extern U0 ACMan(I64 n,CTask *parent_task=NULL);
6
- extern I64 AdamFile(U8 *filename,Bool warn_ext=TRUE);
7
- extern Bool AutoComplete(Bool val=OFF);
8
- extern U0 ClipDel();
9
- extern CCtrl *CtrlFindUnique(CTask *haystack_task,I64 needle_type);
10
- extern Bool CtrlInside(CCtrl *c,I64 x,I64 y);
11
- extern U8 *DC2Sprite(CDC *tmpb);
12
- extern U0 DocBinDel(CDoc *doc,CDocBin *b);
13
- extern U0 DocBinsValidate(CDoc *doc);
14
- extern U0 DocBottom(CDoc *doc=NULL);
15
- extern U0 DocCenter(CDoc *doc=NULL,I64 recalc_flags=RECALCt_NORMAL);
16
- extern U0 DocClear(CDoc *doc=NULL,Bool clear_holds=FALSE);
17
- extern Bool DocCursor(Bool show=OFF,CDoc *doc=NULL);
18
- extern U0 DocD(U8 *buf,I64 cnt=0x80);
19
- extern U0 DocDataFmt(CDoc *doc,CDocEntry *doc_e,I64 d=DOCM_CANCEL);
20
- extern U0 DocDel(CDoc *doc);
21
- extern CDoc *DocDisplay(CTask *task=NULL);
22
- extern U0 DocDump(CDoc *doc,I64 uS_delay=0);
23
- extern CDocEntry *DocEntryCopy(CDoc *doc,CDocEntry *doc_e);
24
- extern U0 DocEntryDel(CDoc *doc,CDocEntry *doc_e);
25
- extern Bool DocForm(U8 *_d,U8 *class_name=lastclass,
26
- I64 dof_flags=0,U8 *header=NULL,U8 *footer=NULL);
27
- extern U0 DocHelpIdx(CDoc *doc,U8 *idx);
28
- extern Bool DocHighlightCursor(Bool show=OFF,CDoc *doc=NULL);
29
- extern U0 DocInsDoc(CDoc *doc=NULL,CDoc *doc2);
30
- extern U0 DocInsEntry(CDoc *doc,CDocEntry *doc_e);
31
- extern Bool DocLock(CDoc *doc);
32
- extern I64 DocMax(I64 i=I64_MAX);
33
- extern CDoc *DocNew(U8 *filename=NULL,CTask *task=NULL);
34
- extern CDocEntry *DocPrint(CDoc *doc=NULL,U8 *fmt,...);
35
- extern CDoc *DocPut(CTask *task=NULL);
36
- extern CDoc *DocRead(U8 *name=NULL,I64 flags=0);
37
- extern Bool DocRecalc(CDoc *doc,I64 recalc_flags=RECALCt_NORMAL);
38
- extern U0 DocRst(CDoc *doc,Bool is_old);
39
- extern CDocEntry *DocSprite(CDoc *doc=NULL,U8 *elems,U8 *fmt=NULL);
40
- extern U0 DocTop(CDoc *doc=NULL);
41
- extern Bool DocUnlock(CDoc *doc);
42
- extern U0 DocUpdateTaskDocs(CTask *task);
43
- extern U0 DrawCtrls(CTask *task);
44
- extern Bool Ed(U8 *link_st,I64 edf_dof_flags=0);
45
- extern U0 EdCodeTools(CDoc *doc);
46
- extern U8 *EdSprite(I64 bin_num);
47
- extern I64 ExeDoc(CDoc *doc,I64 ccf_flags=0);
48
- extern I64 FindWiz();
49
- extern I64 GetI64(U8 *msg=NULL,I64 dft=0,I64 lo=I64_MIN,I64 hi=I64_MAX);
50
- extern Bool GrPlot0(CDC *dc,I64 x,I64 y);
51
- extern CMenuEntry *MenuEntryFind(CMenu *haystack_menu,U8 *needle_full_name);
52
- extern CMenu *MenuFilePush(U8 *filename);
53
- extern U0 MenuPop();
54
- extern CMenu *MenuPush(U8 *st);
55
- extern U8 Mount(Bool caller_is_prtdsk=FALSE);
56
- extern CTask *Noise(I64 mS,F64 min_ona,F64 max_ona);
57
- extern Bool Plain(U8 *filename,I64 edf_dof_flags=0);
58
- extern Bool PopUpCancelOk(U8 *header=NULL,U8 *footer=NULL);
59
- extern I64 PopUpColor(U8 *header=NULL,
60
- Bool allow_transparent=TRUE,Bool allow_dft=TRUE);
61
- extern I64 PopUpColorDither(U8 *header=NULL);
62
- extern I64 PopUpColorLighting(U8 *header=NULL);
63
- extern I64 PopUpFile(U8 *filename,
64
- Bool warn_ext=TRUE,CTask *parent=NULL,CTask **_pu_task=NULL);
65
- extern Bool PopUpForm(U8 *_d,U8 *class_name=lastclass,
66
- I64 dof_flags=DOF_SIZE_MIN,U8 *header=NULL,U8 *footer=NULL);
67
- extern I64 PopUpGetI64(U8 *msg,I64 dft,I64 lo=I64_MIN,I64 hi=I64_MAX);
68
- extern U8 *PopUpGetStr(U8 *header=NULL);
69
- extern I64 PopUpMenu(CDoc *doc,I64 dof_flags=0);
70
- extern Bool PopUpNoYes(U8 *header=NULL,U8 *footer=NULL);
71
- extern Bool PopUpOk(U8 *header=NULL,U8 *footer=NULL);
72
- extern I64 PopUpRangeI64(
73
- I64 lo,I64 hi,I64 step=1,U8 *header=NULL,U8 *footer=NULL);
74
- extern Bool PopUpTransform(I64 *r);
75
- extern I64 RedSeaISO(U8 *_iso_filename=NULL,U8 *_src_dir,
76
- U8 *_stage2_filename=NULL);
77
- extern U0 Refresh(I64 cnt=1,Bool force=FALSE);
78
- extern U0 RegOneTimePopUp(I64 flag_num,U8 *msg);
79
- extern Bool RegWrite(U8 *path,U8 *fmt,...);
80
- extern U0 SettingsPop(CTask *task=NULL,I64 flags=0);
81
- extern CTaskSettings *SettingsPush(CTask *task=NULL,I64 flags=0);
82
- extern U0 TemplateCtrlSlider(CDoc *doc);
83
- extern Bool View();
84
- extern U0 ViewAnglesDel(CTask *task=NULL);
85
- extern CCtrl *ViewAnglesNew(CTask *task=NULL);
86
- extern Bool WinBorder(Bool val=OFF,CTask *task=NULL);
87
- extern CDoc *WinCursorPosSet(CTask *task,I64 msx,I64 msy,Bool set_cursor=TRUE);
88
- extern Bool WinHorz(I64 left,I64 right,CTask *task=NULL);
89
- extern U0 WinMax(CTask *task=NULL);
90
- extern U0 WinScrollNull(CTask *task,CD3I64 *s);
91
- extern U0 WinScrollRestore(CTask *task,CD3I64 *s);
92
- extern U0 WinScrollsInit(CTask *task);
93
- extern I64 WinToTop(CTask *task=NULL,Bool update_z_buf=TRUE);
94
- extern Bool WinVert(I64 top,I64 bottom,CTask *task=NULL);
95
- extern CWinMgrGlbls winmgr;
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:5dc17012fe30bb44a7a5f176461b024a96442f4b8676c6d4337bda7af96d65e7
3
+ size 4478
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/AHash.HC CHANGED
@@ -1,431 +1,3 @@
1
- #help_index "Info;Hash/System;Cmd Line (Typically)"
2
- class CWho
3
- {
4
- CHashGeneric *h;
5
- U8 *idx;
6
- };
7
-
8
- I64 HashEntriesCompare(CWho *h1,CWho *h2)
9
- {
10
- I64 i1,i2;
11
- if (i1=StrCmp(h1->h->str,h2->h->str))
12
- return i1;
13
- i1=HashTypeNum(h1->h);
14
- i2=HashTypeNum(h2->h);
15
- return i1-i2;
16
- }
17
-
18
- I64 HashEntriesCompare2(CWho *h1,CWho *h2)
19
- {
20
- CHashFun *tmpf1=h1->h,*tmpf2=h2->h;
21
- I64 i1=HashVal(tmpf1),i2=HashVal(tmpf2);
22
- if (i1==i2) {
23
- i1=HashTypeNum(tmpf1);
24
- i2=HashTypeNum(tmpf2);
25
- if (i1==i2)
26
- return StrCmp(tmpf1->str,tmpf2->str);
27
- }
28
- return i1-i2;
29
- }
30
-
31
- I64 HelpIndexCnt(U8 *ptr,U8 *idx)
32
- {
33
- I64 cnt=0,ch,idx_len=StrLen(idx);
34
- while (*ptr) {
35
- if (!StrNCmp(ptr,idx,idx_len))
36
- cnt++;
37
- while (ch=*ptr++)
38
- if (ch==';')
39
- break;
40
- if (!ch)
41
- ptr--;
42
- }
43
- return cnt;
44
- }
45
-
46
- U8 *HelpIndexStr(U8 **_ptr,U8 *idx)
47
- {
48
- U8 *ptr=*_ptr,*ptr2,*res;
49
- I64 ch,idx_len=StrLen(idx);
50
- while (*ptr) {
51
- ptr2=ptr;
52
- while (ch=*ptr++)
53
- if (ch==';')
54
- break;
55
- if (!ch)
56
- ptr--;
57
- *_ptr=ptr;
58
- if (!StrNCmp(ptr2,idx,idx_len)) {
59
- if (ch==';')
60
- ptr--;
61
- *ptr=0;
62
- res=StrNew(ptr2);
63
- *ptr=ch;
64
- return res;
65
- }
66
- }
67
- return NULL;
68
- }
69
-
70
- U8 *HelpComment(CTask *task,CHash *tmph,U8 *_src_link)
71
- {
72
- CDoc *doc;
73
- CDocEntry *doc_e;
74
- U8 *res=NULL,*ptr,*ptr2,*src_link=StrNew(_src_link);
75
-
76
- if (*src_link=='F' && src_link[2]==':')
77
- *src_link='P';
78
- XTalkWait(task,"Ed(0x%X,DOF_DONT_WINMGR_SYNC|DOF_DONT_SHOW);\n",src_link);
79
- Free(src_link);
80
-
81
- doc=DocPut(task);
82
- doc_e=doc->cur_entry;
83
- if (tmph->type&HTT_FUN) {
84
- if (Bt(&tmph(CHashFun *)->flags,Ff__EXTERN) ||
85
- Bt(&tmph(CHashFun *)->flags,Ff_INTERNAL))
86
- while (doc_e!=doc &&
87
- (!(doc_e->de_flags&DOCEF_TAG)||!StrOcc(doc_e->tag,';')))
88
- doc_e=doc_e->next;
89
- else
90
- while (doc_e!=doc &&
91
- (!(doc_e->de_flags&DOCEF_TAG)||!StrOcc(doc_e->tag,'{')))
92
- doc_e=doc_e->next;
93
- }
94
- if (doc_e!=doc) {
95
- if (doc_e->de_flags&DOCEF_TAG) {
96
- ptr=doc_e->tag;
97
- if (ptr2=StrMatch("//",ptr))
98
- ptr=ptr2+2;
99
- else if (ptr2=StrMatch("/*",ptr))
100
- ptr=ptr2+2;
101
- else if (!StrNCmp(ptr,"public",6))
102
- ptr+=6;
103
- while (*ptr==CH_SPACE)
104
- ptr++;
105
- res=StrNew(ptr);
106
- doc_e=doc_e->next;
107
- }
108
- while (doc_e!=doc && doc_e->type_u8!=DOCT_NEW_LINE) {
109
- if (doc_e->type_u8==DOCT_TAB) {
110
- ptr=MStrPrint("%s ",res);
111
- Free(res);
112
- res=ptr;
113
- } else if (doc_e->de_flags&DOCEF_TAG) {
114
- ptr=MStrPrint("%s%s",res,doc_e->tag);
115
- Free(res);
116
- res=ptr;
117
- }
118
- doc_e=doc_e->next;
119
- }
120
- }
121
- XTalkWait(task,"%c",CH_SHIFT_ESC);
122
- if (res) {
123
- ptr=MStrUtil(res,SUF_REM_TRAILING|SUF_REM_LEADING|SUF_SINGLE_SPACE);
124
- Free(res);
125
- res=ptr;
126
- }
127
- return res;
128
- }
129
-
130
- I64 HashEntriesCompare3(CWho *h1,CWho *h2)
131
- {
132
- I64 i,i1=0,i2=0;
133
- i=StrCmp(h1->idx,h2->idx);
134
- if (i)
135
- return i;
136
- else {
137
- if (h1->h->type&HTT_HELP_FILE)
138
- i1=1;
139
- if (h2->h->type&HTT_HELP_FILE)
140
- i2=1;
141
- i=i2-i1;
142
- if (i)
143
- return i;
144
- else
145
- return StrCmp(h1->h->str,h2->h->str);
146
- }
147
- }
148
-
149
- public U0 Who(U8 *fu_flags=NULL,CHashTable *h=NULL,
150
- U8 *idx=NULL,CDoc *doc=NULL)
151
- {//Dump hash symbol table.
152
- // "+p" for only public symbols
153
- // "+m" to order by number (normally alphabetical)
154
- // "-r" just local hash table
155
- CHashTable *table;
156
- CHashSrcSym *tmph;
157
- CHashGeneric *ptr;
158
- CWho *lst;
159
- I64 cnt,i,j,k,f=0;
160
- U8 buf[512],*last_idx=StrNew(""),*cur_idx,*comment;
161
- Bool recurse,publics,map;
162
- CTask *task;
163
-
164
- ScanFlags(&f,Define("ST_FILE_UTIL_FLAGS"),"+r");
165
- ScanFlags(&f,Define("ST_FILE_UTIL_FLAGS"),fu_flags);
166
- if (f&~(FUF_RECURSE|FUF_PUBLIC|FUF_MAP))
167
- throw('FUF');
168
- recurse=Bt(&f,FUf_RECURSE);
169
- publics=Bt(&f,FUf_PUBLIC);
170
- map =Bt(&f,FUf_MAP);
171
-
172
- if (!h) h=Fs->hash_table;
173
-
174
- if (idx) {
175
- task=User;
176
- TaskWait(task);
177
- LBtr(&task->display_flags,DISPLAYf_SHOW);
178
- } else
179
- task=NULL;
180
-
181
- cnt=0;
182
- table=h;
183
- while (table) {
184
- for (i=0;i<=table->mask;i++) {
185
- tmph=table->body[i];
186
- while (tmph) {
187
- if (!(tmph->type & (HTF_IMPORT | HTF_PRIVATE)) &&
188
- (tmph->type & HTF_PUBLIC || !publics)) {
189
- if (!idx)
190
- cnt++;
191
- else if (tmph->type&HTG_SRC_SYM && (cur_idx=tmph->idx))
192
- cnt+=HelpIndexCnt(cur_idx,idx);
193
- }
194
- tmph=tmph->next;
195
- }
196
- }
197
- if (recurse)
198
- table=table->next;
199
- else
200
- break;
201
- }
202
- if (!cnt) goto wh_done;
203
-
204
- lst=CAlloc(cnt*sizeof(CWho));
205
- j=0;
206
- table=h;
207
- while (table) {
208
- for (i=0;i<=table->mask;i++) {
209
- tmph=table->body[i];
210
- while (tmph) {
211
- if (!(tmph->type & (HTF_IMPORT | HTF_PRIVATE)) &&
212
- (tmph->type & HTF_PUBLIC || !publics))
213
- if (!idx)
214
- lst[j++].h=tmph;
215
- else if (tmph->type&HTG_SRC_SYM && (cur_idx=tmph->idx) &&
216
- (k=HelpIndexCnt(cur_idx,idx)))
217
- while (k--) {
218
- lst[j].idx=HelpIndexStr(&cur_idx,idx);
219
- lst[j++].h=tmph;
220
- }
221
- tmph=tmph->next;
222
- }
223
- }
224
- if (recurse)
225
- table=table->next;
226
- else
227
- break;
228
- }
229
-
230
- if (map)
231
- QSort(lst,cnt,sizeof(CWho),&HashEntriesCompare2);
232
- else if (idx)
233
- QSort(lst,cnt,sizeof(CWho),&HashEntriesCompare3);
234
- else
235
- QSort(lst,cnt,sizeof(CWho),&HashEntriesCompare);
236
-
237
- if (idx) {
238
- progress1_max=cnt;
239
- progress1=0;
240
- }
241
- for (i=0;i<cnt;i++) {
242
- comment=NULL;
243
- ptr=lst[i].h;
244
- if (idx)
245
- if (cur_idx=lst[i].idx) {
246
- if (StrCmp(cur_idx,last_idx)) {
247
- Free(last_idx);
248
- last_idx=StrNew(cur_idx);
249
- if (i)
250
- DocPrint(doc,"\n\n");
251
- DocPrint(doc,"$$WW,0$$$$PURPLE$$$$TX+CX,\"%$$Q\"$$$$FG$$\n",cur_idx);
252
- }
253
- }
254
-
255
- if (idx && ptr->type & HTT_HELP_FILE) {
256
- DocPrint(doc,"$$WW,1$$");
257
- DocType(doc,ptr->str);
258
- DocPrint(doc,"$$WW,0$$");
259
- } else {
260
- if (ptr->type&HTG_SRC_SYM && ptr(CHashSrcSym *)->src_link) {
261
- DocPrint(doc,"$$LK,\"%-20s\",A=\"%s\"$$",
262
- ptr->str,ptr(CHashSrcSym *)->src_link);
263
- if (idx)
264
- comment=HelpComment(task,ptr,ptr(CHashSrcSym *)->src_link);
265
- } else
266
- DocPrint(doc,"%-20s",ptr->str);
267
-
268
- if (!idx) {
269
- if (ptr->type & HTT_DEFINE_STR) {
270
- j=ptr(CHashDefineStr *)->cnt;
271
- if (j==-1)
272
- StrPrint(buf,"%-10t$$Q ",ptr(CHashDefineStr *)->data);
273
- else
274
- StrPrint(buf,"%-10t$$Q %02X",ptr(CHashDefineStr *)->data,j);
275
- } else if (ptr->type & HTT_GLBL_VAR)
276
- StrPrint(buf,"%010X ",ptr(CHashGlblVar *)->data_addr);
277
- else
278
- StrPrint(buf,"%010X ",HashVal(ptr));
279
- j=HashEntrySize(ptr);
280
- if (j==-1)
281
- CatPrint(buf," %04X ",ptr->use_cnt);
282
- else
283
- CatPrint(buf," %04X %010X ",ptr->use_cnt,j);
284
- } else
285
- *buf=0;
286
-
287
- k=ptr->type;
288
- if (publics)
289
- k&=~HTF_PUBLIC;
290
- if (!(k&HTG_TYPE_MASK))
291
- CatPrint(buf,"NULL ");
292
- while (k) {
293
- j=Bsf(k);
294
- if (j<0)
295
- break;
296
- Btr(&k,j);
297
- CatPrint(buf,"%Z ",j,"ST_HTT_TYPES");
298
- }
299
- DocPrint(doc,"%s",buf);
300
- if (comment) {
301
- DocPrint(doc,"$$GREEN$$%s$$FG$$",comment);
302
- Free(comment);
303
- }
304
- DocPrint(doc,"\n");
305
- }
306
- Free(lst[i].idx);
307
- if (idx)
308
- progress1++;
309
- }
310
- Free(lst);
311
- if (idx)
312
- progress1=progress1_max=0;
313
-
314
- wh_done:
315
- if (doc) {
316
- if (doc->head.next==doc)
317
- DocPrint(doc,"No Match");
318
- else
319
- DocRecalc(doc);
320
- }
321
- Free(last_idx);
322
- Kill(task);
323
- }
324
-
325
- #help_index "Info;Hash;Cmd Line (Typically)"
326
-
327
- #define HDR_NUM 16
328
- public I64 HashDepthRep(CHashTable *table=NULL)
329
- {//Hash table linked-list chain depth report.
330
- //Histogram of collision count.
331
- I64 i,j,longest=0,cnt=0,a[HDR_NUM];
332
- CHash *tmph;
333
- if (!table) table=Fs->hash_table;
334
- MemSet(a,0,sizeof(a));
335
- for (i=0;i<=table->mask;i++) {
336
- tmph=table->body[i];
337
- if (tmph) {
338
- j=LinkedLstCnt(tmph);
339
- if (j<HDR_NUM)
340
- a[j]++;
341
- cnt+=j;
342
- if (j>longest)
343
- longest=j;
344
- }
345
- }
346
- "Histogram\n";
347
- for (i=0;i<HDR_NUM;i++)
348
- if (a[i])
349
- "%02d:%d\n",i,a[i];
350
- "Size:%d Count:%d Longest:%d\n",
351
- table->mask+1,cnt,longest;
352
- return longest;
353
- }
354
-
355
- #help_index "Help System"
356
- #help_file "::/Doc/HelpSystem"
357
-
358
- public U0 DocHelpIdx(CDoc *doc,U8 *idx)
359
- {//Put to doc report for given help idx.
360
- Who("+p",,idx,doc);
361
- }
362
-
363
- public U0 PopUpHelpIndex(U8 *idx,CTask *parent=NULL)
364
- {//PopUp win report for given help idx.
365
- U8 *buf;
366
- buf=MStrPrint("DocHelpIdx(DocPut,\"%s\");View;",idx);
367
- PopUp(buf,parent);
368
- Free(buf);
369
- }
370
-
371
- #help_index "Hash/System"
372
- public U0 MapFileLoad(U8 *filename)
373
- {//Load map file so we have src line info.
374
- U8 *st,*ptr,*name=ExtDft(filename,"MAP.Z"),
375
- *absname=FileNameAbs(name);
376
- CDoc *doc=DocRead(name);
377
- CDocEntry *doc_e;
378
- CHashSrcSym *tmph;
379
- I64 i,j,base=0;
380
- CDbgInfo *dbg_info;
381
-
382
- FileExtRem(absname);
383
- if (absname[1]==':' && StrLen(absname)>2 &&
384
- (tmph=HashSingleTableFind(absname+2,Fs->hash_table,HTT_MODULE)))
385
- base=tmph(CHashGeneric *)->user_data0+sizeof(CBinFile);
386
-
387
- if (!doc) return;
388
- doc_e=doc->head.next;
389
- while (doc_e!=doc) {
390
- if (doc_e->type_u8==DOCT_LINK) {
391
- if (*doc_e->tag)
392
- st=MStrUtil(doc_e->tag,SUF_REM_TRAILING);
393
- else
394
- st=MStrUtil(doc_e->aux_str,SUF_REM_TRAILING);
395
- if (tmph=HashSingleTableFind(st,Fs->hash_table,HTG_SRC_SYM)) {
396
- if (*doc_e->tag) {
397
- Free(tmph->src_link);
398
- tmph->src_link=doc_e->aux_str;
399
- ptr=tmph->src_link;
400
- if (ptr[0] && ptr[1] && ptr[2]==':') {
401
- if (ptr[3]==':')
402
- ptr[3]=blkdev.boot_drv_let;
403
- else if (ptr[3]=='~')
404
- ptr[3]=*blkdev.home_dir;
405
- }
406
- doc_e->aux_str=NULL;
407
- }
408
- if (tmph->type&(HTT_FUN|HTT_EXPORT_SYS_SYM) &&
409
- !(dbg_info=tmph->dbg_info) && doc_e->bin_data &&
410
- (dbg_info=doc_e->bin_data->data)) {
411
- if (doc_e->bin_data->size>MSize(dbg_info))
412
- "Corrupt Map Entry\n";
413
- else {
414
- doc_e->bin_data->data=NULL;
415
- tmph->dbg_info=dbg_info;
416
- for (i=dbg_info->min_line;i<=dbg_info->max_line+1;i++) {
417
- j=i-dbg_info->min_line;
418
- if (dbg_info->body[j])
419
- dbg_info->body[j]=dbg_info->body[j]+base;
420
- }
421
- }
422
- }
423
- }
424
- Free(st);
425
- }
426
- doc_e=doc_e->next;
427
- }
428
- DocDel(doc);
429
- Free(name);
430
- Free(absname);
431
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:71e286112d3265ddb489b5ca8940c43e6ce8f1b3ad8a83c0d5ac38ddb46d5484
3
+ size 9691
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/AMath.HC CHANGED
@@ -1,135 +1,3 @@
1
- #help_index "Math"
2
- public U0 R2P(F64 *_mag=NULL,F64 *_arg=NULL,F64 x,F64 y)
3
- {//Rect to polar
4
- //Returns angle in range (-�,�]
5
- if (_arg)
6
- *_arg=Arg(x,y);
7
- if (_mag)
8
- *_mag=Sqrt(x*x+y*y);
9
- }
10
-
11
- public U0 P2R(F64 *_x=NULL,F64 *_y=NULL,F64 mag,F64 arg)
12
- {//Polar to Rect
13
- if (_x)
14
- *_x=mag*Cos(arg);
15
- if (_y)
16
- *_y=mag*Sin(arg);
17
- }
18
-
19
- public F64 Wrap(F64 �,F64 base=-�)
20
- {//Returns angle in range [base,base+2*�)
21
- F64 res=�%(2*�);
22
- if (res>=base+2*�)
23
- res-=2*�;
24
- else if (res<base)
25
- res+=2*�;
26
- return res;
27
- }
28
-
29
- public I64 DistSqrI64(I64 x1,I64 y1,I64 x2,I64 y2)
30
- {//Distance-squared between 2 points.
31
- I64 dx=x1-x2,dy=y1-y2;
32
- return dx*dx+dy*dy;
33
- }
34
-
35
- public F64 ASin(F64 s)
36
- {//Arc Sin (Inverse Sin).
37
- F64 c;
38
- c=s*s;
39
- if (c>=1.0)
40
- return �/2.0;
41
- c=Sqrt(1.0-c);
42
- return ATan(s/c);
43
- }
44
-
45
- public F64 ACos(F64 c)
46
- {//Arc Cos (Inverse Cos).
47
- F64 s;
48
- if (!c)
49
- return �/2.0;
50
- s=c*c;
51
- if (s>=1.0)
52
- return 0.0;
53
- s=Sqrt(1.0-s);
54
- return ATan(s/c);
55
- }
56
-
57
- public F64 Sinh(F64 x)
58
- {//Hyperbolic Sine.
59
- return 0.5*(Exp(x)-Exp(-x));
60
- }
61
-
62
- public F64 Cosh(F64 x)
63
- {//Hyperbolic Cosine.
64
- return 0.5*(Exp(x)+Exp(-x));
65
- }
66
-
67
- #help_index "Math/Complex;Data Types/Complex"
68
- public Complex *CAdd(Complex *sum,Complex *n1,Complex *n2)
69
- {//sum=n1+n2
70
- sum->x=n1->x+n2->x;
71
- sum->y=n1->y+n2->y;
72
- return sum;
73
- }
74
-
75
- public Complex *CSub(Complex *diff,Complex *n1,Complex *n2)
76
- {//diff=n1-n2
77
- diff->x=n1->x-n2->x;
78
- diff->y=n1->y-n2->y;
79
- return diff;
80
- }
81
-
82
- public Complex *CMul(Complex *prod,Complex *n1,Complex *n2)
83
- {//prod=n1*n2
84
- prod->x=n1->x*n2->x-n1->y*n2->y;
85
- prod->y=n1->x*n2->y+n1->y*n2->x;
86
- return prod;
87
- }
88
-
89
- public Complex *CDiv(Complex *quot,Complex *n1,Complex *n2)
90
- {//quot=n1/n2
91
- F64 m1,arg1,m2,arg2;
92
- R2P(&m1,&arg1,n1->x,n1->y);
93
- R2P(&m2,&arg2,n2->x,n2->y);
94
- m1/=m2;
95
- arg1-=arg2;
96
- quot->x=m1*Cos(arg1);
97
- quot->y=m1*Sin(arg1);
98
- return quot;
99
- }
100
-
101
- public Complex *CScale(Complex *dst,F64 s)
102
- {//dst*=s
103
- dst->x*=s;
104
- dst->y*=s;
105
- return dst;
106
- }
107
-
108
- public Complex *CCopy(Complex *dst,Complex *src)
109
- {//dst=src
110
- dst->x=src->x;
111
- dst->y=src->y;
112
- return dst;
113
- }
114
-
115
- public Complex *CEqu(Complex *dst,F64 x,F64 y)
116
- {//dst=(x,y)
117
- dst->x=x;
118
- dst->y=y;
119
- return dst;
120
- }
121
-
122
- public Complex *CPoly(Complex *dst,I64 n,Complex *zeros,Complex *x)
123
- {//Eval complex polynomial
124
- I64 i;
125
- Complex n1,n2;
126
- if (n>0) {
127
- CSub(dst,x,&zeros[0]);
128
- for (i=1;i<n;i++) {
129
- CCopy(&n1,dst);
130
- CMul(dst,&n1,CSub(&n2,x,&zeros[i]));
131
- }
132
- } else
133
- CEqu(dst,1.0,0.0);
134
- return dst;
135
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:3023888ca30f37c76548ffb67593a5a3d3ccbcb272205b9029081aa75adb88d9
3
+ size 2458
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/AMathODE.HC CHANGED
@@ -1,688 +1,3 @@
1
- #help_index "Math/ODE"
2
- #help_file "::/Doc/ODE"
3
-
4
- //See $LK,"::/Doc/Credits.DD"$.
5
-
6
- F64 LowPass1(F64 a,F64 y0,F64 y,F64 dt=1.0)
7
- {//First order low pass filter
8
- dt=Exp(-a*dt);
9
- return y0*dt+y*(1.0-dt);
10
- }
11
-
12
- U0 ODERstPtrs(CMathODE *ode)
13
- {
14
- I64 s=ode->n_internal*sizeof(F64);
15
- F64 *ptr=ode->array_base;
16
- ode->state_internal=ptr; ptr(I64)+=s;
17
- ode->state_scale=ptr; ptr(I64)+=s;
18
- ode->DstateDt=ptr; ptr(I64)+=s;
19
- ode->initial_state=ptr; ptr(I64)+=s;
20
- ode->tmp0=ptr; ptr(I64)+=s;
21
- ode->tmp1=ptr; ptr(I64)+=s;
22
- ode->tmp2=ptr; ptr(I64)+=s;
23
- ode->tmp3=ptr; ptr(I64)+=s;
24
- ode->tmp4=ptr; ptr(I64)+=s;
25
- ode->tmp5=ptr; ptr(I64)+=s;
26
- ode->tmp6=ptr; ptr(I64)+=s;
27
- ode->tmp7=ptr;
28
- }
29
-
30
- public CMathODE *ODENew(I64 n,F64 max_tolerance=1e-6,I64 flags=0)
31
- {//Make differential equation ctrl struct. See $LK,"flags",A="MN:ODEF_HAS_MASSES"$.
32
- //The tolerance is not precise.
33
- //You can min_tolerance and it will
34
- //dynamically adjust tolerance to utilize
35
- //the CPU.
36
- I64 s=n*sizeof(F64);
37
- CMathODE *ode=CAlloc(sizeof(CMathODE));
38
- ode->t_scale=1.0;
39
- ode->flags=flags;
40
- ode->n_internal=ode->n=n;
41
- ode->h=1e-6;
42
- ode->h_min=1e-64;
43
- ode->h_max=1e32;
44
- ode->max_tolerance=ode->min_tolerance=ode->tolerance_internal=max_tolerance;
45
- ode->win_task=ode->mem_task=Fs;
46
- QueInit(&ode->next_mass);
47
- QueInit(&ode->next_spring);
48
- ode->state=CAlloc(s);
49
- ode->array_base=MAlloc(12*s);
50
- ODERstPtrs(ode);
51
- return ode;
52
- }
53
-
54
-
55
- public Bool ODEPause(CMathODE *ode,Bool val=ON)
56
- {//Pause ODE.
57
- Bool res;
58
- if (!ode) return OFF;
59
- res=LBEqu(&ode->flags,ODEf_PAUSED,val);
60
- if (val)
61
- while (Bt(&ode->flags,ODEf_BUSY))
62
- Yield;
63
- return res;
64
- }
65
-
66
- public U0 ODEDel(CMathODE *ode)
67
- {//Free ODE node, but not masses or springs.
68
- I64 i;
69
- if (!ode) return;
70
- ODEPause(ode);
71
- Free(ode->state);
72
- Free(ode->array_base);
73
- if (ode->slave_tasks) {
74
- for (i=0;i<mp_cnt;i++)
75
- Kill(ode->slave_tasks[i]);
76
- Free(ode->slave_tasks);
77
- }
78
- Free(ode);
79
- }
80
-
81
- public I64 ODESize(CMathODE *ode)
82
- {//Mem size of ode ctrl, but not masses and springs.
83
- if (!ode)
84
- return 0;
85
- else
86
- return MSize2(ode->state)+MSize2(ode->array_base)+MSize2(ode);
87
- }
88
-
89
- U0 ODESetMassesPtrs(CMathODE *ode,F64 *state,F64 *DstateDt)
90
- {
91
- COrder2D3 *ptr1=state(F64 *)+ode->n,
92
- *ptr2=DstateDt(F64 *)+ode->n;
93
- CMass *tmpm=ode->next_mass;
94
- while (tmpm!=&ode->next_mass) {
95
- tmpm->state=ptr1++;
96
- tmpm->DstateDt=ptr2++;
97
- tmpm=tmpm->next;
98
- }
99
- }
100
-
101
- U0 ODEState2Internal(CMathODE *ode)
102
- {
103
- CMass *tmpm;
104
- F64 *old_array_base;
105
- I64 mass_cnt;
106
-
107
- if (ode->flags&ODEF_HAS_MASSES) {
108
- mass_cnt=0;
109
- tmpm=ode->next_mass;
110
- while (tmpm!=&ode->next_mass) {
111
- mass_cnt++;
112
- tmpm=tmpm->next;
113
- }
114
- old_array_base=ode->array_base;
115
- ode->n_internal=ode->n+6*mass_cnt;
116
- ode->array_base=MAlloc(12*ode->n_internal*sizeof(F64),ode->mem_task);
117
- Free(old_array_base);
118
- ODERstPtrs(ode);
119
-
120
- ODESetMassesPtrs(ode,ode->state_internal,ode->state_internal);
121
- tmpm=ode->next_mass;
122
- while (tmpm!=&ode->next_mass) {
123
- MemCpy(tmpm->state,&tmpm->saved_state,sizeof(COrder2D3));
124
- tmpm=tmpm->next;
125
- }
126
- }
127
- MemCpy(ode->state_internal,ode->state,ode->n*sizeof(F64));
128
- }
129
-
130
- U0 ODEInternal2State(CMathODE *ode)
131
- {
132
- CMass *tmpm;
133
- MemCpy(ode->state,ode->state_internal,ode->n*sizeof(F64));
134
- if (ode->flags&ODEF_HAS_MASSES) {
135
- ODESetMassesPtrs(ode,ode->state_internal,ode->state_internal);
136
- tmpm=ode->next_mass;
137
- while (tmpm!=&ode->next_mass) {
138
- MemCpy(&tmpm->saved_state,tmpm->state,sizeof(COrder2D3));
139
- tmpm=tmpm->next;
140
- }
141
- }
142
- }
143
-
144
- public U0 ODERenum(CMathODE *ode)
145
- {//Renumber masses and springs.
146
- I64 i;
147
- CSpring *tmps;
148
- CMass *tmpm;
149
-
150
- i=0;
151
- tmpm=ode->next_mass;
152
- while (tmpm!=&ode->next_mass) {
153
- tmpm->num=i++;
154
- tmpm=tmpm->next;
155
- }
156
-
157
- i=0;
158
- tmps=ode->next_spring;
159
- while (tmps!=&ode->next_spring) {
160
- tmps->num=i++;
161
- tmps->end1_num=tmps->end1->num;
162
- tmps->end2_num=tmps->end2->num;
163
- tmps=tmps->next;
164
- }
165
- }
166
-
167
- public CMass *MassFind(CMathODE *ode,F64 x,F64 y,F64 z=0)
168
- {//Search for mass nearest to x,y,z.
169
- CMass *tmpm,*best_mass=NULL;
170
- F64 dd,best_dd=F64_MAX;
171
-
172
- tmpm=ode->next_mass;
173
- while (tmpm!=&ode->next_mass) {
174
- dd=Sqr(tmpm->x-x)+Sqr(tmpm->y-y)+Sqr(tmpm->z-z);
175
- if (dd<best_dd) {
176
- best_dd=dd;
177
- best_mass=tmpm;
178
- }
179
- tmpm=tmpm->next;
180
- }
181
- return best_mass;
182
- }
183
-
184
- public CSpring *SpringFind(CMathODE *ode,F64 x,F64 y,F64 z=0)
185
- {//Find spring midpoint nearest x,y,z.
186
- CSpring *tmps,*best_spring=NULL;
187
- F64 dd,best_dd=F64_MAX;
188
-
189
- tmps=ode->next_spring;
190
- while (tmps!=&ode->next_spring) {
191
- dd=Sqr((tmps->end1->x+tmps->end2->x)/2-x)+
192
- Sqr((tmps->end1->y+tmps->end2->y)/2-y)+
193
- Sqr((tmps->end1->z+tmps->end2->z)/2-z);
194
- if (dd<best_dd) {
195
- best_dd=dd;
196
- best_spring=tmps;
197
- }
198
- tmps=tmps->next;
199
- }
200
- return best_spring;
201
- }
202
-
203
- public U0 MassOrSpringFind(
204
- CMathODE *ode,CMass **res_mass,CSpring **res_spring,
205
- F64 x,F64 y,F64 z=0)
206
- {//Find spring or mass nearest x,y,z.
207
- CMass *tmpm,*best_mass=NULL;
208
- CSpring *tmps,*best_spring=NULL;
209
- F64 dd,best_dd=F64_MAX;
210
-
211
- tmpm=ode->next_mass;
212
- while (tmpm!=&ode->next_mass) {
213
- dd=Sqr(tmpm->x-x)+Sqr(tmpm->y-y)+Sqr(tmpm->z-z);
214
- if (dd<best_dd) {
215
- best_dd=dd;
216
- best_mass=tmpm;
217
- }
218
- tmpm=tmpm->next;
219
- }
220
-
221
- tmps=ode->next_spring;
222
- while (tmps!=&ode->next_spring) {
223
- dd=Sqr((tmps->end1->x+tmps->end2->x)/2-x)+
224
- Sqr((tmps->end1->y+tmps->end2->y)/2-y)+
225
- Sqr((tmps->end1->z+tmps->end2->z)/2-z);
226
- if (dd<best_dd) {
227
- best_dd=dd;
228
- best_spring=tmps;
229
- best_mass=NULL;
230
- }
231
- tmps=tmps->next;
232
- }
233
- if (res_mass) *res_mass =best_mass;
234
- if (res_spring) *res_spring=best_spring;
235
- }
236
-
237
- public CMass *MassFindNum(CMathODE *ode,I64 num)
238
- {//Return mass number N.
239
- CMass *tmpm=ode->next_mass;
240
- while (tmpm!=&ode->next_mass) {
241
- if (tmpm->num==num)
242
- return tmpm;
243
- tmpm=tmpm->next;
244
- }
245
- return NULL;
246
- }
247
-
248
- public U0 ODERstInactive(CMathODE *ode)
249
- {//Set all masses and springs to ACTIVE for new trial.
250
- CMass *tmpm;
251
- CSpring *tmps;
252
- tmpm=ode->next_mass;
253
- while (tmpm!=&ode->next_mass) {
254
- tmpm->flags&=~MSF_INACTIVE;
255
- tmpm=tmpm->next;
256
- }
257
- tmps=ode->next_spring;
258
- while (tmps!=&ode->next_spring) {
259
- tmps->flags&=~SSF_INACTIVE;
260
- tmps=tmps->next;
261
- }
262
- }
263
-
264
- U0 ODECalcSprings(CMathODE *ode)
265
- {
266
- CSpring *tmps=ode->next_spring;
267
- CMass *e1,*e2;
268
- F64 d;
269
- CD3 p;
270
- while (tmps!=&ode->next_spring) {
271
- if (tmps->flags&SSF_INACTIVE) {
272
- tmps->displacement=0;
273
- tmps->f=0;
274
- } else {
275
- e1=tmps->end1;
276
- e2=tmps->end2;
277
- d=D3Norm(D3Sub(&p,&e2->state->x,&e1->state->x));
278
- tmps->displacement=d-tmps->rest_len;
279
- tmps->f=tmps->displacement*tmps->const;
280
- if (tmps->f>0 && tmps->flags&SSF_NO_TENSION)
281
- tmps->f=0;
282
- else if (tmps->f<0 && tmps->flags&SSF_NO_COMPRESSION)
283
- tmps->f=0;
284
- if (d>0) {
285
- D3MulEqu(&p,tmps->f/d);
286
- D3AddEqu(&e1->DstateDt->DxDt,&p);
287
- D3SubEqu(&e2->DstateDt->DxDt,&p);
288
- }
289
- }
290
- tmps=tmps->next;
291
- }
292
- }
293
-
294
- U0 ODECalcDrag(CMathODE *ode)
295
- {
296
- CMass *tmpm;
297
- F64 d,dd;
298
- CD3 p;
299
- if (ode->drag_v || ode->drag_v2 || ode->drag_v3) {
300
- tmpm=ode->next_mass;
301
- while (tmpm!=&ode->next_mass) {
302
- if (!(tmpm->flags & MSF_INACTIVE) &&
303
- tmpm->drag_profile_factor &&
304
- (dd=D3NormSqr(&tmpm->state->DxDt))) {
305
- d=ode->drag_v;
306
- if (ode->drag_v2)
307
- d+=ode->drag_v2*Sqrt(dd);
308
- if (ode->drag_v3)
309
- d+=dd*ode->drag_v3;
310
- D3SubEqu(&tmpm->DstateDt->DxDt,
311
- D3Mul(&p,d*tmpm->drag_profile_factor,&tmpm->state->DxDt));
312
- }
313
- tmpm=tmpm->next;
314
- }
315
- }
316
- }
317
-
318
- U0 ODEApplyAccelerationLimit(CMathODE *ode)
319
- {
320
- CMass *tmpm;
321
- F64 d;
322
- if (ode->acceleration_limit) {
323
- tmpm=ode->next_mass;
324
- while (tmpm!=&ode->next_mass) {
325
- if (!(tmpm->flags & MSF_INACTIVE) &&
326
- (d=D3Norm(&tmpm->DstateDt->DxDt))>ode->acceleration_limit)
327
- D3MulEqu(&tmpm->DstateDt->DxDt,ode->acceleration_limit/d);
328
- tmpm=tmpm->next;
329
- }
330
- }
331
- }
332
-
333
- U0 ODEMPTask(CMathODE *ode)
334
- {
335
- while (TRUE) {
336
- while (!Bt(&ode->mp_not_done_flags,Gs->num))
337
- Yield;
338
- if (ode->mp_derive)
339
- (*ode->mp_derive)(ode,ode->mp_t,
340
- Gs->num,ode->mp_state,ode->mp_DstateDt);
341
- LBtr(&ode->mp_not_done_flags,Gs->num);
342
- }
343
- }
344
-
345
- U0 ODEMPWake(CMathODE *ode)
346
- {
347
- I64 i;
348
- if (!ode->slave_tasks) {
349
- ode->slave_tasks=CAlloc(mp_cnt*sizeof(CTask *));
350
- for (i=0;i<mp_cnt;i++)
351
- ode->slave_tasks[i]=Spawn(&ODEMPTask,ode,"ODE Slave",i);
352
- }
353
- for (i=0;i<mp_cnt;i++) {
354
- Suspend(ode->slave_tasks[i],FALSE);
355
- MPInt(I_WAKE,i);
356
- }
357
- }
358
-
359
- U0 ODEMPSleep(CMathODE *ode)
360
- {
361
- I64 i;
362
- if (ode->slave_tasks) {
363
- while (ode->mp_not_done_flags)
364
- Yield;
365
- for (i=0;i<mp_cnt;i++)
366
- Suspend(ode->slave_tasks[i]);
367
- }
368
- }
369
-
370
- U0 ODECallMPDerivative(CMathODE *ode,F64 t,F64 *state,F64 *DstateDt)
371
- {
372
- ode->mp_t=t;
373
- ode->mp_state=state;
374
- ode->mp_DstateDt=DstateDt;
375
- ode->mp_not_done_flags=1<<mp_cnt-1;
376
- do Yield;
377
- while (ode->mp_not_done_flags);
378
- }
379
-
380
- U0 ODECallDerivative(CMathODE *ode,F64 t,F64 *state,F64 *DstateDt)
381
- {
382
- CMass *tmpm;
383
- if (ode->flags&ODEF_HAS_MASSES) {
384
- ODESetMassesPtrs(ode,state,DstateDt);
385
- tmpm=ode->next_mass;
386
- while (tmpm!=&ode->next_mass) {
387
- if (!(tmpm->flags&MSF_INACTIVE)) {
388
- D3Zero(&tmpm->DstateDt->DxDt);
389
- D3Copy(&tmpm->DstateDt->x,&tmpm->state->DxDt);
390
- }
391
- tmpm=tmpm->next;
392
- }
393
- ODECalcSprings(ode);
394
- ODECalcDrag(ode);
395
- if (ode->mp_derive)
396
- ODECallMPDerivative(ode,t,state,DstateDt);
397
- if (ode->derive)
398
- (*ode->derive)(ode,t,state,DstateDt);
399
- tmpm=ode->next_mass;
400
- while (tmpm!=&ode->next_mass) {
401
- if (!(tmpm->flags&MSF_INACTIVE)) {
402
- if (tmpm->flags&MSF_FIXED) {
403
- D3Zero(&tmpm->DstateDt->DxDt);
404
- D3Zero(&tmpm->DstateDt->x);
405
- } else if (tmpm->mass)
406
- D3DivEqu(&tmpm->DstateDt->DxDt,tmpm->mass);
407
- }
408
- tmpm=tmpm->next;
409
- }
410
- ODEApplyAccelerationLimit(ode);
411
- } else {
412
- if (ode->mp_derive)
413
- ODECallMPDerivative(ode,t,state,DstateDt);
414
- if (ode->derive)
415
- (*ode->derive)(ode,t,state,DstateDt);
416
- }
417
- }
418
-
419
- U0 ODEOneStep(CMathODE *ode)
420
- {
421
- I64 i;
422
- ODECallDerivative(ode,ode->t,ode->state_internal,ode->DstateDt);
423
- for (i=0;i<ode->n_internal;i++)
424
- ode->state_internal[i]+=ode->h*ode->DstateDt[i];
425
- ode->t+=ode->h;
426
- }
427
-
428
- U0 ODERK4OneStep(CMathODE *ode)
429
- {
430
- I64 i,n=ode->n_internal;
431
- F64 xh,hh,h6,*dym,*dyt,*yt,*DstateDt;
432
-
433
- dym =ode->tmp0;
434
- dyt =ode->tmp1;
435
- yt =ode->tmp2;
436
- DstateDt=ode->tmp3;
437
- hh =0.5*ode->h;
438
- h6 =ode->h / 6.0;
439
- xh =ode->t + hh;
440
-
441
- ODECallDerivative(ode,ode->t,ode->state_internal,ode->DstateDt);
442
- for (i=0;i<n;i++)
443
- yt[i]=ode->state_internal[i]+hh*DstateDt[i];
444
- ODECallDerivative(ode,xh,yt,dyt);
445
- for (i=0;i<n;i++)
446
- yt[i]=ode->state_internal[i]+hh*dyt[i];
447
- ODECallDerivative(ode,xh,yt,dym);
448
- for (i=0;i<n;i++) {
449
- yt[i]=ode->state_internal[i]+ode->h*dym[i];
450
- dym[i]+=dyt[i];
451
- }
452
- ode->t+=ode->h;
453
- ODECallDerivative(ode,ode->t,yt,dyt);
454
- for (i=0;i<n;i++)
455
- ode->state_internal[i]+=h6*(DstateDt[i]+dyt[i]+2.0*dym[i]);
456
- }
457
-
458
- #define ODEa2 0.2
459
- #define ODEa3 0.3
460
- #define ODEa4 0.6
461
- #define ODEa5 1.0
462
- #define ODEa6 0.875
463
- #define ODEb21 0.2
464
- #define ODEb31 (3.0/40.0)
465
- #define ODEb32 (9.0/40.0)
466
- #define ODEb41 0.3
467
- #define ODEb42 (-0.9)
468
- #define ODEb43 1.2
469
- #define ODEb51 (-11.0/54.0)
470
- #define ODEb52 2.5
471
- #define ODEb53 (-70.0/27.0)
472
- #define ODEb54 (35.0/27.0)
473
- #define ODEb61 (1631.0/55296.0)
474
- #define ODEb62 (175.0/512.0)
475
- #define ODEb63 (575.0/13824.0)
476
- #define ODEb64 (44275.0/110592.0)
477
- #define ODEb65 (253.0/4096.0)
478
- #define ODEc1 (37.0/378.0)
479
- #define ODEc3 (250.0/621.0)
480
- #define ODEc4 (125.0/594.0)
481
- #define ODEc6 (512.0/1771.0)
482
- #define ODEdc1 (37.0/378.0-2825.0/27648.0)
483
- #define ODEdc3 (250.0/621.0-18575.0/48384.0)
484
- #define ODEdc4 (125.0/594.0-13525.0/55296.0)
485
- #define ODEdc5 (-277.0/14336.0)
486
- #define ODEdc6 (512.0/1771.0-0.25)
487
-
488
- U0 ODECashKarp(CMathODE *ode)
489
- {
490
- I64 i,n=ode->n_internal;
491
- F64 h=ode->h,*state=ode->state_internal,
492
- *DstateDt=ode->DstateDt,*ak2,*ak3,*ak4,*ak5,*ak6,
493
- *tmpstate,*stateerr,*outstate;
494
-
495
- ak2=ode->tmp0;
496
- ak3=ode->tmp1;
497
- ak4=ode->tmp2;
498
- ak5=ode->tmp3;
499
- ak6=ode->tmp4;
500
- tmpstate=ode->tmp5;
501
- outstate=ode->tmp6;
502
- stateerr=ode->tmp7;
503
-
504
- for (i=0;i<n;i++)
505
- tmpstate[i]=state[i]+ODEb21*h*DstateDt[i];
506
- ODECallDerivative(ode,ode->t+ODEa2*h,tmpstate,ak2);
507
- for (i=0;i<n;i++)
508
- tmpstate[i]=state[i]+h*(ODEb31*DstateDt[i]+ODEb32*ak2[i]);
509
- ODECallDerivative(ode,ode->t+ODEa3*h,tmpstate,ak3);
510
- for (i=0;i<n;i++)
511
- tmpstate[i]=state[i]+h*(ODEb41*DstateDt[i]+ODEb42*ak2[i]+ODEb43*ak3[i]);
512
- ODECallDerivative(ode,ode->t+ODEa4*h,tmpstate,ak4);
513
- for (i=0;i<n;i++)
514
- tmpstate[i]=state[i]+h*(ODEb51*DstateDt[i]+
515
- ODEb52*ak2[i]+ODEb53*ak3[i]+ODEb54*ak4[i]);
516
- ODECallDerivative(ode,ode->t+ODEa5*h,tmpstate,ak5);
517
- for (i=0;i<n;i++)
518
- tmpstate[i]=state[i]+h*(ODEb61*DstateDt[i]+
519
- ODEb62*ak2[i]+ODEb63*ak3[i]+ODEb64*ak4[i]+ODEb65*ak5[i]);
520
- ODECallDerivative(ode,ode->t+ODEa6*h,tmpstate,ak6);
521
-
522
- for (i=0;i<n;i++)
523
- outstate[i]=state[i]+h*(ODEc1*DstateDt[i]+
524
- ODEc3*ak3[i]+ODEc4*ak4[i]+ODEc6*ak6[i]);
525
- for (i=0;i<n;i++)
526
- stateerr[i]=h*(ODEdc1*DstateDt[i]+ODEdc3*ak3[i]+
527
- ODEdc4*ak4[i]+ODEdc5*ak5[i]+ODEdc6*ak6[i]);
528
- }
529
-
530
- #define SAFETY 0.9
531
- #define PGROW (-0.2)
532
- #define PSHRNK (-0.25)
533
- #define ERRCON 1.89e-4
534
-
535
- U0 ODERK5OneStep(CMathODE *ode)
536
- {
537
- I64 i;
538
- F64 errmax,tmp,*tmpstate=ode->tmp6,*stateerr=ode->tmp7;
539
- while (TRUE) {
540
- ode->h=Clamp(ode->h,ode->h_min,ode->h_max);
541
- ODECashKarp(ode);
542
- errmax=0.0;
543
- for (i=0;i<ode->n_internal;i++) {
544
- tmp=Abs(stateerr[i]/ode->state_scale[i]);
545
- if (tmp>errmax)
546
- errmax=tmp;
547
- }
548
- errmax/=ode->tolerance_internal;
549
- if (errmax<=1.0 || ode->h==ode->h_min) break;
550
- tmp=ode->h*SAFETY*errmax`PSHRNK;
551
- if (tmp<0.1*ode->h)
552
- ode->h*=0.1;
553
- else
554
- ode->h=tmp;
555
- }
556
- ode->t+=ode->h;
557
- if (errmax>ERRCON)
558
- ode->h*=SAFETY*errmax`PGROW;
559
- else
560
- ode->h*=5.0;
561
- ode->h=Clamp(ode->h,ode->h_min,ode->h_max);
562
- MemCpy(ode->state_internal,tmpstate,sizeof(F64)*ode->n_internal);
563
- }
564
-
565
- F64 ode_alloced_factor=0.75;
566
-
567
- U0 ODEsUpdate(CTask *task)
568
- {/* This routine is called by the $LK,"window mgr",A="FF:::/Adam/Gr/GrScrn.HC,ODEsUpdate"$on a continuous
569
- basis to allow real-time simulation. It is intended
570
- to provide ress good enough for games. It uses a runge-kutta
571
- integrator which is a better algorithm than doing it with Euler.
572
-
573
- It is adaptive step-sized, so it slows down when an important
574
- event is taking place to improve accuracy, but in my implementation
575
- it has a timeout.
576
- */
577
- I64 i;
578
- F64 d,start_time,timeout_time,t_desired,t_initial,interpolation;
579
- CMathODE *ode;
580
-
581
- if (task->next_ode==&task->next_ode)
582
- task->last_ode_time=0;
583
- else if (!Bt(&task->win_inhibit,WIf_SELF_ODE)) {
584
- //See $LK,"GrUpdateTasks",A="MN:GrUpdateTasks"$() and $LK,"GrUpdateTaskODEs",A="MN:GrUpdateTaskODEs"$().
585
- //We will not pick a time limit based on
586
- //how busy the CPU is, what percent of the
587
- //last refresh cycle was spent on ODE's
588
- //and what the refresh cycle rate was.
589
- start_time=tS;
590
- d=1.0/winmgr.fps;
591
- timeout_time=start_time+
592
- (task->last_ode_time/d+0.1)/(winmgr.last_ode_time/d+0.1)*
593
- ode_alloced_factor*d;
594
- ode=task->next_ode;
595
- while (ode!=&task->next_ode) {
596
- t_initial=ode->t;
597
- d=tS;
598
- if (!(ode->flags&ODEF_STARTED)) {
599
- ode->base_t=d;
600
- ode->flags|=ODEF_STARTED;
601
- }
602
- d-=ode->base_t+t_initial;
603
- t_desired=ode->t_scale*d+t_initial;
604
- if (ode->flags&ODEF_PAUSED)
605
- ode->base_t+=t_desired-ode->t; //Slip
606
- else {
607
- ode->flags|=ODEF_BUSY;
608
- if (ode->flags&ODEF_PAUSED)
609
- ode->base_t+=t_desired-ode->t; //Slip
610
- else {
611
- if (ode->derive || ode->mp_derive) {
612
- if (ode->mp_derive)
613
- ODEMPWake(ode);
614
- ODEState2Internal(ode);
615
- MemCpy(ode->initial_state,ode->state_internal,
616
- ode->n_internal*sizeof(F64));
617
- while (ode->t<t_desired) {
618
- ode->h_max=t_desired-ode->t;
619
- ODECallDerivative(ode,ode->t,ode->state_internal,ode->DstateDt);
620
- for (i=0;i<ode->n_internal;i++)
621
- ode->state_scale[i]=Abs(ode->state_internal[i])+
622
- Abs(ode->DstateDt[i]*ode->h)+ode->tolerance_internal;
623
- ODERK5OneStep(ode);
624
- if (tS>timeout_time) {
625
- ode->base_t+=t_desired-ode->t; //Slip
626
- goto ode_done;
627
-
628
- }
629
- }
630
-
631
- //Interpolate if end time was not exact.
632
- if (ode->t!=t_desired) {
633
- if (interpolation=ode->t-t_initial) {
634
- interpolation=(t_desired-t_initial)/interpolation;
635
- if (interpolation!=1.0)
636
- for (i=0;i<ode->n_internal;i++)
637
- ode->state_internal[i]=(ode->state_internal[i]-
638
- ode->initial_state[i])*interpolation+
639
- ode->initial_state[i];
640
- }
641
- ode->t=t_desired;
642
- }
643
- ode_done:
644
- ODEInternal2State(ode);
645
-
646
- //Convenience call to set vals
647
- ODECallDerivative(ode,ode->t,ode->state_internal,ode->DstateDt);
648
-
649
- if (ode->mp_derive)
650
- ODEMPSleep(ode);
651
- }
652
- }
653
- ode->flags&=~ODEF_BUSY;
654
- }
655
- ode->base_t+=(1.0-ode->t_scale)*d;
656
- ode=ode->next;
657
- }
658
-
659
- //Now, we will dynamically adjust tolerances.
660
-
661
- //We will regulate the tolerances
662
- //to fill the time we decided was
663
- //okay to devote to ODE's.
664
- //Since we might have multiple ODE's
665
- //active we scale them by the same factor.
666
-
667
- //This algorithm is probably not stable or very good, but it's something.
668
-
669
- //Target is 75% of alloced time.
670
- d=(tS-start_time)/(timeout_time-start_time)-0.75;
671
-
672
- ode=task->next_ode;
673
- while (ode!=&task->next_ode) {
674
- if (!(ode->flags&ODEF_PAUSED) && ode->derive) {
675
- if (ode->min_tolerance!=ode->max_tolerance) {
676
- if (d>0)
677
- ode->tolerance_internal*=10.0`d;
678
- else
679
- ode->tolerance_internal*=2.0`d;
680
- }
681
- ode->tolerance_internal=Clamp(ode->tolerance_internal,
682
- ode->min_tolerance,ode->max_tolerance);
683
- }
684
- ode=ode->next;
685
- }
686
- winmgr.ode_time+=task->last_ode_time=tS-start_time;
687
- }
688
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:702ccf50723c83219c1e1dfd4ec33e486fb3f17884107dd0b7fd879404317e99
3
+ size 17606
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/AMem.HC CHANGED
@@ -1,179 +1,3 @@
1
- #help_index "Memory/Task"
2
- public I64 TaskMemAlloced(CTask *task=NULL,Bool override_validate=FALSE)
3
- {//Count of bytes alloced to a task, used+unused.
4
- I64 res;
5
- if (!task) task=Fs;
6
- if (override_validate || TaskValidate(task)) {
7
- res=task->code_heap->alloced_u8s;
8
- if (task->code_heap!=task->data_heap)
9
- res+=task->data_heap->alloced_u8s;
10
- return res;
11
- } else
12
- return 0;
13
- }
14
-
15
- public I64 TaskMemUsed(CTask *task=NULL,Bool override_validate=FALSE)
16
- {//Count of bytes alloced to a task and in use.
17
- I64 res;
18
- if (!task) task=Fs;
19
- if (override_validate || TaskValidate(task)) {
20
- res=task->code_heap->used_u8s;
21
- if (task->data_heap!=task->code_heap)
22
- res+=task->data_heap->used_u8s;
23
- return res;
24
- } else
25
- return 0;
26
- }
27
-
28
- #help_index "Memory/Task;Debugging/Heap;Memory/Debugging"
29
- public Bool HeapRep(CTask *task)
30
- {//Report status of task's heap.
31
- I64 i,cnt;
32
- CMemUnused *uum;
33
-
34
- if (!task || task==Fs) {
35
- "Task can't HeapRep on self.\n";
36
- return FALSE;
37
- }
38
- if (!TaskValidate(task)) return FALSE;
39
-
40
- PUSHFD
41
- CLI
42
- while (LBts(&task->code_heap->locked_flags,HClf_LOCKED))
43
- PAUSE
44
- if (task->data_heap!=task->code_heap)
45
- while (LBts(&task->data_heap->locked_flags,HClf_LOCKED))
46
- PAUSE
47
-
48
- for (i=0;i<MEM_HEAP_HASH_SIZE>>3;i++) {
49
- cnt=0;
50
- uum=task->code_heap->heap_hash[i];
51
- while (uum) {
52
- cnt+=uum->size;
53
- uum=uum->next;
54
- }
55
- if (task->data_heap!=task->code_heap) {
56
- uum=task->data_heap->heap_hash[i];
57
- while (uum) {
58
- cnt+=uum->size;
59
- uum=uum->next;
60
- }
61
- }
62
- if (cnt)
63
- "%03X:%08X\n",i<<3,cnt;
64
- }
65
- '\n';
66
-
67
- uum=task->code_heap->malloc_free_lst;
68
- while (uum) {
69
- "%X, ",uum->size;
70
- uum=uum->next;
71
- }
72
- if (task->data_heap!=task->code_heap) {
73
- uum=task->data_heap->malloc_free_lst;
74
- while (uum) {
75
- "%X, ",uum->size;
76
- uum=uum->next;
77
- }
78
- }
79
-
80
- if (task->data_heap!=task->code_heap)
81
- LBtr(&task->data_heap->locked_flags,HClf_LOCKED);
82
- LBtr(&task->code_heap->locked_flags,HClf_LOCKED);
83
- POPFD
84
-
85
- '\n';
86
- }
87
-
88
- #help_index "Memory/HeapCtrl;Debugging/Heap;Memory/Debugging"
89
- public Bool IsInHeapCtrl(U8 *a,CHeapCtrl *hc,Bool lock=TRUE)
90
- {//Check addr if in HeapCtrl.
91
- CMemBlk *m;
92
- PUSHFD
93
- CLI
94
- if (lock)
95
- while (LBts(&hc->locked_flags,HClf_LOCKED))
96
- PAUSE
97
- m=hc->next_mem_blk;
98
- while (m!=&hc->next_mem_blk) {
99
- if (a>=m && a<m(U8 *)+m->pags<<MEM_PAG_BITS) {
100
- if (lock)
101
- LBtr(&hc->locked_flags,HClf_LOCKED);
102
- POPFD
103
- return TRUE;
104
- }
105
- m=m->next;
106
- }
107
- if (lock)
108
- LBtr(&hc->locked_flags,HClf_LOCKED);
109
- POPFD
110
- return FALSE;
111
- }
112
-
113
- public Bool HeapCtrlWalk(CHeapCtrl *hc)
114
- {//Check integrity of HeapCtrl.
115
- I64 i;
116
- CMemUnused *uum;
117
-
118
- PUSHFD
119
- CLI
120
- while (LBts(&hc->locked_flags,HClf_LOCKED))
121
- PAUSE
122
-
123
- for (i=0;i<MEM_HEAP_HASH_SIZE>>3;i++) {
124
- uum=hc->heap_hash[i];
125
- while (uum) {
126
- if (!IsInHeapCtrl(uum,hc,FALSE))
127
- goto hc_false;
128
- uum=uum->next;
129
- }
130
- }
131
- uum=hc->malloc_free_lst;
132
- while (uum) {
133
- if (!IsInHeapCtrl(uum,hc,FALSE))
134
- goto hc_false;
135
- uum=uum->next;
136
- }
137
-
138
- #if _CFG_HEAP_DBG
139
- CMemUsed *um,*um1;
140
- um1=(&hc->next_um)(U8 *)-offset(CMemUsed.next);
141
- um=um1->next;
142
- while (um!=um1) {
143
- if (!IsInHeapCtrl(um,hc,FALSE))
144
- goto hc_false;
145
- um=um->next;
146
- }
147
- #endif
148
-
149
- LBtr(&hc->locked_flags,HClf_LOCKED);
150
- POPFD
151
- return TRUE;
152
-
153
- hc_false:
154
- LBtr(&hc->locked_flags,HClf_LOCKED);
155
- POPFD
156
- return FALSE;
157
- }
158
-
159
- #help_index "Memory/Task;Debugging/Heap;Memory/Debugging"
160
- public Bool IsInHeap(U8 *a,CTask *task=NULL,Bool lock=TRUE)
161
- {//Check addr if in task's heaps.
162
- if (!task) task=Fs;
163
- if (TaskValidate(task) && (IsInHeapCtrl(a,task->code_heap,lock)||
164
- task->data_heap!=task->code_heap &&
165
- IsInHeapCtrl(a,task->data_heap,lock)))
166
- return TRUE;
167
- else
168
- return FALSE;
169
- }
170
-
171
- public Bool HeapWalk(CTask *task=NULL)
172
- {//Check integrity of task's heaps.
173
- if (!task) task=Fs;
174
- if (!TaskValidate(task) || !HeapCtrlWalk(task->code_heap) ||
175
- task->data_heap!=task->code_heap && !HeapCtrlWalk(task->data_heap))
176
- return FALSE;
177
- else
178
- return TRUE;
179
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:b1f64f5775feab9138eba3cafaa5bb959dd4f40497e50357d7cd04be3614e0e8
3
+ size 4037
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/AMouse.HC CHANGED
Binary files a/Adam/AMouse.HC and b/Adam/AMouse.HC differ
 
Adam/ARegistry.HC CHANGED
@@ -1,203 +1,3 @@
1
- #help_index "Registry"
2
- #define REGISTRY_FILENAME "~/Registry.HC.Z"
3
- CDoc *sys_registry_doc=NULL;
4
- I64 sys_msg_flags[1]={0};
5
- F64 registry_version;
6
-
7
- Bool RegCache()
8
- {
9
- Bool old_silent;
10
- if (!sys_registry_doc) {
11
- old_silent=Silent;
12
- sys_registry_doc=DocRead(REGISTRY_FILENAME);
13
- Silent(old_silent);
14
- return FALSE;
15
- } else
16
- return TRUE;
17
- }
18
-
19
- public Bool RegDft(U8 *path,U8 *val,Bool is_adam_entry=FALSE)
20
- {//Add code doc tree branch to registry.
21
- Bool res,unlock_doc;
22
- RegCache;
23
- unlock_doc=DocLock(sys_registry_doc);
24
- if (!DocTreeFind(sys_registry_doc,path)) {
25
- DocTreeMake(sys_registry_doc,path);
26
- DocPrint(sys_registry_doc,"%s",val);
27
- if (is_adam_entry) {
28
- if (Fs==adam_task)
29
- ExePrint("%s",val);
30
- else
31
- Adam("%s",val);
32
- }
33
- if (DrvIsWritable(*sys_registry_doc->filename.name))
34
- DocWrite(sys_registry_doc);
35
- res=FALSE;
36
- } else
37
- res=TRUE;
38
- if (unlock_doc)
39
- DocUnlock(sys_registry_doc);
40
- return res;
41
- }
42
-
43
- public I64 RegExe(U8 *path)
44
- {//Execute doc tree branch in registry.
45
- RegCache;
46
- return DocTreeExe(sys_registry_doc,path);
47
- }
48
-
49
- public Bool RegWrite(U8 *path,U8 *fmt,...)
50
- {//Rewrite doc tree branch in registry.
51
- Bool res;
52
- RegCache;
53
- res=DocTreeWriteJoin(sys_registry_doc,path,TRUE,fmt,argc,argv);
54
- return res;
55
- }
56
-
57
- public I64 RegCnt(U8 *path)
58
- {//Tree branch cnt in registry.
59
- I64 res=0;
60
- CDocEntry *tree_branch,*start_indent,*end_indent;
61
- Bool unlock_doc=DocLock(sys_registry_doc);
62
- if (DocTreeFind(sys_registry_doc,path,
63
- &tree_branch,&start_indent,&end_indent)) {
64
- end_indent=end_indent->next;
65
- while (start_indent!=end_indent) {
66
- res++;
67
- start_indent=start_indent->next;
68
- }
69
- }
70
- if (unlock_doc)
71
- DocUnlock(sys_registry_doc);
72
- return res;
73
- }
74
-
75
- public Bool RegAppend(U8 *path,U8 *fmt,...)
76
- {//Append to doc tree branch in registry.
77
- Bool res;
78
- RegCache;
79
- res=DocTreeAppendJoin(sys_registry_doc,path,TRUE,fmt,argc,argv);
80
- return res;
81
- }
82
-
83
- public Bool OneTimePopUp(U8 *_flags,I64 flag_num,U8 *msg)
84
- {//See $LK,"::/Apps/X-Caliber/X-Caliber.HC"$.
85
- Bool res=FALSE;
86
- CDoc *doc=DocNew;
87
- CDocEntry *doc_e;
88
- if (!Bt(_flags,flag_num)) {
89
- if (msg) DocPrint(doc,"%s",msg);
90
- doc_e=DocPrint(doc,"\n$$CB,\"Do not show this msg again.\",LE=1$$");
91
- DocPrint(doc,"$$CM+CX,0,4$$$$BT,\"OKAY\",LE=1$$\n");
92
- if (PopUpMenu(doc)==1 && doc_e->de_flags&DOCEF_CHECKED_COLLAPSED) {
93
- LBts(_flags,flag_num);
94
- res=TRUE;
95
- }
96
- DocDel(doc);
97
- }
98
- return res;
99
- }
100
-
101
- U0 RegOneTimePopUp(I64 flag_num,U8 *msg)
102
- {//You're not supposed to make system pop-up flags, only me.
103
- if (OneTimePopUp(sys_msg_flags,flag_num,msg))
104
- RegWrite("Adam/SysMsgFlags","sys_msg_flags[0]=0x%X;\n",
105
- sys_msg_flags[0]);
106
- }
107
-
108
- U0 RegInit()
109
- {
110
- U8 buf[STR_LEN];
111
- Bool version_present;
112
- RegDft("Adam/SysMsgFlags","sys_msg_flags[0]=0;\n",TRUE);
113
- StrPrint(buf,"registry_version=%4.3f;\n",sys_os_version);
114
- version_present=RegDft("Adam/SysRegVer",buf,TRUE);
115
- RegExe("Adam");
116
- if (registry_version!=sys_os_version) {
117
- RegWrite("Adam/SysRegVer",buf);
118
- RegExe("Adam");
119
- }
120
- }
121
-
122
- #help_index "Boot/Once;Registry/Once"
123
- #help_file "::/Doc/Once"
124
-
125
- public U0 AOnceFlush()
126
- {//Flush AOnce() buf.
127
- RegWrite("Once/Adam","");
128
- }
129
-
130
- public U0 OnceFlush()
131
- {//Flush Once() buf.
132
- RegWrite("Once/User","");
133
- }
134
-
135
- public U0 AOnce(U8 *fmt,...)
136
- {//Add Adam code to $LK,"~/Registry.HC"$, executed next boot.
137
- U8 *buf=StrPrintJoin(NULL,fmt,argc,argv);
138
- if (!Bt(&sys_run_level,RLf_ONCE_ADAM))
139
- AOnceFlush;
140
- RegAppend("Once/Adam","%s\n",buf);
141
- Free(buf);
142
- }
143
-
144
- public U0 Once(U8 *fmt,...)
145
- {//Add User code to $LK,"~/Registry.HC"$, executed next boot.
146
- U8 *buf=StrPrintJoin(NULL,fmt,argc,argv);
147
- if (!Bt(&sys_run_level,RLf_ONCE_USER))
148
- OnceFlush;
149
- RegAppend("Once/User","%s\n",buf);
150
- Free(buf);
151
- }
152
-
153
- public U0 AOnceDrv(U8 drv_let=0,U8 *fmt,...)
154
- {//Add Adam code to drv $LK,"~/Registry.HC"$, executed next boot.
155
- U8 *buf=StrPrintJoin(NULL,fmt,argc,argv);
156
- I64 old_drv_let=*sys_registry_doc->filename.name;
157
- if (drv_let)
158
- *sys_registry_doc->filename.name=drv_let;
159
- if (!Bt(&sys_run_level,RLf_ONCE_ADAM))
160
- AOnceFlush;
161
- RegAppend("Once/Adam","%s\n",buf);
162
- Free(buf);
163
- *sys_registry_doc->filename.name=old_drv_let;
164
- }
165
-
166
- public U0 OnceDrv(U8 drv_let=0,U8 *fmt,...)
167
- {//Add User code to drv $LK,"~/Registry.HC"$, executed next boot.
168
- U8 *buf=StrPrintJoin(NULL,fmt,argc,argv);
169
- I64 old_drv_let=*sys_registry_doc->filename.name;
170
- if (drv_let)
171
- *sys_registry_doc->filename.name=drv_let;
172
- if (!Bt(&sys_run_level,RLf_ONCE_USER))
173
- OnceFlush;
174
- RegAppend("Once/User","%s\n",buf);
175
- Free(buf);
176
- *sys_registry_doc->filename.name=old_drv_let;
177
- }
178
-
179
- public U0 OnceExe()
180
- {//Execute Once code. Call goes in $LK,"~/Once.HC"$.
181
- try {
182
-
183
- RegDft("Once/Adam","");
184
- if (RegCnt("Once/Adam")>2) {
185
- Adam("RegExe(\"Once/Adam\");");
186
- AOnceFlush;
187
- }
188
- LBts(&sys_run_level,RLf_ONCE_ADAM);
189
-
190
- RegDft("Once/User","");
191
- if (RegCnt("Once/User")>2) {
192
- RegExe("Once/User");
193
- OnceFlush;
194
- }
195
- LBts(&sys_run_level,RLf_ONCE_USER);
196
-
197
- } catch {
198
- AOnceFlush;
199
- LBts(&sys_run_level,RLf_ONCE_ADAM);
200
- OnceFlush;
201
- LBts(&sys_run_level,RLf_ONCE_USER);
202
- }
203
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:fa55d37ecc4bf3ebf540d2cc7854562924c974dd291f3318334c4057656fd2be
3
+ size 5114
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/ASnd.HC CHANGED
@@ -1,409 +1,3 @@
1
- #help_index "Snd"
2
- public U0 SndTaskEndCB()
3
- {//Will turn-off snd when a task gets killed.
4
- Snd;
5
- Exit;
6
- }
7
-
8
- #help_index "Snd/Math;Math"
9
- public F64 Saw(F64 t,F64 period)
10
- {//Sawtooth. 0.0 - 1.0 think "(Sin+1)/2"
11
- if (period) {
12
- if (t>=0.0)
13
- return t%period/period;
14
- else
15
- return 1.0+t%period/period;
16
- } else
17
- return 0.0;
18
- }
19
-
20
- public F64 FullSaw(F64 t,F64 period)
21
- {//Plus&Minus Sawtooth. 1.0 - -1.0 think "Sin"
22
- if (period) {
23
- if (t>=0.0)
24
- return 2.0*(t%period/period)-1.0;
25
- else
26
- return 2.0*(t%period/period)+1.0;
27
- } else
28
- return 0.0;
29
- }
30
-
31
- public F64 Caw(F64 t,F64 period)
32
- {//Cawtooth. 1.0 - 0.0 think "(Cos+1)/2"
33
- if (period) {
34
- if (t>=0.0)
35
- return 1.0-t%period/period;
36
- else
37
- return -(t%period)/period;
38
- } else
39
- return 1.0;
40
- }
41
-
42
- public F64 FullCaw(F64 t,F64 period)
43
- {//Plus&Minus Cawtooth. 1.0 - -1.0 think "Cos"
44
- if (period) {
45
- if (t>=0.0)
46
- return -2.0*(t%period/period)+1.0;
47
- else
48
- return -2.0*(t%period/period)-1.0;
49
- } else
50
- return 1.0;
51
- }
52
-
53
- public F64 Tri(F64 t,F64 period)
54
- {//Triangle waveform. 0.0 - 1.0 - 0.0
55
- if (period) {
56
- t=2.0*(Abs(t)%period)/period;
57
- if (t<=1.0)
58
- return t;
59
- else
60
- return 2.0-t;
61
- } else
62
- return 0.0;
63
- }
64
-
65
- public F64 FullTri(F64 t,F64 period)
66
- {//Plus&Minus Triangle waveform. 0.0 - 1.0 - 0.0 - -1.0 -0.0
67
- if (period) {
68
- t=4.0*(t%period)/period;
69
- if (t<=-1.0) {
70
- if (t<=-3.0)
71
- return t+4.0;
72
- else
73
- return -2.0-t;
74
- } else {
75
- if (t<=1.0)
76
- return t;
77
- else if (t<=3.0)
78
- return 2.0-t;
79
- else
80
- return t-4.0;
81
- }
82
- } else
83
- return 0.0;
84
- }
85
-
86
- #help_index "Snd/Music"
87
-
88
- public class CMusicGlbls
89
- {
90
- U8 *cur_song;
91
- CTask *cur_song_task;
92
- I64 octave;
93
- F64 note_len;
94
- U8 note_map[7];
95
- Bool mute;
96
- I64 meter_top,meter_bottom;
97
- F64 tempo,stacatto_factor;
98
-
99
- //If you wish to sync with a
100
- //note in a Play() string. 0 is the start
101
- I64 play_note_num;
102
-
103
- F64 tM_correction,last_Beat,last_tM;
104
- } music={NULL,NULL,4,1.0,{0,2,3,5,7,8,10},FALSE,4,4,2.5,0.9,0,0,0,0};
105
-
106
- #help_index "Snd/Music;Time/Seconds"
107
- public F64 tM()
108
- {//Time in seconds synced to music subsystem.
109
- return (cnts.jiffies+music.tM_correction)/JIFFY_FREQ;
110
- }
111
-
112
- public F64 Beat()
113
- {//Time in music beats.
114
- F64 res,cur_tM;
115
- PUSHFD
116
- CLI
117
- if (mp_cnt>1)
118
- while (LBts(&sys_semas[SEMA_TMBEAT],0))
119
- PAUSE
120
- cur_tM=tM;
121
- res=music.last_Beat;
122
- if (music.tempo)
123
- res+=(cur_tM-music.last_tM)*music.tempo;
124
- music.last_tM=cur_tM;
125
- music.last_Beat=res;
126
- LBtr(&sys_semas[SEMA_TMBEAT],0);
127
- POPFD
128
- return res;
129
- }
130
-
131
- #help_index "Snd/Music"
132
- U8 *MusicSetOctave(U8 *st)
133
- {
134
- I64 ch;
135
- ch=*st++;
136
- while ('0'<=ch<='9') {
137
- music.octave=ch-'0';
138
- ch=*st++;
139
- }
140
- return --st;
141
- }
142
-
143
- U8 *MusicSetMeter(U8 *st)
144
- {
145
- I64 ch;
146
- ch=*st++;
147
- while (ch=='M') {
148
- ch=*st++;
149
- if ('0'<=ch<='9') {
150
- music.meter_top=ch-'0';
151
- ch=*st++;
152
- }
153
- if (ch=='/')
154
- ch=*st++;
155
- if ('0'<=ch<='9') {
156
- music.meter_bottom=ch-'0';
157
- ch=*st++;
158
- }
159
- }
160
- return --st;
161
- }
162
-
163
- U8 *MusicSetNoteLen(U8 *st)
164
- {
165
- Bool cont=TRUE;
166
- do {
167
- switch (*st++) {
168
- case 'w': music.note_len=4.0; break;
169
- case 'h': music.note_len=2.0; break;
170
- case 'q': music.note_len=1.0; break;
171
- case 'e': music.note_len=0.5; break;
172
- case 's': music.note_len=0.25; break;
173
- case 't': music.note_len=2.0*music.note_len/3.0; break;
174
- case '.': music.note_len=1.5*music.note_len; break;
175
- default:
176
- st--;
177
- cont=FALSE;
178
- }
179
- } while (cont);
180
- return st;
181
- }
182
-
183
- public I8 Note2Ona(I64 note,I64 octave=4)
184
- {//Note to ona. Mid C is ona=51, note=3 and octave=4.
185
- if (note<3)
186
- return (octave+1)*12+note;
187
- else
188
- return octave*12+note;
189
- }
190
-
191
- public I8 Ona2Note(I8 ona)
192
- {//Ona to note in octave. Mid C is ona=51, note=3 and octave=4.
193
- return ona%12;
194
- }
195
-
196
- public I8 Ona2Octave(I8 ona)
197
- {//Ona to octave. Mid C is ona=51, note=3 and octave=4.
198
- I64 note=ona%12,octave=ona/12;
199
- if (note<3)
200
- return octave-1;
201
- else
202
- return octave;
203
- }
204
-
205
- public U0 Play(U8 *st,U8 *words=NULL)
206
- {/* Notes are entered with a capital letter.
207
-
208
- Octaves are entered with a digit and
209
- stay set until changed. Mid C is octave 4.
210
-
211
- Durations are entered with
212
- 'w' whole note
213
- 'h' half note
214
- 'q' quarter note
215
- 'e' eighth note
216
- 't' sets to 2/3rds the current duration
217
- '.' sets to 1.5 times the current duration
218
- durations stay set until changed.
219
-
220
- '(' tie, placed before the note to be extended
221
-
222
- $LK,"music.meter_top",A="MN:CMusicGlbls"$,$LK,"music.meter_bottom",A="MN:CMusicGlbls"$ is set with
223
- "M3/4"
224
- "M4/4"
225
- etc.
226
-
227
- Sharp and flat are done with '#' or 'b'.
228
-
229
- The var music.stacatto_factor can
230
- be set to a range from 0.0 to 1.0.
231
-
232
- The var music.tempo is quarter-notes
233
- per second. It defaults to
234
- 2.5 and gets faster when bigger.
235
- */
236
- U8 *word,*last_st;
237
- I64 note,octave,i=0,ona,timeout_val,timeout_val2;
238
- Bool tie;
239
- F64 d,on_jiffies,off_jiffies;
240
- music.play_note_num=0;
241
- while (*st) {
242
- timeout_val=cnts.jiffies;
243
- tie=FALSE;
244
-
245
- do {
246
- last_st=st;
247
- if (*st=='(') {
248
- tie=TRUE;
249
- st++;
250
- } else {
251
- st=MusicSetMeter(st);
252
- st=MusicSetOctave(st);
253
- st=MusicSetNoteLen(st);
254
- }
255
- } while (st!=last_st);
256
-
257
- if (!*st) break;
258
- note=*st++-'A';
259
- if (note<7) {
260
- note=music.note_map[note];
261
- octave=music.octave;
262
- if (*st=='b') {
263
- note--;
264
- if (note==2)
265
- octave--;
266
- st++;
267
- } else if (*st=='#') {
268
- note++;
269
- if (note==3)
270
- octave++;
271
- st++;
272
- }
273
- ona=Note2Ona(note,octave);
274
- } else
275
- ona=0;
276
- if (words && (word=LstSub(i++,words)) && StrCmp(word," "))
277
- "%s",word;
278
-
279
- d=JIFFY_FREQ*music.note_len/music.tempo;
280
- on_jiffies =d*music.stacatto_factor;
281
- off_jiffies =d*(1.0-music.stacatto_factor);
282
-
283
- timeout_val+=on_jiffies;
284
- timeout_val2=timeout_val+off_jiffies;
285
-
286
- if (!music.mute)
287
- Snd(ona);
288
- SleepUntil(timeout_val);
289
- music.tM_correction+=on_jiffies-ToI64(on_jiffies);
290
-
291
- if (!music.mute && !tie)
292
- Snd;
293
- SleepUntil(timeout_val2);
294
- music.tM_correction+=off_jiffies-ToI64(off_jiffies);
295
-
296
- music.play_note_num++;
297
- }
298
- }
299
-
300
- U0 MusicSettingsRst()
301
- {
302
- music.play_note_num=0;
303
- music.stacatto_factor=0.9;
304
- music.tempo=2.5;
305
- music.octave=4;
306
- music.note_len=1.0;
307
- music.meter_top=4;
308
- music.meter_bottom=4;
309
- SndRst;
310
- PUSHFD
311
- CLI
312
- if (mp_cnt>1)
313
- while (LBts(&sys_semas[SEMA_TMBEAT],0))
314
- PAUSE
315
- music.last_tM=tM;
316
- music.last_Beat=0.0;
317
- LBtr(&sys_semas[SEMA_TMBEAT],0);
318
- POPFD
319
- }
320
-
321
- MusicSettingsRst;
322
-
323
- U0 CurSongTask()
324
- {
325
- Fs->task_end_cb=&SndTaskEndCB;
326
- while (TRUE)
327
- Play(music.cur_song);
328
- }
329
-
330
- #help_index "Snd"
331
-
332
- #define SE_NOISE 0
333
- #define SE_SWEEP 1
334
-
335
- class CSoundEffectFrame
336
- {
337
- I32 type;
338
- I8 ona1,ona2;
339
- F64 duration;
340
- };
341
-
342
- U0 SoundEffectEndTaskCB()
343
- {
344
- Free(FramePtr("CSoundEffectFrame"));
345
- music.mute--;
346
- SndTaskEndCB;
347
- }
348
-
349
- U0 SoundEffectTask(CSoundEffectFrame *ns)
350
- {
351
- I64 i,ona;
352
- F64 t0=tS,t,timeout=t0+ns->duration;
353
- FramePtrAdd("CSoundEffectFrame",ns);
354
- Fs->task_end_cb=&SoundEffectEndTaskCB;
355
- switch (ns->type) {
356
- case SE_NOISE:
357
- i=MaxI64(ns->ona2-ns->ona1,1);
358
- while (tS<timeout) {
359
- ona=RandU16%i+ns->ona1;
360
- Snd(ona);
361
- t=Clamp(3000.0/Ona2Freq(ona),1.0,50.0);
362
- if (t+tS>timeout)
363
- t=timeout-tS;
364
- Sleep(t);
365
- }
366
- break;
367
- case SE_SWEEP:
368
- while (tS<timeout) {
369
- t=(tS-t0)/ns->duration;
370
- ona=(1.0-t)*ns->ona1+t*ns->ona2;
371
- Snd(ona);
372
- t=Clamp(3000.0/Ona2Freq(ona),1.0,50.0);
373
- if (t+tS>timeout)
374
- t=timeout-tS;
375
- Sleep(t);
376
- }
377
- break;
378
- }
379
- }
380
-
381
- public CTask *Noise(I64 mS,F64 min_ona,F64 max_ona)
382
- {//Make white noise for given number of mS.
383
- CSoundEffectFrame *ns;
384
- if (mS>0) {
385
- ns=MAlloc(sizeof(CSoundEffectFrame));
386
- ns->type=SE_NOISE;
387
- ns->duration=mS/1000.0;
388
- ns->ona1=min_ona;
389
- ns->ona2=max_ona;
390
- music.mute++;
391
- return Spawn(&SoundEffectTask,ns,"Noise",,Fs);
392
- } else
393
- return NULL;
394
- }
395
-
396
- public CTask *Sweep(I64 mS,F64 ona1,F64 ona2)
397
- {//Sweep through freq range in given number of mS.
398
- CSoundEffectFrame *ns;
399
- if (mS>0) {
400
- ns=MAlloc(sizeof(CSoundEffectFrame));
401
- ns->type=SE_SWEEP;
402
- ns->duration=mS/1000.0;
403
- ns->ona1=ona1;
404
- ns->ona2=ona2;
405
- music.mute++;
406
- return Spawn(&SoundEffectTask,ns,"Noise",,Fs);
407
- } else
408
- return NULL;
409
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:e9a891cd859b0f432f23e9b28d0ce140d00ad3838406aeff0e5b1e48c9ba8984
3
+ size 8095
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/AutoComplete/ACDictGen.HC CHANGED
@@ -1,261 +1,3 @@
1
- /*
2
- This file is a stand-alone program
3
- which will regenerate processed dictionary
4
- files from a raw Project Gutenberg
5
- dictionary file.
6
-
7
- See $LK,"::/Doc/Credits.DD"$.
8
- */
9
-
10
- U0 ACDPreprocess(U8 *in_name,U8 *out_name)
11
- {/*
12
- <cr><nl>--> <nl>
13
- $$ --> $$$$
14
- \'89 --> �
15
- */
16
- I64 ch,i;
17
- U8 *src,*dst;
18
- CDoc *doc;
19
- CDocEntry *doc_e;
20
- if (doc=DocRead(in_name,DOCF_PLAIN_TEXT_TABS|DOCF_DBL_DOLLARS)) {
21
- doc_e=doc->head.next;
22
- while (doc_e!=doc) {
23
- if (doc_e->type_u8==DOCT_TEXT) {
24
- src=dst=doc_e->tag;
25
- while (ch=*src++) {
26
- if (ch=='\\' && *src=='\'') {
27
- src++;
28
- i=0;
29
- ch=ToUpper(*src++);
30
- if ('0'<=ch<='9')
31
- i+=ch-'0';
32
- else if ('A'<=ch<='F')
33
- i+=ch-'A'+10;
34
- i<<=4;
35
- ch=ToUpper(*src++);
36
- if ('0'<=ch<='9')
37
- i+=ch-'0';
38
- else if ('A'<=ch<='F')
39
- i+=ch-'A'+10;
40
- *dst++=i;
41
- } else
42
- *dst++=ch;
43
- }
44
- *dst=0;
45
- }
46
- doc_e=doc_e->next;
47
- }
48
- StrCpy(doc->filename.name,out_name);
49
- DocWrite(doc);
50
- DocDel(doc);
51
- }
52
- }
53
-
54
- I64 ACDNextCmd(U8 **_ptr)
55
- {
56
- U8 *ptr=*_ptr,*ptr2;
57
- I64 ch,res=-1;
58
- do {
59
- do {
60
- if (!(ch=*ptr++)) goto ncmd_done;
61
- } while (ch!='<');
62
-
63
- ptr2=ptr;
64
- do {
65
- if (!(ch=*ptr2++)) goto ncmd_done;
66
- } while (ch!='>');
67
- *--ptr2=0;
68
- res=LstMatch(ptr,"h1\0/h1\0def\0/def\0hw\0/hw\0tt\0/tt\0"
69
- "ety\0@fld\0@cd\0@blockquote\0@wordforms\0@note\0@altname\0@chform\0"
70
- "@cref\0@syn\0/ety\0@/fld\0@/cd\0@/blockquote\0@/wordforms\0@/note\0"
71
- "@/altname\0@/chform\0@/cref\0@/syn\0");
72
- *ptr2++='>';
73
- ptr=ptr2;
74
- } while (res<0);
75
-
76
- ncmd_done:
77
- *_ptr=ptr;
78
- return res;
79
- }
80
-
81
- U8 *ACDNextEntry(U8 **_ptr)
82
- {
83
- U8 *res,*ignore,*ptr=*_ptr,buf[ACD_BLK_SIZE],*out_ptr=buf;
84
- I64 ch,l;
85
- while (TRUE) {
86
- while (TRUE) {
87
- if (!(ch=*ptr++)) goto nentry_done;
88
- if (ch!='<') {
89
- *out_ptr++=ch;
90
- if (ch=='$$')
91
- *out_ptr++=ch;
92
- } else
93
- break;
94
- }
95
- ignore="b>\0i>\0ppp>\0/b>\0/i>\0/p>\0"
96
- "ets>\0col>\0spn>\0/ets>\0/col>\0/spn>\0er>\0as>\0cs>\0cd>\0ex>\0"
97
- "/er>\0/as>\0/cs>\0/cd>\0/ex>\0"
98
- "note>\0/note>\0blockquote>\0/blockquote>\0";
99
- while (*ignore) {
100
- l=StrLen(ignore);
101
- if (!StrNCmp(ptr,ignore,l)) {
102
- ptr+=l;
103
- break;
104
- } else
105
- ignore+=l+1;
106
- }
107
- if (!*ignore)
108
- break;
109
- }
110
- nentry_done:
111
- *out_ptr++=0;
112
- res=StrNew(buf);
113
- *_ptr=ptr-1;
114
- return res;
115
- }
116
-
117
- I64 ACDCompareWords(U8 *e1,U8 *e2)
118
- {
119
- return StrICmp(e1,e2);
120
- }
121
-
122
- U8 *ACDSortWords(U8 *start,I64 size,I64 word_cnt)
123
- {
124
- U8 **ptr_array=MAlloc(sizeof(U8 *)*word_cnt),
125
- *out_start=MAlloc(size),
126
- *ptr=start,*ptr2;
127
- I64 i=0;
128
- while (*ptr) {
129
- ptr_array[i++]=ptr;
130
- ptr+=StrLen(ptr)+3;
131
- }
132
- "Sorting...\n"; Sleep(100);
133
- QSortI64(ptr_array,word_cnt,&ACDCompareWords);
134
- "Done...\n"; Sleep(100);
135
-
136
- ptr=out_start;
137
- for (i=0;i<word_cnt;i++) {
138
- ptr2=ptr_array[i];
139
- while (*ptr2)
140
- *ptr++=*ptr2++;
141
- *ptr++=*ptr2++; //zero
142
- *ptr++=*ptr2++; //blk lo
143
- *ptr++=*ptr2++; //blk hi
144
- }
145
- *ptr++=0;
146
- return out_start;
147
- }
148
-
149
- U0 ACDGen(U8 *in_file)
150
- {
151
- I64 cmd,size,word_cnt=0,largest_entry=0;
152
- U8 *st,*in_ptr=FileRead(in_file,&size),*in_start=in_ptr,
153
- *out_ptr=MAlloc(size),*out_start=out_ptr,
154
- *word_ptr=MAlloc(size),*word_start=word_ptr,
155
- *last_word="",*def_word_start=out_ptr,
156
- *sorted_word_start;
157
- U16 *d;
158
- if (!in_ptr) return;
159
- do {
160
- cmd=ACDNextCmd(&in_ptr);
161
- if (cmd==ACD_H1) {
162
- next_word:
163
- if (out_ptr-def_word_start>largest_entry)
164
- largest_entry=out_ptr-def_word_start;
165
- def_word_start=out_ptr;
166
- if (st=ACDNextEntry(&in_ptr)) {
167
- if (*st) {
168
- if (StrICmp(st,last_word)) {
169
- word_cnt++;
170
-
171
- *word_ptr++=ACD_WORD_CHAR;
172
- last_word=word_ptr;
173
- StrCpy(word_ptr,st);
174
- word_ptr+=StrLen(st)+1;
175
-
176
- d=word_ptr;
177
- *d=(out_ptr-out_start)/ACD_BLK_SIZE;
178
- word_ptr+=2;
179
-
180
- *out_ptr++=ACD_WORD_CHAR;
181
- StrCpy(out_ptr,st);
182
- out_ptr+=StrLen(st)+1;
183
- }
184
- Free(st);
185
-
186
- do {
187
- do {
188
- cmd=ACDNextCmd(&in_ptr);
189
- if (cmd==ACD_H1)
190
- goto next_word;
191
- } while (cmd>=0 && !(cmd==ACD_DEF||cmd==ACD_PRONUNCIATION||
192
- cmd==ACD_POS||cmd==ACD_EXTRA));
193
- if (cmd==ACD_DEF) {
194
- if(st=ACDNextEntry(&in_ptr)) {
195
- if (*st) {
196
- *out_ptr++=ACD_DEF_CHAR;
197
- StrCpy(out_ptr,st);
198
- out_ptr+=StrLen(st)+1;
199
- }
200
- Free(st);
201
- }
202
- } else if (cmd==ACD_PRONUNCIATION) {
203
- if(st=ACDNextEntry(&in_ptr)) {
204
- if (*st) {
205
- *out_ptr++=ACD_PRONUNCIATION_CHAR;
206
- StrCpy(out_ptr,st);
207
- out_ptr+=StrLen(st)+1;
208
- }
209
- Free(st);
210
- }
211
- } else if (cmd==ACD_POS) {
212
- if(st=ACDNextEntry(&in_ptr)) {
213
- if (*st) {
214
- *out_ptr++=ACD_POS_CHAR;
215
- StrCpy(out_ptr,st);
216
- out_ptr+=StrLen(st)+1;
217
- }
218
- Free(st);
219
- }
220
- } else if (cmd==ACD_EXTRA) {
221
- if(st=ACDNextEntry(&in_ptr)) {
222
- if (*st) {
223
- *out_ptr++=ACD_EXTRA_CHAR;
224
- StrCpy(out_ptr,st);
225
- out_ptr+=StrLen(st)+1;
226
- }
227
- Free(st);
228
- }
229
- }
230
- } while (cmd==ACD_DEF||cmd==ACD_PRONUNCIATION||
231
- cmd==ACD_POS||cmd==ACD_EXTRA);
232
- } else
233
- Free(st);
234
- }
235
- }
236
- } while (cmd>=0);
237
- *out_ptr++=ACD_END_CHAR;
238
- *word_ptr++=ACD_END_CHAR;
239
-
240
- Free(in_start);
241
-
242
- "Blk Size :%d\n",ACD_BLK_SIZE;
243
- "Blk Cnt :%04X\n",(out_ptr-out_start+ACD_BLK_SIZE-1)/ACD_BLK_SIZE;
244
- "Largest Entry :%d\n",largest_entry;
245
- "Word Count :%d\n",word_cnt;
246
-
247
- FileWrite(ACD_DEF_FILENAME,out_start,out_ptr-out_start);
248
- "Def File Size :%d\n",out_ptr-out_start;
249
-
250
- sorted_word_start=ACDSortWords(word_start,word_ptr-word_start,word_cnt);
251
- FileWrite(ACD_WORD_FILENAME,sorted_word_start,word_ptr-word_start);
252
- "Word File Size:%d\n",word_ptr-word_start;
253
-
254
- Free(out_start);
255
- Free(word_start);
256
- Free(sorted_word_start);
257
- }
258
-
259
- Cd(__DIR__);
260
- ACDPreprocess("DICTIONARY.DD","DICTIONARY2.DD");
261
- ACDGen("DICTIONARY2.DD");
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:e2be6f15b3fa7bf0c3f2d84acf01c2b67a85da9d0349296a6143e84cc30639ce
3
+ size 5653
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/AutoComplete/ACFill.HC CHANGED
@@ -1,226 +1,3 @@
1
- #help_index "AutoComplete/Dictionary"
2
- public U8 *ACDDefGet(U8 *st,I64 def_num=1)
3
- {//MAlloc str holding single dict definition of word.
4
- CFile *f;
5
- CHashGeneric *tmph;
6
- U8 *res=NULL,*buf,*in_ptr,
7
- *st2=MStrUtil(st,SUF_TO_UPPER);
8
- tmph=HashFind(st2,ac.hash_table,HTT_DICT_WORD);
9
- Free(st2);
10
- if (tmph) {
11
- if (f=FOpen(ACD_DEF_FILENAME,"r")) {
12
- buf=MAlloc(ACD_BLK_SIZE*2+1);
13
- buf[ACD_BLK_SIZE*2]=0; //terminate
14
- FBlkRead(f,buf,tmph->user_data0*ACD_BLK_SIZE/BLK_SIZE,
15
- ACD_BLK_SIZE*2/BLK_SIZE);
16
- FClose(f);
17
- in_ptr=buf;
18
- while (in_ptr<buf+ACD_BLK_SIZE*2) {
19
- while (*in_ptr!=ACD_WORD_CHAR && in_ptr<buf+ACD_BLK_SIZE*2)
20
- in_ptr++;
21
- if (*in_ptr++==ACD_WORD_CHAR) {
22
- if (!StrICmp(st,in_ptr)) {
23
- while (def_num && *in_ptr!=ACD_WORD_CHAR
24
- && in_ptr<buf+ACD_BLK_SIZE*2) {
25
- if (*in_ptr==ACD_DEF_CHAR) {
26
- if (!--def_num)
27
- break;
28
- else
29
- in_ptr++;
30
- } else
31
- in_ptr++;
32
- }
33
- if (*in_ptr++==ACD_DEF_CHAR) {
34
- res=StrNew(in_ptr);
35
- break;
36
- }
37
- }
38
- }
39
- }
40
- Free(buf);
41
- }
42
- }
43
- return res;
44
- }
45
-
46
- public U8 *ACDDefsGet(U8 *st)
47
- {//MAlloc str with all dict definitions of word.
48
- CFile *f;
49
- CHashGeneric *tmph;
50
- U8 *res=NULL,*buf,*in_ptr,*in_ptr2,
51
- *st2=MStrUtil(st,SUF_TO_UPPER);
52
- tmph=HashFind(st2,ac.hash_table,HTT_DICT_WORD);
53
- Free(st2);
54
- if (tmph) {
55
- if (f=FOpen(ACD_DEF_FILENAME,"r")) {
56
- buf=MAlloc(ACD_BLK_SIZE*2+1);
57
- buf[ACD_BLK_SIZE*2]=0; //terminate
58
- FBlkRead(f,buf,tmph->user_data0*ACD_BLK_SIZE/BLK_SIZE,
59
- ACD_BLK_SIZE*2/BLK_SIZE);
60
- FClose(f);
61
- in_ptr=buf;
62
- while (in_ptr<buf+ACD_BLK_SIZE*2) {
63
- while (*in_ptr!=ACD_WORD_CHAR && in_ptr<buf+ACD_BLK_SIZE*2)
64
- in_ptr++;
65
- if (*in_ptr++==ACD_WORD_CHAR) {
66
- if (!StrICmp(st,in_ptr)) {
67
- in_ptr2=in_ptr;
68
- in_ptr--;
69
- while (*in_ptr2!=ACD_WORD_CHAR
70
- && in_ptr2<buf+ACD_BLK_SIZE*2) {
71
- in_ptr2++;
72
- }
73
- res=MAlloc(in_ptr2+1-in_ptr);
74
- MemCpy(res,in_ptr,in_ptr2-in_ptr);
75
- res[in_ptr2-in_ptr]=ACD_END_CHAR;
76
- break;
77
- }
78
- }
79
- }
80
- Free(buf);
81
- }
82
- }
83
- return res;
84
- }
85
-
86
- /*Fmt of word lst entry:
87
- U8 ACD_WORD_CHAR
88
- U8 word[] with terminating zero
89
- I16 block;
90
- */
91
- public U8 *ACDWordPtAt(U8 *st)
92
- {//Point to word in word list.
93
- I64 i;
94
- U8 *start=acd.word_lst,*r=start,
95
- *end=acd.word_lst+acd.word_lst_size;
96
- if (!st || !*st)
97
- return acd.word_lst;
98
- if (acd.word_lst_size) {
99
- while (start+3<end) {
100
- r=(start+end)>>1;
101
- while (TRUE) {
102
- while (*r!=ACD_WORD_CHAR && r>acd.word_lst)
103
- r--;
104
- if ((r[2]==ACD_WORD_CHAR||r[1]==ACD_WORD_CHAR)&&r-3>acd.word_lst)
105
- r--;
106
- else
107
- break;
108
- }
109
- if (*r==ACD_WORD_CHAR) {
110
- i=StrICmp(st,r+1);
111
- if (i<0)
112
- end=r-1;
113
- else if (i>0)
114
- start=r+StrLen(r)+3;
115
- else
116
- return r;
117
- } else
118
- break;
119
- }
120
- r=(start+end)>>1;
121
- while (TRUE) {
122
- while (*r!=ACD_WORD_CHAR && r>acd.word_lst)
123
- r--;
124
- if ((r[2]==ACD_WORD_CHAR||r[1]==ACD_WORD_CHAR)&&r-3>acd.word_lst)
125
- r--;
126
- else
127
- break;
128
- }
129
- if (*r==ACD_WORD_CHAR && StrICmp(st,r+1)>0)
130
- r+=StrLen(r)+3;
131
- }
132
- if (*r==ACD_WORD_CHAR)
133
- return r;
134
- else
135
- return acd.word_lst;
136
- }
137
-
138
- U0 ACDFillin(I64 n)
139
- {
140
- U8 *s;
141
- I64 len;
142
- if (0<=n<acd.num_fillins) {
143
- s=acd.fillins[n]+1;
144
- len=StrLen(s);
145
- if (len>ac.partial_len)
146
- In(s+ac.partial_len);
147
- }
148
- }
149
-
150
- public U0 ACDDefsPut(CDoc *doc=NULL,U8 *st,I64 num=-1)
151
- {//Put to doc a dictionary definition(s) of a word.
152
- U8 *st2,*st3;
153
- I64 ch,i=0;
154
- if (!st) return;
155
- if (*st==ACD_WORD_CHAR)
156
- st++;
157
- DocPrint(doc,"$$WW,1$$$$RED$$%s:$$FG$$\n\n",st);
158
- if (num<0) {
159
- if (st3=ACDDefsGet(st)) {
160
- st2=st3;
161
- while (ch=*st2++) {
162
- switch (ch) {
163
- case ACD_WORD_CHAR:
164
- break;
165
- case ACD_DEF_CHAR:
166
- DocPrint(doc,"$$GREEN$$(%d)$$FG$$ %s\n",
167
- ++i,st2);
168
- break;
169
- case ACD_PRONUNCIATION_CHAR:
170
- DocPrint(doc,"$$LTGREEN$$%s$$FG$$\n",st2);
171
- break;
172
- case ACD_POS_CHAR:
173
- DocPrint(doc,"$$BLACK$$%s$$FG$$\n",st2);
174
- break;
175
- case ACD_EXTRA_CHAR:
176
- DocPrint(doc,"$$LTBLUE$$%s$$FG$$\n",st2);
177
- break;
178
- }
179
- st2+=StrLen(st2)+1;
180
- }
181
- Free(st3);
182
- }
183
- } else {
184
- while (st2=ACDDefGet(st,++i)) {
185
- if (i==num)
186
- DocPrint(doc,"$$GREEN$$(%d)$$FG$$ %s\n",
187
- i,st2);
188
- Free(st2);
189
- }
190
- }
191
- }
192
-
193
- U0 ACDPopUpDef(U8 *st,I64 num=-1,CTask *parent=NULL)
194
- {
195
- U8 *buf;
196
- buf=MStrPrint("ACDDefsPut(DocPut,\"%s\",%d);View;",st,num);
197
- PopUp(buf,parent);
198
- Free(buf);
199
- }
200
-
201
- U0 ACDDef(I64 n,CTask *parent=NULL)
202
- {
203
- if (0<=n<acd.num_fillins)
204
- ACDPopUpDef(acd.fillins[n],-1,parent);
205
- }
206
-
207
- #help_index "AutoComplete"
208
- U0 ACFillIn(I64 n)
209
- {
210
- U8 *s;
211
- if (0<=--n<ac.num_fillins) {
212
- s=ac.fillin_matches[n]->str;
213
- if (StrLen(s)>ac.partial_len)
214
- In(s+ac.partial_len);
215
- }
216
- }
217
-
218
- U0 ACMan(I64 n,CTask *parent_task=NULL)
219
- {
220
- CHashAC *tmpw;
221
- CHashSrcSym *tmph;
222
- if (0<=--n<ac.num_fillins && (tmpw=ac.fillin_matches[n]) &&
223
- (tmph=HashFind(tmpw->str,Fs->hash_table,HTG_SRC_SYM)) &&
224
- tmph->src_link)
225
- PopUpEd(tmph->src_link,parent_task);
226
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:eee70592aa054cb126e29d204280f560e879309298fa30ab4401a7ea104314c3
3
+ size 4960
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/AutoComplete/ACInit.HC CHANGED
@@ -1,169 +1,3 @@
1
- #help_index "AutoComplete/Dictionary"
2
- acd.has_words=FileFind(ACD_WORD_FILENAME);
3
- acd.has_defs =FileFind(ACD_DEF_FILENAME)||FileFind(ACD_DEF_FILENAME_Z);
4
-
5
- public U0 ACDWordsLoad()
6
- {//Put words from word list into hash table.
7
- I64 size;
8
- CHashGeneric *tmph;
9
- U8 *in_ptr,*in_start,*st2;
10
- U16 *d;
11
- acd.num_words=0;
12
- if (in_ptr=FileRead(ACD_WORD_FILENAME,&size)) {
13
- in_start=in_ptr;
14
- Free(acd.word_lst);
15
- acd.word_lst=AMAlloc(size);
16
- MemCpy(acd.word_lst,in_start,size);
17
- acd.word_lst_size=size;
18
-
19
- while (in_ptr<in_start+size) {
20
- if (*in_ptr==ACD_WORD_CHAR)
21
- in_ptr++;
22
- if (*in_ptr) {
23
- st2=MStrUtil(in_ptr,SUF_TO_UPPER);
24
- tmph=ACAlloc(sizeof(CHashGeneric)+StrLen(st2)+1);
25
- StrCpy(tmph+1,st2);
26
- Free(st2);
27
- in_ptr+=StrLen(in_ptr)+1;
28
- tmph->str=tmph+1;
29
- tmph->use_cnt=1;
30
- tmph->type=HTT_DICT_WORD;
31
- d=in_ptr;
32
- tmph->user_data0=*d;
33
- in_ptr+=2;
34
- HashAdd(tmph,ac.hash_table);
35
- acd.num_words++;
36
- } else
37
- in_ptr+=3;
38
- }
39
- Free(in_start);
40
- }
41
- }
42
-
43
- #help_index "AutoComplete"
44
- CHashAC *ACHashAdd(U8 *w)
45
- {
46
- CHashAC *tmpw=HashFind(w,ac.hash_table,HTT_WORD);
47
- if (tmpw) {
48
- tmpw->hits++;
49
- return tmpw;
50
- }
51
- tmpw=ACAlloc(sizeof(CHashAC));
52
- tmpw->str=AStrNew(w);
53
- tmpw->type=HTT_WORD;
54
- tmpw->use_cnt=1;
55
- tmpw->hits=1;
56
- HashAdd(tmpw,ac.hash_table);
57
- ac.num_words++;
58
- return tmpw;
59
- }
60
-
61
- U0 ACSingleFileAdd(U8 *buf)
62
- {
63
- I64 ch;
64
- U8 *ptr=buf,*ptr2,*ptr3;
65
- while (TRUE) {
66
- while (TRUE) {
67
- if (ch=*ptr++) {
68
- if (Bt(char_bmp_alpha_numeric,ch))
69
- break;
70
- } else
71
- return;
72
- }
73
- ptr3=ptr;
74
- ptr2=ptr;
75
- ptr--;
76
- while (TRUE) {
77
- if (ch=*ptr2++) {
78
- if (Bt(char_bmp_alpha_numeric,ch))
79
- *ptr3++=ch;
80
- else if (ch!=CH_CURSOR)
81
- break;
82
- } else {
83
- ptr2--;
84
- break;
85
- }
86
- }
87
- *ptr3=0;
88
- ACHashAdd(ptr);
89
- ptr=ptr2;
90
- }
91
- }
92
-
93
- U0 ACMainFileLstTraverse(U8 *files_find_mask)
94
- {
95
- U8 *buf;
96
- CDirEntry *tmpde,*tmpde1;
97
- try {
98
- tmpde=tmpde1=FilesFind(files_find_mask,
99
- FUF_RECURSE|FUF_JUST_TXT|FUF_JUST_FILES|FUF_CLUS_ORDER);
100
- while (tmpde) {
101
- "%s\n",tmpde->full_name;
102
- buf=FileRead(tmpde->full_name);
103
- ACSingleFileAdd(buf);
104
- Free(buf);
105
- tmpde=tmpde->next;
106
- }
107
- } catch
108
- Fs->catch_except=TRUE;
109
- DirTreeDel(tmpde1);
110
- }
111
-
112
- U0 ACProgressTask(Bool *_start_flag)
113
- {
114
- I64 start=blkdev.write_cnt;
115
- progress1=0;
116
- progress1_max=(Size(ACD_DEF_FILENAME_Z,"+x+s")+BLK_SIZE-1)>>BLK_SIZE_BITS;
117
- StrCpy(progress1_desc,"Uncompressing Dictionary");
118
- start=blkdev.write_cnt;
119
- *_start_flag=TRUE;
120
- while (progress1<progress1_max) {
121
- progress1=blkdev.write_cnt-start;
122
- Sleep(10);
123
- }
124
- *progress1_desc=progress1=progress1_max=0;
125
- }
126
-
127
- public U0 ACInit(U8 *mask=NULL)
128
- {//Read files and build AutoComplete statistics.
129
- Bool start_flag;
130
- CBlkDev *bd=Let2BlkDev;
131
-
132
- LBtr(&sys_run_level,RLf_AUTO_COMPLETE);
133
- AutoComplete;
134
- while (LBts(&ac.flags,ACf_INIT_IN_PROGRESS))
135
- Yield;
136
- if (DrvIsWritable && FileFind(ACD_DEF_FILENAME_Z) &&
137
- !FileFind(ACD_DEF_FILENAME)) {
138
- if (bd->type!=BDT_RAM) {
139
- start_flag=FALSE;
140
- Spawn(&ACProgressTask,&start_flag);
141
- while (!start_flag)
142
- Yield;
143
- }
144
- Move(ACD_DEF_FILENAME_Z,ACD_DEF_FILENAME);
145
- }
146
-
147
- HashTableDel(ac.hash_table);
148
- ac.hash_table=HashTableNew(2048,adam_task);
149
-
150
- ac.num_words=0;
151
- Free(ac.cur_word);
152
- ac.cur_word=NULL;
153
-
154
- if (mask)
155
- ACMainFileLstTraverse(mask);
156
-
157
- ACDWordsLoad;
158
- LBtr(&ac.flags,ACf_INIT_IN_PROGRESS);
159
- LBts(&sys_run_level,RLf_AUTO_COMPLETE);
160
- AutoComplete(ON);
161
- }
162
-
163
- I64 AutoCompleteSize()
164
- {
165
- if (ac.hash_table)
166
- return HashTableSize2(ac.hash_table)+MSize2(acd.word_lst);
167
- else
168
- return 0;
169
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:77daaea6d160a93075ec3b09e690e5a2a0822535507efe1f8c4fa6ad4e739708
3
+ size 3567
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/AutoComplete/ACTask.HC CHANGED
@@ -1,283 +1,3 @@
1
- #help_index "AutoComplete/Dictionary"
2
- U0 ACDDictWordsAdd(U8 *st)
3
- {
4
- I64 i;
5
- U8 *ptr;
6
- if (st && *st && (ptr=ACDWordPtAt(st))) {
7
- for (i=0;i<ACD_FILLINS_NUM;i++) {
8
- if (*ptr++!=ACD_WORD_CHAR)
9
- break;
10
- if (i) '\n';
11
- acd.fillins[i]=ptr-1;
12
- "$$GREEN$$'%d'$$FG$$ %-23ts",i,ptr;
13
- ptr+=StrLen(ptr)+3;
14
- }
15
- acd.num_fillins=i;
16
- }
17
- }
18
-
19
- #help_index "AutoComplete"
20
- U0 ACDocRst(I64 left,I64 top)
21
- {
22
- CDoc *doc=DocPut;
23
- DocRst(doc,TRUE);
24
- doc->flags|=DOCF_SIZE_MIN;
25
- Fs->border_src=BDS_CONST;
26
- Fs->border_attr=LTGRAY<<4+DrvTextAttrGet(':')&15;
27
- Fs->text_attr =LTGRAY<<4+BLUE;
28
- LBtr(&Fs->display_flags,DISPLAYf_SHOW);
29
- WinHorz(left,Fs->win_right);
30
- WinVert(top,Fs->win_bottom);
31
- DocCursor;
32
- }
33
-
34
- I64 ACSkipCrap(U8 *src,I64 len)
35
- {
36
- I64 j;
37
- j=len-1;
38
- while (j>=0) {
39
- if (Bt(char_bmp_alpha_numeric,src[j]))
40
- break;
41
- else
42
- j--;
43
- }
44
- return j+1;
45
- }
46
-
47
- I64 ACPriorWordInStr(U8 *src,U8 *dst,I64 len,I64 buf_size)
48
- {
49
- I64 i,j=0,k;
50
- i=len-1;
51
- while (i>=0)
52
- if (!Bt(char_bmp_alpha_numeric,src[i]))
53
- break;
54
- else
55
- i--;
56
- if (i>=-1 && len>0)
57
- for (k=i+1;k<len && j<buf_size-1;k++)
58
- dst[j++]=src[k];
59
- dst[j]=0;
60
- return i+1;
61
- }
62
-
63
- U0 ACFillInAdd(CHashAC *tmpw)
64
- {
65
- I64 k;
66
- if (ac.num_fillins<AC_FILLINS_NUM ||
67
- tmpw->hits>ac.fillin_hits[ac.num_fillins-1]) {
68
- for (k=ac.num_fillins-1;k>=0;k--) {
69
- if (tmpw->hits<=ac.fillin_hits[k])
70
- break;
71
- else {
72
- ac.fillin_matches[k+1]=ac.fillin_matches[k];
73
- ac.fillin_hits[k+1] =ac.fillin_hits[k];
74
- }
75
- }
76
- ac.fillin_matches[k+1]=tmpw;
77
- ac.fillin_hits[k+1] =tmpw->hits;
78
- if (ac.num_fillins<AC_FILLINS_NUM)
79
- ac.num_fillins++;
80
- }
81
- }
82
-
83
- U0 ACPutChoices(CDoc *focus_l,CDocEntry *doc_e,CTask *focus_task,
84
- Bool force_refresh)
85
- {
86
- I64 i,data_col;
87
- U8 *buf,*buf1,*src=NULL,*st;
88
- CHashAC *tmpw;
89
- F64 timeout_time=tS+0.5;
90
- CHashSrcSym *tmph;
91
-
92
- src=DocScanLine(focus_l,doc_e,&data_col);
93
- DocUnlock(focus_l);
94
- i=StrLen(src);
95
- buf =MAlloc(MaxI64(i+1,256));
96
- buf1=MAlloc(MaxI64(i+1,256));
97
- if (data_col==-1)
98
- data_col=0;
99
- data_col=ACPriorWordInStr(src,buf,data_col,256);
100
- ac.partial_len=StrLen(buf);
101
- data_col=ACSkipCrap(src,data_col);
102
- data_col=ACPriorWordInStr(src,buf1,data_col,256);
103
-
104
- if (!ac.cur_word || StrCmp(ac.cur_word,buf) || force_refresh) {
105
- st=ac.cur_word;
106
- ac.cur_word=AStrNew(buf);
107
- Free(st);
108
- ac.num_fillins=0;
109
- if (*ac.cur_word)
110
- for (i=0;i<=ac.hash_table->mask && tS<timeout_time;i++) {
111
- tmpw=ac.hash_table->body[i];
112
- while (tmpw) {
113
- if (!MemCmp(ac.cur_word,tmpw->str,StrLen(ac.cur_word)))
114
- ACFillInAdd(tmpw);
115
- tmpw=tmpw->next;
116
- }
117
- }
118
- ACDocRst(51,13);
119
- if (ac.cur_word && *ac.cur_word) {
120
- "$$PURPLE$$Word:%s$$FG$$\n",ac.cur_word;
121
- for (i=0;i<ac.num_fillins;i++) {
122
- st=ac.fillin_matches[i]->str;
123
- "$$GREEN$$F%02d$$FG$$ ",i+1;
124
- if (TaskValidate(focus_task) &&
125
- (tmph=HashFind(st,focus_task->hash_table,HTG_SRC_SYM)) &&
126
- tmph->src_link) {
127
- if (tmph->type&HTF_PUBLIC)
128
- "$$RED$$";
129
- "$$TX+UL+L+PU,\"%$$Q\",A=\"%s\"$$$$FG$$\n",st,tmph->src_link;
130
- } else
131
- "%s\n",st;
132
- }
133
- if (acd.has_words)
134
- ACDDictWordsAdd(ac.cur_word);
135
- } else if (FileFind("::/Doc/StandBy.DD.Z"))
136
- Type("::/Doc/StandBy.DD.Z",0);
137
- }
138
- Free(src);
139
- Free(buf);
140
- Free(buf1);
141
- }
142
-
143
- U0 ACTaskNormal(I64 sc,I64 last_sc,
144
- CTask *focus_task,CTask *original_focus_task)
145
- {
146
- CDoc *doc;
147
- CDocEntry *doc_e;
148
- if ((doc=DocPut(focus_task)) &&
149
- focus_task!=Fs && Bt(&focus_task->display_flags,DISPLAYf_SHOW)) {
150
- DocLock(doc);
151
- if (TaskValidate(focus_task) && original_focus_task==sys_focus_task &&
152
- doc && doc==DocPut(focus_task) && (doc_e=doc->cur_entry)) {
153
- if (doc_e==doc) doc_e=doc_e->last;
154
- while (doc_e->last!=doc && (doc_e->type_u8==DOCT_NEW_LINE ||
155
- doc_e->type_u8==DOCT_SOFT_NEW_LINE))
156
- doc_e=doc_e->last;
157
- while (doc_e->last->type_u8!=DOCT_NEW_LINE && doc_e->last!=doc)
158
- doc_e=doc_e->last;
159
- ACPutChoices(doc,doc_e,focus_task,ToBool(sc!=last_sc));
160
- } else
161
- DocUnlock(doc);
162
- }
163
- if (!LBts(&Fs->display_flags,DISPLAYf_SHOW))
164
- WinZBufUpdate;
165
- }
166
-
167
- U0 ACTaskCtrl(I64 sc,I64 last_sc,
168
- CTask *focus_task,CTask *original_focus_task)
169
- {
170
- if (TaskValidate(focus_task) &&
171
- (focus_task->scroll_x || focus_task->scroll_y)) {
172
- if (LBtr(&Fs->display_flags,DISPLAYf_SHOW))
173
- WinZBufUpdate;
174
- } else {
175
- if (sc!=last_sc) {
176
- if (sc&SCF_ALT) {
177
- ACDocRst(27,3);
178
- if (TaskValidate(original_focus_task) &&
179
- !Bt(&original_focus_task->win_inhibit,WIf_SELF_KEY_DESC))
180
- KeyMapFamily(original_focus_task,0,
181
- ToBool(!(sc&SCF_SHIFT)),ToBool(sc&SCF_SHIFT));
182
- KeyMapCtrlAltFamily(
183
- ToBool(!(sc&SCF_SHIFT)),ToBool(sc&SCF_SHIFT));
184
- } else if (TaskValidate(original_focus_task) &&
185
- !Bt(&original_focus_task->win_inhibit,WIf_SELF_KEY_DESC)) {
186
- ACDocRst(27,3);
187
- KeyMapFamily(original_focus_task,SCF_CTRL,
188
- ToBool(!(sc&SCF_SHIFT)),ToBool(sc&SCF_SHIFT));
189
- }
190
- }
191
- if (!LBts(&Fs->display_flags,DISPLAYf_SHOW))
192
- WinZBufUpdate;
193
- }
194
- }
195
-
196
- U0 ACTaskAlt(I64 sc,I64 last_sc,
197
- CTask *,CTask *original_focus_task)
198
- {
199
- if (sc!=last_sc && TaskValidate(original_focus_task) &&
200
- !Bt(&original_focus_task->win_inhibit,WIf_SELF_KEY_DESC)) {
201
- ACDocRst(27,3);
202
- KeyMapFamily(original_focus_task,SCF_ALT,
203
- ToBool(!(sc&SCF_SHIFT)),ToBool(sc&SCF_SHIFT));
204
- }
205
- if (!LBts(&Fs->display_flags,DISPLAYf_SHOW))
206
- WinZBufUpdate;
207
- }
208
-
209
- U0 ACTaskEndCB()
210
- {
211
- ac.task=NULL;
212
- Exit;
213
- }
214
-
215
- U0 ACTask(I64)
216
- {
217
- CTask *focus_task,*original_focus_task;
218
- I64 ch,scan_code=0,last_scan_code=0;
219
- CDoc *doc;
220
- Fs->task_end_cb=&ACTaskEndCB;
221
- DocTermNew;
222
- LBts(&Fs->display_flags,DISPLAYf_SHOW);
223
- WinHorz(51,Fs->win_right);
224
- LBts(&Fs->display_flags,DISPLAYf_WIN_ON_TOP);
225
- Fs->win_inhibit=WIG_NO_FOCUS_TASK_DFT;
226
- Free(ac.cur_word);
227
- ac.cur_word=NULL;
228
- while (TRUE) {
229
- if (scan_code&(SCF_CTRL|SCF_ALT) ||
230
- GetTSC>KbdMsEvtTime+cnts.time_stamp_freq>>1) {
231
- last_scan_code=scan_code;
232
- scan_code=kbd.scan_code;
233
- }
234
- original_focus_task=focus_task=sys_focus_task;
235
- while (TaskValidate(focus_task) &&
236
- Bt(&focus_task->task_flags,TASKf_INPUT_FILTER_TASK))
237
- focus_task=focus_task->parent_task;
238
- if (scan_code&SCF_CTRL)
239
- ACTaskCtrl(scan_code,last_scan_code,focus_task,original_focus_task);
240
- else if (TaskValidate(focus_task)) {
241
- if (scan_code&SCF_ALT)
242
- ACTaskAlt(scan_code,last_scan_code,focus_task,original_focus_task);
243
- else
244
- ACTaskNormal(scan_code,last_scan_code,focus_task,original_focus_task);
245
- }
246
- Sleep(333);
247
- if (ScanMsg(&ch,,1<<MSG_KEY_DOWN) && (ch==CH_ESC||ch==CH_SHIFT_ESC))
248
- break;
249
- doc=DocPut;
250
- DocLock(doc);
251
- if (doc->cur_entry->de_flags & DOCEF_LINK) {
252
- '' CH_SPACE;
253
- doc->cur_entry=doc;
254
- }
255
- DocUnlock(doc);
256
- }
257
- }
258
-
259
- public Bool AutoComplete(Bool val=OFF)
260
- {//Turn AutoComplete OFF or ON.
261
- Bool old_val=FALSE;
262
- while (Bt(&ac.flags,ACf_INIT_IN_PROGRESS))
263
- Sleep(10);
264
- if (val) {
265
- if (Bt(&sys_run_level,RLf_AUTO_COMPLETE)) {
266
- if (TaskValidate(ac.task))
267
- old_val=TRUE;
268
- else {
269
- ac.task=Spawn(&ACTask,NULL,"AutoComplete");
270
- TaskWait(ac.task);
271
- }
272
- WinToTop(ac.task);
273
- }
274
- } else {
275
- if (TaskValidate(ac.task)) {
276
- if (Bt(&sys_run_level,RLf_AUTO_COMPLETE))
277
- old_val=TRUE;
278
- Kill(ac.task);
279
- DeathWait(&ac.task);
280
- }
281
- }
282
- return old_val;
283
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:531790c0e5d20cf3d17310835675a35d1879abb0b5d16edaffe6e3d29a644422
3
+ size 7294
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/AutoComplete/MakeAC.HC CHANGED
@@ -1,6 +1,3 @@
1
- //See $LK,"::/Doc/AutoComplete.DD"$
2
- Cd(__DIR__);;
3
- #include "ACFill"
4
- #include "ACTask"
5
- #include "ACInit"
6
- Cd("..");;
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:e70be77672162cc6762d1bb458fc0848312e71d682ca52401728ffe0341fbaea
3
+ size 115
 
 
 
Adam/CPURep.HC CHANGED
@@ -1,72 +1,3 @@
1
- #help_index "Info;Time/CPU Cycles;Processor"
2
- class CCPURep
3
- {
4
- Bool mp_start,mp_end;
5
- I64 mp_not_done_flags,
6
- **swaps,
7
- **cycles;
8
- };
9
-
10
- U0 MPCPURep(CCPURep *cr)
11
- {
12
- I64 swaps=0,cycles_0,cycles_f;
13
- while (!cr->mp_start)
14
- Yield;
15
- cycles_0=GetTSC;
16
- while (!cr->mp_end) {
17
- swaps++;
18
- Yield;
19
- }
20
- cycles_f=GetTSC;
21
- cr->swaps[Gs->num]=swaps;
22
- cr->cycles[Gs->num]=cycles_f-cycles_0;
23
- LBtr(&cr->mp_not_done_flags,Gs->num);
24
- }
25
-
26
- public U0 CPURep(Bool full=FALSE)
27
- {//Report number of cores and clock freq.
28
- I64 i,total_swaps,total_cycles;
29
- F64 t0,tf;
30
- CCPURep cr;
31
-
32
- if (!full)
33
- "%03X Cores %6h?nHz\n",mp_cnt,ToF64(cnts.time_stamp_freq);
34
- else {
35
- cr.swaps=CAlloc(sizeof(I64)*mp_cnt);
36
- cr.cycles=CAlloc(sizeof(I64)*mp_cnt);
37
- cr.mp_start=cr.mp_end=FALSE;
38
- cr.mp_not_done_flags=1<<mp_cnt-1;
39
- for (i=0;i<mp_cnt;i++)
40
- Spawn(&MPCPURep,&cr,NULL,i);
41
-
42
- t0=tS;
43
- cr.mp_start=TRUE;
44
- Sleep(2000);
45
- cr.mp_end=TRUE;
46
- while (cr.mp_not_done_flags)
47
- Yield;
48
- tf=tS;
49
-
50
- "\n%03X Cores %6h?nHz\n",mp_cnt,ToF64(cnts.time_stamp_freq);
51
- "\n Context\n"
52
- "CPU Swaps/s Cycles\n"
53
- "--- ------------- -----------------\n";
54
- total_swaps=0;
55
- total_cycles=0;
56
- for (i=0;i<mp_cnt;i++) {
57
- " %02X %13,d %17,d\n",i,
58
- ToI64(cr.swaps[i]/(tf-t0)),ToI64(cr.cycles[i]/(tf-t0));
59
- total_swaps+=cr.swaps[i];
60
- total_cycles+=cr.cycles[i];
61
- }
62
- "--- ------------- -----------------\n";
63
- "%03X %13,d %17,d\n",i,
64
- ToI64(total_swaps/(tf-t0)),ToI64(total_cycles/(tf-t0));
65
- "Avg %13,d %17,d\n\n",
66
- ToI64(total_swaps/(tf-t0)/i),ToI64(total_cycles/(tf-t0)/i);
67
- "Avg Cycles/Swap: %12.6f\n",ToF64(total_cycles)/total_swaps;
68
- "Avg Time/Swap : %12.6fns\n\n",(tf-t0)*1000000000.0*i/total_swaps;
69
- Free(cr.swaps);
70
- Free(cr.cycles);
71
- }
72
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:a75d72382236fdbe325d34174c9ca704714cd1ec28db11c16c2f001377013354
3
+ size 1822
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/Ctrls/CtrlsA.HC CHANGED
@@ -1,388 +1,3 @@
1
- public CCtrl *CtrlFindUnique(CTask *haystack_task,I64 needle_type)
2
- {//Find task ctrl given $LK,"ctrl_type",A="MN:CTRLT_VIEWING_ANGLES"$.
3
- CCtrl *c;
4
- c=haystack_task->next_ctrl;
5
- while (c!=&haystack_task->next_ctrl) {
6
- if (c->type==needle_type)
7
- return c;
8
- c=c->next;
9
- }
10
- return NULL;
11
- }
12
-
13
- U0 CtrlsUpdate(CTask *task)
14
- {
15
- CCtrl *c;
16
- c=task->next_ctrl;
17
- while (c!=&task->next_ctrl) {
18
- if (c->update_derived_vals)
19
- (*c->update_derived_vals)(c);
20
- if (c->flags&CTRLF_BORDER) {
21
- c->scrn_left =gr.pan_text_x+task->pix_left+c->left-FONT_WIDTH;
22
- c->scrn_right =gr.pan_text_x+task->pix_left+c->right-FONT_WIDTH;
23
- c->scrn_top =gr.pan_text_y+task->pix_top+c->top-FONT_HEIGHT;
24
- c->scrn_bottom=gr.pan_text_y+task->pix_top+c->bottom-FONT_HEIGHT;
25
- } else {
26
- c->scrn_left =gr.pan_text_x+task->pix_left+c->left;
27
- c->scrn_right =gr.pan_text_x+task->pix_left+c->right;
28
- c->scrn_top =gr.pan_text_y+task->pix_top+c->top;
29
- c->scrn_bottom=gr.pan_text_y+task->pix_top+c->bottom;
30
- }
31
- c=c->next;
32
- }
33
- }
34
-
35
- fp_update_ctrls=&CtrlsUpdate;
36
-
37
- Bool CtrlInsideRect(CCtrl *c,I64 x,I64 y)
38
- {//scrn coordinates
39
- if (c->scrn_left<=x<=c->scrn_right &&
40
- c->scrn_top<=y<=c->scrn_bottom)
41
- return TRUE;
42
- else
43
- return FALSE;
44
- }
45
-
46
- public Bool CtrlInside(CCtrl *c,I64 x,I64 y)
47
- {//Is x,y inside a ctrl?
48
- if (c->flags&CTRLF_SHOW) {
49
- if (c->inside_ctrl)
50
- return (*c->inside_ctrl)(c,x,y);
51
- else
52
- return CtrlInsideRect(c,x,y);
53
- } else
54
- return FALSE;
55
- }
56
-
57
- U0 DrawCtrls(CTask *task)
58
- {
59
- CCtrl *c;
60
- CDC *dc=DCAlias(gr.dc2,task);
61
- c=task->next_ctrl;
62
- while (c!=&task->next_ctrl) {
63
- if (c->flags&CTRLF_SHOW) {
64
- if (c->flags&CTRLF_BORDER) {
65
- if (!Bt(&task->display_flags,DISPLAYf_NO_BORDER)) {
66
- PUSHFD
67
- CLI
68
- while (LBts(&task->task_flags,TASKf_TASK_LOCK))
69
- PAUSE
70
-
71
- task->win_left--; //Allow drawing on border
72
- task->win_right++;
73
- task->win_top--;
74
- task->win_bottom++;
75
- WinDerivedValsUpdate(task);
76
-
77
- LBtr(&task->task_flags,TASKf_TASK_LOCK);
78
- POPFD
79
-
80
- if (c->draw_it)
81
- (*c->draw_it)(dc,c);
82
-
83
- PUSHFD
84
- CLI
85
- while (LBts(&task->task_flags,TASKf_TASK_LOCK))
86
- PAUSE
87
-
88
- task->win_left++;
89
- task->win_right--;
90
- task->win_top++;
91
- task->win_bottom--;
92
- WinDerivedValsUpdate(task);
93
-
94
- LBtr(&task->task_flags,TASKf_TASK_LOCK);
95
- POPFD
96
- }
97
- } else
98
- if (c->draw_it)
99
- (*c->draw_it)(dc,c);
100
- }
101
- c=c->next;
102
- }
103
- DCDel(dc);
104
- }
105
-
106
- #define WIN_SCROLL_SIZE 8
107
- #define WIN_SCROLL_BORDER_BONUS 4
108
- U0 DrawWinScroll(CDC *dc,CCtrl *c)
109
- {
110
- CWinScroll *s=c->state;
111
-
112
- if (c->flags&CTRLF_CLICKED)
113
- dc->color=s->color>>4;
114
- else
115
- dc->color=s->color&0xF;
116
- GrRect(dc,c->left,c->top,c->right-c->left+1,c->bottom-c->top+1);
117
-
118
- if (c->flags&CTRLF_CLICKED)
119
- dc->color=s->color&0xF;
120
- else
121
- dc->color=s->color>>4;
122
- GrRect(dc,c->left+2,c->top+2,c->right-c->left+1-4,c->bottom-c->top+1-4);
123
- }
124
-
125
- U0 WinDerivedScrollValsUpdate(CCtrl *c)
126
- {
127
- CWinScroll *s=c->state;
128
- I64 range;
129
- if (s->max<s->min) s->max=s->min;
130
- if (s->pos<s->min) s->pos=s->min;
131
- if (s->pos>s->max) s->pos=s->max;
132
- s->color=c->win_task->border_attr&0xF^0xF+
133
- (c->win_task->border_attr&0xF)<<4;
134
- range=s->max-s->min;
135
- if (!range) range=1;
136
- switch (c->type) {
137
- case CTRLT_WIN_HSCROLL:
138
- c->left =gr.pan_text_x+FONT_WIDTH-WIN_SCROLL_BORDER_BONUS+
139
- (s->pos-s->min)*(c->win_task->pix_width+2*WIN_SCROLL_BORDER_BONUS
140
- -WIN_SCROLL_SIZE)/range;
141
- c->right =c->left+WIN_SCROLL_SIZE-1;
142
- c->top =gr.pan_text_y+FONT_HEIGHT+
143
- (FONT_WIDTH-WIN_SCROLL_SIZE)/2+c->win_task->pix_height;
144
- c->bottom=c->top+WIN_SCROLL_SIZE-1;
145
- break;
146
- case CTRLT_WIN_VSCROLL:
147
- c->left =gr.pan_text_x+FONT_WIDTH+
148
- (FONT_WIDTH-WIN_SCROLL_SIZE)/2+c->win_task->pix_width;
149
- c->right =c->left+WIN_SCROLL_SIZE-1;
150
- c->top =gr.pan_text_y+FONT_HEIGHT-WIN_SCROLL_BORDER_BONUS+
151
- (s->pos-s->min)*(c->win_task->pix_height+
152
- 2*WIN_SCROLL_BORDER_BONUS-WIN_SCROLL_SIZE)/range;
153
- c->bottom=c->top+WIN_SCROLL_SIZE-1;
154
- break;
155
- }
156
- }
157
-
158
- U0 LeftClickHWinScroll(CCtrl *c,I64 x,I64,Bool down)
159
- {
160
- CTask *task=c->win_task;
161
- CWinScroll *s=c->state;
162
- I64 range=task->pix_width+2*WIN_SCROLL_BORDER_BONUS-WIN_SCROLL_SIZE;
163
- LBts(&s->flags,WSSf_SET_TO_POS);
164
- s->pos=((x-(FONT_WIDTH-WIN_SCROLL_BORDER_BONUS))
165
- *(s->max-s->min+1)+range/2)/range+s->min;
166
- if (down)
167
- c->flags|=CTRLF_CLICKED;
168
- else
169
- c->flags&=~CTRLF_CLICKED;
170
- if (c->update_derived_vals)
171
- (*c->update_derived_vals)(c);
172
- }
173
-
174
- U0 LeftClickVWinScroll(CCtrl *c,I64,I64 y,Bool down)
175
- {
176
- CTask *task=c->win_task;
177
- CWinScroll *s=c->state;
178
- I64 range=task->pix_height+2*WIN_SCROLL_BORDER_BONUS-WIN_SCROLL_SIZE;
179
- LBts(&s->flags,WSSf_SET_TO_POS);
180
- s->pos=((y-(FONT_HEIGHT-WIN_SCROLL_BORDER_BONUS))
181
- *(s->max-s->min+1)+range/2)/range+s->min;
182
- if (down)
183
- c->flags|=CTRLF_CLICKED;
184
- else
185
- c->flags&=~CTRLF_CLICKED;
186
- if (c->update_derived_vals)
187
- (*c->update_derived_vals)(c);
188
- }
189
-
190
- U0 WheelChangeWinScroll(CCtrl *c,I64 delta)
191
- {
192
- CWinScroll *s=c->state;
193
- LBts(&s->flags,WSSf_SET_TO_POS);
194
- s->pos+=delta;
195
- if (c->update_derived_vals)
196
- (*c->update_derived_vals)(c);
197
- }
198
-
199
- U0 WinScrollsInit(CTask *task)
200
- {
201
- CCtrl *c;
202
-
203
- if (!CtrlFindUnique(task,CTRLT_WIN_HSCROLL)) {
204
- c=CAlloc(sizeof(CCtrl));
205
- c->win_task=task;
206
- c->flags=CTRLF_SHOW|CTRLF_BORDER|CTRLF_CAPTURE_LEFT_MS;
207
- c->type=CTRLT_WIN_HSCROLL;
208
- c->state=&task->horz_scroll;
209
- c->update_derived_vals=&WinDerivedScrollValsUpdate;
210
- c->draw_it=&DrawWinScroll;
211
- c->left_click=&LeftClickHWinScroll;
212
- QueIns(c,task->last_ctrl);
213
- }
214
-
215
- if (!CtrlFindUnique(task,CTRLT_WIN_VSCROLL)) {
216
- c=CAlloc(sizeof(CCtrl));
217
- c->win_task=task;
218
- c->flags=CTRLF_SHOW|CTRLF_BORDER|CTRLF_CAPTURE_LEFT_MS;
219
- c->type=CTRLT_WIN_VSCROLL;
220
- c->state=&task->vert_scroll;
221
- c->update_derived_vals=&WinDerivedScrollValsUpdate;
222
- c->draw_it=&DrawWinScroll;
223
- c->left_click=&LeftClickVWinScroll;
224
- c->wheel_chg=&WheelChangeWinScroll;
225
- QueIns(c,task->last_ctrl);
226
- }
227
- TaskDerivedValsUpdate(task);
228
- }
229
- #define VIEWANGLES_SPACING 22
230
- #define VIEWANGLES_RANGE 48
231
- #define VIEWANGLES_BORDER 2
232
- #define VIEWANGLES_SNAP 2
233
-
234
- U0 DrawViewAnglesCtrl(CDC *dc,CCtrl *c)
235
- {
236
- I64 i,j;
237
- CViewAngles *s=c->state;
238
-
239
- dc->color=s->cbd;
240
- GrRect(dc, c->left,c->top,VIEWANGLES_SPACING*4+3,
241
- VIEWANGLES_SPACING*2+VIEWANGLES_RANGE);
242
- dc->color=s->cbg;
243
- GrRect(dc, c->left+VIEWANGLES_BORDER,c->top+VIEWANGLES_BORDER,
244
- VIEWANGLES_SPACING*4+3-2*VIEWANGLES_BORDER,
245
- VIEWANGLES_SPACING*2+VIEWANGLES_RANGE-2*VIEWANGLES_BORDER);
246
- dc->color=s->cfg;
247
- GrLine(dc,c->left+VIEWANGLES_SPACING,c->top+VIEWANGLES_SPACING,
248
- c->left+VIEWANGLES_SPACING,c->top+VIEWANGLES_SPACING+
249
- VIEWANGLES_RANGE-1);
250
- GrLine(dc,c->left+2*VIEWANGLES_SPACING+1,c->top+VIEWANGLES_SPACING,
251
- c->left+2*VIEWANGLES_SPACING+1,c->top+VIEWANGLES_SPACING+
252
- VIEWANGLES_RANGE-1);
253
- GrLine(dc,c->left+3*VIEWANGLES_SPACING+2,c->top+VIEWANGLES_SPACING,
254
- c->left+3*VIEWANGLES_SPACING+2,c->top+VIEWANGLES_SPACING+
255
- VIEWANGLES_RANGE-1);
256
- for (i=1;i<VIEWANGLES_RANGE+1;i+=2*VIEWANGLES_SNAP) {
257
- j=2-i/3&1;
258
- GrLine(dc,c->left+VIEWANGLES_SPACING-j,c->bottom-VIEWANGLES_SPACING-i,
259
- c->left+VIEWANGLES_SPACING+j,c->bottom
260
- -VIEWANGLES_SPACING-i);
261
- GrLine(dc,c->left+2*VIEWANGLES_SPACING+1-j,c->bottom-VIEWANGLES_SPACING-i,
262
- c->left+2*VIEWANGLES_SPACING+1+j,c->bottom
263
- -VIEWANGLES_SPACING-i);
264
- GrLine(dc,c->left+3*VIEWANGLES_SPACING+2-j,c->bottom-VIEWANGLES_SPACING-i,
265
- c->left+3*VIEWANGLES_SPACING+2+j,c->bottom
266
- -VIEWANGLES_SPACING-i);
267
- }
268
-
269
- dc->color=s->cx;
270
- GrPrint(dc,c->left+VIEWANGLES_SPACING-FONT_WIDTH/2,
271
- c->top+VIEWANGLES_SPACING-(1+FONT_HEIGHT),"X");
272
- GrPrint(dc,c->left+VIEWANGLES_SPACING-3*FONT_WIDTH/2,
273
- c->top+VIEWANGLES_SPACING+VIEWANGLES_RANGE+3,
274
- "%3d",s->sx*360/VIEWANGLES_RANGE);
275
- i=c->left+VIEWANGLES_SPACING;
276
- if (s->sx>VIEWANGLES_RANGE/2)
277
- j=-VIEWANGLES_RANGE/2+s->sx;
278
- else
279
- j=s->sx+VIEWANGLES_RANGE/2;
280
- j=c->top+VIEWANGLES_SPACING+VIEWANGLES_RANGE-1-j;
281
- GrRect(dc,i-3,j-2,7,5);
282
- dc->color=s->cx^8;
283
- GrRect(dc,i-2,j-1,5,3);
284
-
285
- dc->color=s->cy;
286
- GrPrint(dc,c->left+2*VIEWANGLES_SPACING+1-FONT_WIDTH/2,
287
- c->top+VIEWANGLES_SPACING-(1+FONT_HEIGHT),"Y");
288
- GrPrint(dc,c->left+2*VIEWANGLES_SPACING+1-3*FONT_WIDTH/2,
289
- c->top+VIEWANGLES_SPACING+VIEWANGLES_RANGE+3,
290
- "%3d",s->sy*360/VIEWANGLES_RANGE);
291
- i=c->left+2*VIEWANGLES_SPACING+1;
292
- if (s->sy>VIEWANGLES_RANGE/2)
293
- j=-VIEWANGLES_RANGE/2+s->sy;
294
- else
295
- j=s->sy+VIEWANGLES_RANGE/2;
296
- j=c->top+VIEWANGLES_SPACING+VIEWANGLES_RANGE-1-j;
297
- GrRect(dc,i-3,j-2,7,5);
298
- dc->color=s->cy^8;
299
- GrRect(dc,i-2,j-1,5,3);
300
-
301
- dc->color=s->cz;
302
- GrPrint(dc,c->left+3*VIEWANGLES_SPACING+2-FONT_WIDTH/2,
303
- c->top+VIEWANGLES_SPACING-(1+FONT_HEIGHT),"Z");
304
- GrPrint(dc,c->left+3*VIEWANGLES_SPACING+2-3*FONT_WIDTH/2,
305
- c->top+VIEWANGLES_SPACING+VIEWANGLES_RANGE+3,
306
- "%3d",s->sz*360/VIEWANGLES_RANGE);
307
- i=c->left+3*VIEWANGLES_SPACING+2;
308
- if (s->sz>VIEWANGLES_RANGE/2)
309
- j=-VIEWANGLES_RANGE/2+s->sz;
310
- else
311
- j=s->sz+VIEWANGLES_RANGE/2;
312
- j=c->top+VIEWANGLES_SPACING+VIEWANGLES_RANGE-1-j;
313
- GrRect(dc,i-3,j-2,7,5);
314
- dc->color=s->cz^8;
315
- GrRect(dc,i-2,j-1,5,3);
316
- }
317
-
318
- U0 UpdateDerivedViewAnglesCtrl(CCtrl *c)
319
- {
320
- CViewAngles *s=c->state;
321
- c->left=c->win_task->pix_width-(VIEWANGLES_SPACING*4+3);
322
- c->right=c->left+VIEWANGLES_SPACING*4+3;
323
- c->top=c->win_task->pix_height-(VIEWANGLES_SPACING*2+VIEWANGLES_RANGE);
324
- c->bottom=c->top+VIEWANGLES_SPACING*2+VIEWANGLES_RANGE;
325
- s->sx=ClampI64(RoundI64(s->sx,VIEWANGLES_SNAP),0,VIEWANGLES_RANGE-1);
326
- s->sy=ClampI64(RoundI64(s->sy,VIEWANGLES_SNAP),0,VIEWANGLES_RANGE-1);
327
- s->sz=ClampI64(RoundI64(s->sz,VIEWANGLES_SNAP),0,VIEWANGLES_RANGE-1);
328
- s->ax=2*�*s->sx/VIEWANGLES_RANGE;
329
- s->ay=2*�*s->sy/VIEWANGLES_RANGE;
330
- s->az=2*�*s->sz/VIEWANGLES_RANGE;
331
- }
332
-
333
- U0 LeftClickViewAngles(CCtrl *c,I64 x,I64 y,Bool)
334
- {
335
- CViewAngles *s=c->state;
336
- I64 i;
337
- i=VIEWANGLES_RANGE-1-(y-(c->top+VIEWANGLES_SPACING));
338
- if (i>=VIEWANGLES_RANGE/2)
339
- i-=VIEWANGLES_RANGE/2;
340
- else
341
- i+=VIEWANGLES_RANGE/2;
342
- if (x<c->left+(c->right-c->left)/3)
343
- s->sx=i;
344
- else if (x<c->left+2*(c->right-c->left)/3)
345
- s->sy=i;
346
- else
347
- s->sz=i;
348
- if (c->update_derived_vals)
349
- (*c->update_derived_vals)(c);
350
- }
351
-
352
- public CCtrl *ViewAnglesNew(CTask *task=NULL)
353
- {//Create view angle ctrl. See $LK,"::/Demo/Graphics/Shading.HC"$.
354
- CCtrl *c;
355
- CViewAngles *s;
356
- if (!task) task=Fs;
357
- if (!(c=CtrlFindUnique(task,CTRLT_VIEWING_ANGLES))) {
358
- s=CAlloc(sizeof(CViewAngles),task);
359
- c=CAlloc(sizeof(CCtrl));
360
- s->cbd=BLUE;
361
- s->cbg=LTBLUE;
362
- s->cfg=BLACK;
363
- s->cx=LTGREEN;
364
- s->cy=GREEN;
365
- s->cz=LTGREEN;
366
- c->win_task=task;
367
- c->flags=CTRLF_SHOW|CTRLF_CAPTURE_LEFT_MS;
368
- c->type=CTRLT_VIEWING_ANGLES;
369
- c->state=s;
370
- c->draw_it=&DrawViewAnglesCtrl;
371
- c->left_click=&LeftClickViewAngles;
372
- c->update_derived_vals=&UpdateDerivedViewAnglesCtrl;
373
- QueIns(c,task->last_ctrl);
374
- TaskDerivedValsUpdate(task);
375
- }
376
- return c;
377
- }
378
-
379
- public U0 ViewAnglesDel(CTask *task=NULL)
380
- {//Free view angle ctrl.
381
- CCtrl *c;
382
- if (!task) task=Fs;
383
- if (c=CtrlFindUnique(task,CTRLT_VIEWING_ANGLES)) {
384
- QueRem(c);
385
- Free(c->state);
386
- Free(c);
387
- }
388
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:dc56e5d3e41fb8489fd2a2081abbca998a9d2aba8e3c0b439f4db2b008503afc
3
+ size 11095
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/Ctrls/CtrlsBttn.HC CHANGED
@@ -1,91 +1,3 @@
1
- #define BTTN_BORDER 2
2
-
3
- #define BTF_DONT_FREE 1
4
-
5
- class CCtrlBttnState
6
- {
7
- I64 state,num_states,flags;
8
- U8 *state_texts;
9
- CColorROPU32 *state_colors;
10
- };
11
-
12
- U0 DrawCtrlBttn(CDC *dc,CCtrl *c)
13
- {
14
- CCtrlBttnState *s=c->state;
15
- I64 l;
16
- U8 *st;
17
-
18
- dc->color=BLACK;
19
- GrRect(dc,c->left,c->top,c->right-c->left+1,c->bottom-c->top+1);
20
- if (!(st=LstSub(s->state,s->state_texts)))
21
- st=s->state_texts;
22
- dc->color=s->state_colors[s->state];
23
- l=StrLen(st);
24
- GrRect(dc,c->left+BTTN_BORDER,c->top+BTTN_BORDER,
25
- c->right-c->left+1-BTTN_BORDER*2,
26
- c->bottom-c->top+1-BTTN_BORDER*2);
27
- dc->color=s->state_colors[s->state]^(WHITE<<16+WHITE);
28
- GrPrint(dc,(c->left+c->right+1-l*FONT_WIDTH)>>1,
29
- (c->top+c->bottom+1-FONT_HEIGHT)>>1,"%s",st);
30
- }
31
-
32
- U0 LeftClickCtrlBttn(CCtrl *c,I64,I64,Bool down)
33
- {
34
- CCtrlBttnState *s=c->state;
35
- if (down) {
36
- s->state++;
37
- if (s->state==s->num_states)
38
- s->state=0;
39
- }
40
- }
41
-
42
- public CCtrl *CtrlBttnNew(I64 x,I64 y,I64 width=-1,I64 height=-1,
43
- I64 num_states=1,U8 *state_texts,
44
- I32 *state_colors,CCtrlBttnState *_s=NULL)
45
- {//Create bttn ctrl. See $LK,"::/Apps/Strut/Strut.HC"$.
46
- CCtrl *res;
47
- CCtrlBttnState *s;
48
- I64 i,j,l;
49
- U8 *st;
50
- if (width<0) {
51
- l=1;
52
- for (i=0;i<num_states;i++)
53
- if (st=LstSub(i,state_texts)) {
54
- j=StrLen(st);
55
- if (j>l) l=j;
56
- }
57
- width=BTTN_BORDER*4+l*FONT_WIDTH;
58
- }
59
- if (height<0) height=BTTN_BORDER*4+FONT_HEIGHT;
60
- res=CAlloc(sizeof(CCtrl));
61
- if (_s) {
62
- s=_s;
63
- MemSet(s,0,sizeof(CCtrlBttnState));
64
- } else {
65
- s=CAlloc(sizeof(CCtrlBttnState));
66
- s->flags=BTF_DONT_FREE;
67
- }
68
- s->num_states=num_states;
69
- s->state_texts=state_texts;
70
- s->state_colors=state_colors;
71
- res->win_task=Fs;
72
- res->flags=CTRLF_SHOW;
73
- res->type=CTRLT_GENERIC;
74
- res->state=s;
75
- res->draw_it=&DrawCtrlBttn;
76
- res->left_click=&LeftClickCtrlBttn;
77
- res->left=x;
78
- res->top=y;
79
- res->right=res->left+width-1;
80
- res->bottom=res->top+height-1;
81
- QueIns(res,Fs->last_ctrl);
82
- return res;
83
- }
84
-
85
- public U0 CtrlBttnDel(CCtrl *c)
86
- {//Free bttn ctrl.
87
- QueRem(c);
88
- if (!(c->flags&BTF_DONT_FREE))
89
- Free(c->state);
90
- Free(c);
91
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:be24034b653ef4341e9d07f1df0fa547b4990f0ae6ea9b1054b9c3892eca74ac
3
+ size 2071
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/Ctrls/CtrlsSlider.HC CHANGED
@@ -1,214 +1,3 @@
1
- class CTemplateCSSlider
2
- {
3
- CTemplateCSSlider *next,*last;
4
- U8 *name;
5
- I64 num;
6
- };
7
-
8
- class CTemplateCS
9
- {
10
- CTemplateCSSlider *next_slider,*last_slider;
11
- I64 num_sliders,range,spacing,border;
12
- U8 *glbl_name;
13
- };
14
-
15
- CTemplateCS *CtrlSliderGet()
16
- {
17
- CTemplateCSSlider *tmps;
18
- U8 *st,pmt[STR_LEN];
19
- CTemplateCS *res=CAlloc(sizeof(CTemplateCS));
20
-
21
- "$$PURPLE$$Ctrl Slider$$FG$$\n\n";
22
-
23
- res->glbl_name=GetStr("Glbl Struct Name (ENTER for No Glbl):");
24
- res->range=GetI64 ("Range (%4d):",30);
25
- res->spacing=GetI64("Spacing (%4d):",20);
26
- res->border=GetI64 ("Border (%4d):",2);
27
-
28
- res->next_slider=res->last_slider=&res->next_slider;
29
- while (TRUE) {
30
- StrPrint(pmt,"Slider #%d Name:",res->num_sliders+1);
31
- st=GetStr(pmt);
32
- if (!*st) {
33
- Free(st);
34
- break;
35
- }
36
- tmps=CAlloc(sizeof(CTemplateCSSlider));
37
- tmps->name=st;
38
- QueIns(tmps,res->last_slider);
39
- tmps->num=res->num_sliders++;
40
- }
41
- return res;
42
- }
43
-
44
- U0 TemplateCtrlSlider(CDoc *doc)
45
- {
46
- CTask *task;
47
- CTemplateCS *m=NULL;
48
- CTemplateCSSlider *tmps;
49
- I64 i;
50
-
51
- DocUnlock(doc);
52
- DocRecalc(doc);
53
- DocCaptureUndo(doc,TRUE);
54
-
55
- task=User("CTemplateCS **_m=0x%X;*_m=CtrlSliderGet;\n",&m);
56
- while (!m)
57
- Yield;
58
-
59
- DocPrint(doc,
60
- "#define SLIDER_RANGE\t%d
61
- #define SLIDER_SPACING\t%d
62
- #define SLIDER_BORDER\t%d
63
-
64
- class CSliderState
65
- {
66
- ",m->range,m->spacing,m->border);
67
-
68
- tmps=m->next_slider;
69
- while (tmps!=&m->next_slider) {
70
- DocPrint(doc," I64 %s;\n",tmps->name);
71
- tmps=tmps->next;
72
- }
73
- if (*m->glbl_name)
74
- DocPrint(doc,"} %s;\n",m->glbl_name);
75
- else
76
- DocPrint(doc,"};\n");
77
-
78
- DocPrint(doc,
79
- "
80
- U0 DrawCtrlSlider(CDC *dc,CCtrl *c)
81
- {
82
- CSliderState *s=c->state;
83
-
84
- dc->color=LTRED;
85
- GrRect(dc, c->left,c->top,%d*SLIDER_SPACING+%d,SLIDER_SPACING*2+SLIDER_RANGE);
86
- dc->color=BLUE;
87
- GrRect(dc, c->left+SLIDER_BORDER,c->top+SLIDER_BORDER,
88
- %d*SLIDER_SPACING+%d-2*SLIDER_BORDER,SLIDER_SPACING*2
89
- +SLIDER_RANGE-2*SLIDER_BORDER);
90
- dc->color=BLACK;
91
- ",m->num_sliders+1,m->num_sliders,m->num_sliders+1,m->num_sliders);
92
-
93
- for (i=0;i<m->num_sliders;i++)
94
- DocPrint(doc,
95
- " GrLine(dc,c->left+%d*SLIDER_SPACING+%d,c->top+SLIDER_SPACING,
96
- c->left+%d*SLIDER_SPACING+%d,c->top+SLIDER_SPACING+SLIDER_RANGE-1);
97
- ",i+1,i,i+1,i);
98
-
99
- DocPrint(doc," dc->color=LTRED;\n");
100
-
101
- tmps=m->next_slider;
102
- while (tmps!=&m->next_slider) {
103
- DocPrint(doc,
104
- " GrPrint(dc,c->left+%d*SLIDER_SPACING+%d-FONT_WIDTH/2,
105
- c->top+SLIDER_SPACING+SLIDER_RANGE+3,
106
- \"%%d\",s->%s*10/SLIDER_RANGE);\n",
107
- tmps->num+1,tmps->num,tmps->name);
108
- tmps=tmps->next;
109
- }
110
-
111
- tmps=m->next_slider;
112
- while (tmps!=&m->next_slider) {
113
- DocPrint(doc,
114
- " GrRect(dc,c->left+%d*SLIDER_SPACING+%d-3,"
115
- "c->top+SLIDER_SPACING+SLIDER_RANGE-1-s->%s-2,7,5);\n",
116
- tmps->num+1,tmps->num,tmps->name);
117
- tmps=tmps->next;
118
- }
119
- DocPrint(doc," dc->color=YELLOW;\n");
120
-
121
- tmps=m->next_slider;
122
- while (tmps!=&m->next_slider) {
123
- DocPrint(doc," GrRect(dc,c->left+%d*SLIDER_SPACING+%d-2,"
124
- "c->top+SLIDER_SPACING+SLIDER_RANGE-1-s->%s-1,5,3);\n",
125
- tmps->num+1,tmps->num,tmps->name);
126
- tmps=tmps->next;
127
- }
128
- DocPrint(doc,
129
- "}
130
-
131
- U0 UpdateDerivedCtrlSlider(CCtrl *c)
132
- {
133
- CSliderState *s=c->state;
134
- c->left=c->win_task->pix_width/2-(SLIDER_SPACING*3+2)/2;
135
- c->right=c->left+%d*SLIDER_SPACING+%d;
136
- c->top=c->win_task->pix_height/2-(SLIDER_SPACING*2+SLIDER_RANGE)/2;
137
- c->bottom=c->top+SLIDER_SPACING*2+SLIDER_RANGE;
138
- ",m->num_sliders+1,m->num_sliders);
139
-
140
- tmps=m->next_slider;
141
- while (tmps!=&m->next_slider) {
142
- DocPrint(doc," s->%s=ClampI64(s->%s,0,SLIDER_RANGE-1);\n",
143
- tmps->name,tmps->name);
144
- tmps=tmps->next;
145
- }
146
- DocPrint(doc,
147
- "}
148
-
149
- U0 LeftClickSlider(CCtrl *c,I64 x,I64 y,Bool down)
150
- {
151
- no_warn down;
152
- CSliderState *s=c->state;
153
- ");
154
-
155
- tmps=m->next_slider;
156
- while (tmps!=&m->next_slider) {
157
- DocPrint(doc," ");
158
- if (tmps!=m->next_slider)
159
- DocPrint(doc,"else ");
160
- if (tmps->next==&m->next_slider)
161
- DocPrint(doc,"\n");
162
- else
163
- DocPrint(doc,"if (x<c->left+%d*SLIDER_SPACING+%d+SLIDER_SPACING/2)\n",
164
- tmps->num+1,tmps->num);
165
- DocPrint(doc," s->%s=SLIDER_RANGE-1-(y-(c->top+SLIDER_SPACING));\n",
166
- tmps->name);
167
- tmps=tmps->next;
168
- }
169
-
170
- DocPrint(doc,
171
- " if (c->update_derived_vals)
172
- (*c->update_derived_vals)(c);
173
- }
174
-
175
- CCtrl *SliderNew()
176
- {
177
- CCtrl *c=CAlloc(sizeof(CCtrl));
178
- c->win_task=Fs;
179
- c->flags=CTRLF_SHOW|CTRLF_CAPTURE_LEFT_MS;
180
- c->type=CTRLT_GENERIC;
181
- ");
182
- if (*m->glbl_name)
183
- DocPrint(doc," c->state=&%s;\n"
184
- " MemSet(&%s,0,sizeof(CSliderState));\n",m->glbl_name,m->glbl_name);
185
- else
186
- DocPrint(doc, " c->state=CAlloc(sizeof(CSliderState));\n");
187
- DocPrint(doc,
188
- " c->draw_it=&DrawCtrlSlider;
189
- c->left_click=&LeftClickSlider;
190
- c->update_derived_vals=&UpdateDerivedCtrlSlider;
191
- QueIns(c,Fs->last_ctrl);
192
- TaskDerivedValsUpdate;
193
- return c;
194
- }
195
-
196
- U0 SliderDel(CCtrl *c)
197
- {
198
- QueRem(c);
199
- ");
200
- if (!*m->glbl_name)
201
- DocPrint(doc," Free(c->state);\n");
202
- DocPrint(doc,
203
- " Free(c);
204
- }
205
- ");
206
-
207
- Kill(task); //This frees memory.
208
-
209
- RegOneTimePopUp(ARf_MANAGE_SLIDER,
210
- "Modify the code to your heart's content.\n"
211
- "The code is no longer managed.\n");
212
-
213
- DocLock(doc);
214
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:a99b85f224bed986aa36c83f3d9b25aa06b325e0363ae390bcc0e3e6cee90396
3
+ size 5105
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/Ctrls/MakeCtrls.HC CHANGED
@@ -1,8 +1,3 @@
1
- Cd(__DIR__);;
2
-
3
- #help_index "Ctrls"
4
- #help_file "::/Doc/Ctrls"
5
- #include "CtrlsA"
6
- #include "CtrlsBttn"
7
- #include "CtrlsSlider"
8
- Cd("..");;
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:5e38edfd514597402c16d16dd1ebd0d49d314c6cd18d8853edc2b51d8eaa6735
3
+ size 134
 
 
 
 
 
Adam/DevInfo.HC CHANGED
@@ -1,220 +1,3 @@
1
- #help_index "PCI;Processor;Devices;Info"
2
-
3
- //The file was downloaded from
4
- //http://www.pcidatabase.com/reports.php?type=tab-delimeted
5
-
6
- #define PCI_DEV_FILE "::/Misc/PCIDevices.DD.Z"
7
-
8
- /****
9
- //1) Download http://www.pcidatabase.com/reports.php?type=tab-delimeted
10
- //2) Rename to ::/Misc/PCIDevices.DD.Z
11
- //3) ToDolDoc("::/Misc/PCIDevices.DD.Z");
12
- //4) Edit and remove file header and tail
13
- //5) Text find-and-replace "=0A=" with "". (Doesn't seem necessary anmore.)
14
- //6) Run PCIDevFileGen(). (Doesn't seem necessary anmore.)
15
-
16
- public U0 PCIDevFileGen()
17
- {
18
- Bool first=TRUE,del=FALSE,del2=FALSE,cont=FALSE;
19
- CDoc *doc=DocRead(PCI_DEV_FILE,
20
- DOCF_PLAIN_TEXT|DOCF_DBL_DOLLARS|DOCF_NO_CURSOR);
21
- CDocEntry *doc_e=doc->head.next,*doc_e2;
22
- while (doc_e!=doc) {
23
- doc_e2=doc_e->next;
24
- if (first) {
25
- if (doc_e->type_u8==DOCT_TEXT) {
26
- if (doc_e->tag[0]==';')
27
- del=TRUE;
28
- }
29
- first=FALSE;
30
- }
31
- if (doc_e->type_u8==DOCT_TEXT && doc_e->tag[StrLen(doc_e->tag)-1]=='=' &&
32
- doc_e2->type_u8==DOCT_NEW_LINE) {
33
- doc_e->tag[StrLen(doc_e->tag)-1]=CH_SPACE;
34
- cont=TRUE;
35
- }
36
- del2=del;
37
- if (doc_e->type_u8==DOCT_NEW_LINE) {
38
- first=TRUE;
39
- del2=FALSE;
40
- if (cont) {
41
- del=TRUE;
42
- cont=FALSE;
43
- }
44
- }
45
- if (del)
46
- DocEntryDel(doc,doc_e);
47
- del=del2;
48
- doc_e=doc_e2;
49
- }
50
- DocWrite(doc);
51
- }
52
- ****/
53
-
54
- //$LK,"::/Misc/PCIDevices.DD",A="PI:::/Misc/PCIDevices.DD"$
55
- U0 PCILookUpSingle(CDoc *doc,I64 m,I64 d,U8 **_vendor,U8 **_dev)
56
- {
57
- Bool first=TRUE;
58
- U8 buf[8],*vendor=NULL,*dev=NULL;
59
- CDocEntry *doc_e=doc->head.next;
60
- while (doc_e!=doc) {
61
- if (first) {
62
- if (doc_e->type_u8==DOCT_TEXT && doc_e->tag[0]!=';' &&
63
- StrLen(doc_e->tag)>=4) {
64
- buf[0](U16)='0x';
65
- buf[2](U32)=doc_e->tag(U32 *)[0];
66
- buf[6]=0;
67
- if (Str2I64(buf)==m) {
68
- doc_e=doc_e->next->next;
69
- if (doc_e->type_u8==DOCT_TEXT) {
70
- vendor=AStrNew(doc_e->tag);
71
- first=FALSE;
72
- break;
73
- }
74
- }
75
- }
76
- first=FALSE;
77
- }
78
- if (doc_e->type_u8==DOCT_NEW_LINE)
79
- first=TRUE;
80
- doc_e=doc_e->next;
81
- }
82
-
83
- if (vendor) {
84
- while (doc_e!=doc) {
85
- if (first) {
86
- if (doc_e->type_u8==DOCT_TAB) {
87
- doc_e=doc_e->next;
88
- if (doc_e->type_u8==DOCT_TEXT && StrLen(doc_e->tag)>=4) {
89
- buf[0](U16)='0x';
90
- buf[2](U32)=doc_e->tag(U32 *)[0];
91
- buf[6]=0;
92
- if (Str2I64(buf)==d) {
93
- doc_e=doc_e->next->next;
94
- if (doc_e->type_u8==DOCT_TEXT) {
95
- dev=AStrNew(doc_e->tag);
96
- break;
97
- }
98
- }
99
- }
100
- } else
101
- break;
102
- first=FALSE;
103
- }
104
- if (doc_e->type_u8==DOCT_NEW_LINE)
105
- first=TRUE;
106
- doc_e=doc_e->next;
107
- }
108
- }
109
-
110
- if (vendor)
111
- *_vendor=vendor;
112
- else
113
- *_vendor=AStrNew("Unknown");
114
-
115
- if (dev)
116
- *_dev=dev;
117
- else
118
- *_dev=AStrNew("Unknown");
119
- }
120
-
121
- U0 PCILookUpDevs()
122
- {
123
- CPCIDev *tmppci;
124
- I64 w1,w2,b,d,f,timeout=32*8*2;
125
- CDoc *doc;
126
- if (dev.pci_head.next!=&dev.pci_head)
127
- return;
128
- doc=DocRead(PCI_DEV_FILE,DOCF_PLAIN_TEXT|DOCF_NO_CURSOR);
129
- for (b=0;b<sys_pci_busses;b++)
130
- for (d=0;d<32;d++)
131
- for (f=0;f<8;f++) {
132
- w1=PCIReadU16(b,d,f,0);
133
- if (w1!=0xFFFF) {
134
- tmppci=ACAlloc(sizeof(CPCIDev));
135
- tmppci->bus=b;
136
- tmppci->dev=d;
137
- tmppci->fun=f;
138
- tmppci->vendor=w1;
139
- tmppci->dev_id=w2=PCIReadU16(b,d,f,2);
140
- tmppci->sub_code=PCIReadU8(b,d,f,0xA);
141
- tmppci->base_code=PCIReadU8(b,d,f,0xB);
142
- PCILookUpSingle(doc,w1,w2,&tmppci->vendor_str,&tmppci->dev_id_str);
143
- QueIns(tmppci,dev.pci_head.last);
144
- timeout=32*8*2;
145
- } else if (sys_pci_busses==256 && --timeout<=0)
146
- goto lud_done;
147
- }
148
- lud_done:
149
- DocDel(doc);
150
- }
151
-
152
- public U0 PCIRep()
153
- {//Report description of PCI devices.
154
- CPCIDev *tmppci;
155
- "PCI Busses:%d\n",sys_pci_busses;
156
- if (!FileFind(PCI_DEV_FILE)) {
157
- "You don't have the PCI device file.\n";
158
- return;
159
- }
160
- PCILookUpDevs;
161
- tmppci=dev.pci_head.next;
162
- while (tmppci!=&dev.pci_head) {
163
- "%02X:%02X:%01X %02X%02X $$GREEN$$%s $$CYAN$$%s$$FG$$\n",
164
- tmppci->bus,tmppci->dev,tmppci->fun,
165
- tmppci->base_code,tmppci->sub_code,
166
- tmppci->vendor_str,tmppci->dev_id_str;
167
- tmppci=tmppci->next;
168
- }
169
- }
170
-
171
- #help_index "Info;Memory/Info"
172
- public U0 MemBIOSRep()
173
- {//Report the memory ranges reported by the BIOS at boot.
174
- U16 *m01=MEM_E801;
175
- CMemE820 *m20=MEM_E820;
176
- CMemRange *tmpmr;
177
- "Standard Addresses\n"
178
- "000A0000-000BFFFF VGA\n"
179
- "FEE00000-FEE00FFF See $$LK,\"APIC\",A=\"MN:LAPIC_BASE\"$$\n\n"
180
- "32 Bit Device Mem\n";
181
- while (LBts(&sys_semas[SEMA_DEV_MEM],0))
182
- Yield;
183
- tmpmr=dev.mem32_head.next;
184
- while (tmpmr!=&dev.mem32_head) {
185
- "%02X:%016X-%016X\n",
186
- tmpmr->type,tmpmr->base,tmpmr->base+tmpmr->size-1;
187
- tmpmr=tmpmr->next;
188
- }
189
- LBtr(&sys_semas[SEMA_DEV_MEM],0);
190
-
191
- "\nBIOS Memory Report 15:E801\n"
192
- "01:0000000000000000-%016X\n",0x100000+m01[0]<<10-1;
193
- "01:0000000001000000-%016X\n",SYS_16MEG_AREA_LIMIT+m01[1]<<16-1;
194
-
195
- if (m20->type) {
196
- '\n';
197
- "BIOS Memory Report 15:E820\n";
198
- while (m20->type) {
199
- "%02X:%016X-%016X\n",m20->type,m20->base,m20->base+m20->len-1;
200
- m20++;
201
- }
202
- }
203
- }
204
-
205
- public U0 MemPageRep()
206
- {//Page Table Report.
207
- "MAPPED\t :%010X with ",mem_mapped_space;
208
- if (Bt(&mem_page_size,30))
209
- "$$RED$$1GIG$$FG$$ pages\n";
210
- else
211
- "$$RED$$2MEG$$FG$$ pages\n";
212
- "PML2\t :%010X 2MEG :%08X\n",
213
- *MEM_PML2(U64 *),*MEM_2MEG_NUM(U64 *);
214
- "PML3\t :%010X 1GIG :%08X\n",
215
- *MEM_PML3(U64 *),*MEM_1GIG_NUM(U64 *);
216
- "PML4\t :%010X 512GIG:%08X\n",
217
- *MEM_PML4(U64 *),*MEM_512GIG_NUM(U64 *);
218
- "FIXED_AREA:%010X\n",SYS_FIXED_AREA;
219
- "HEAP_BASE :%010X\nHEAP_LIMIT:%010X\n",mem_heap_base,mem_heap_limit;
220
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:362aff99e1e7513bf7113e7cb482a9e0d7e334762a680babdd54e92e47d39052
3
+ size 5457
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/DolDoc/DocBin.HC CHANGED
@@ -1,142 +1,3 @@
1
- #help_index "DolDoc/Bin"
2
-
3
- CDocBin *DocBinFindNum(CDoc *haystack_doc,I64 needle_num)
4
- {
5
- CDocBin *b=haystack_doc->bin_head.next;
6
- while (b!=&haystack_doc->bin_head) {
7
- if (b->num==needle_num)
8
- return b;
9
- b=b->next;
10
- }
11
- return NULL;
12
- }
13
-
14
- CDocBin *DocBinFindTag(CDoc *haystack_doc,U8 *needle_tag)
15
- {
16
- CDocBin *b;
17
- if (needle_tag) {
18
- b=haystack_doc->bin_head.next;
19
- while (b!=&haystack_doc->bin_head) {
20
- if (b->tag && !StrCmp(b->tag,needle_tag))
21
- return b;
22
- b=b->next;
23
- }
24
- }
25
- return NULL;
26
- }
27
-
28
- U0 DocBinsValidate(CDoc *doc)
29
- {
30
- Bool unlock=DocLock(doc);
31
- CDocBin *b,*b1;
32
- CDocEntry *doc_e,*doc_e2;
33
- I64 renum_num=0;
34
- b=doc->bin_head.next;
35
- while (b!=&doc->bin_head) {
36
- b->use_cnt=0;
37
- b->tmp_use_cnt=0;
38
- b->renum_num=-1;
39
- Free(b->tag);
40
- b->tag=NULL;
41
- b=b->next;
42
- }
43
- doc_e=doc->head.next;
44
- while (doc_e!=doc) {
45
- doc_e2=doc_e->next;
46
- if (doc_e->de_flags & DOCEF_HAS_BIN) {
47
- if (b=doc_e->bin_data=DocBinFindNum(doc,doc_e->bin_num)) {
48
- if (doc_e->de_flags & DOCEF_BIN_PTR_LINK)
49
- b->tmp_use_cnt=I32_MAX;
50
- if (!b->use_cnt++)
51
- b->renum_num=++renum_num;
52
- doc_e->bin_num=b->renum_num;
53
- if (!b->tag && doc_e->de_flags&DOCEF_TAG && doc_e->tag && *doc_e->tag)
54
- b->tag=StrNew(doc_e->tag,doc->mem_task);
55
- } else {
56
- RawPrint(3000,"Bin Not Found");
57
- doc_e->type=doc_e->de_flags=0;
58
- doc_e->type_u8=DOCT_ERROR;
59
- }
60
- }
61
- doc_e=doc_e2;
62
- }
63
-
64
- b=doc->bin_head.next;
65
- doc->cur_bin_num=1;
66
- while (b!=&doc->bin_head) {
67
- b1=b->next;
68
- if (!b->use_cnt) {
69
- QueRem(b);
70
- Free(b->data);
71
- Free(b);
72
- } else {
73
- b->num=b->renum_num;
74
- if (b->num>=doc->cur_bin_num)
75
- doc->cur_bin_num=b->num+1;
76
- }
77
- b=b1;
78
- }
79
- if (unlock)
80
- DocUnlock(doc);
81
- }
82
-
83
- U0 DocBinDel(CDoc *doc,CDocBin *b)
84
- {
85
- if (doc && b && b->use_cnt) {
86
- b->use_cnt--;
87
- if (!b->use_cnt) {
88
- QueRem(b);
89
- Free(b->tag);
90
- Free(b->data);
91
- Free(b);
92
- }
93
- } else
94
- RawPrint(3000,"DocBinDel");
95
- }
96
-
97
- I64 DocBinPtrRst(CDoc *doc,CDocEntry *doc_e)
98
- {
99
- U8 *st,*st2;
100
- CDoc *doc2;
101
- CDocBin *tmpb,*tmpb2;
102
- I64 i,bin_num=0;
103
- if (doc_e->de_flags&DOCEF_HAS_BIN &&
104
- doc_e->bin_ptr_link && StrLen(doc_e->bin_ptr_link)) {
105
- bin_num=doc_e->bin_num;
106
- st=StrNew(doc_e->bin_ptr_link);
107
- st2=StrNew(st);
108
- StrLastRem(st,",",st2);
109
- i=Str2I64(st2);
110
- if (i>0||*st2) {
111
- doc2=DocRead(st);
112
- if (i>0 && (tmpb2=DocBinFindNum(doc2,i)) ||
113
- i==0 && (tmpb2=DocBinFindTag(doc2,st2))) {
114
- i=1;
115
- if (bin_num>0) {
116
- if (tmpb=DocBinFindNum(doc,bin_num)) {
117
- i=tmpb->use_cnt;
118
- DocBinDel(doc,tmpb);
119
- }
120
- } else
121
- bin_num=doc->cur_bin_num++;
122
- tmpb=MAllocIdent(tmpb2,doc->mem_task);
123
- tmpb->use_cnt=i;
124
- tmpb->data=MAllocIdent(tmpb2->data,doc->mem_task);
125
- tmpb->num=bin_num;
126
- doc_e->bin_data=tmpb;
127
- if (doc_e->de_flags&DOCEF_TAG && doc_e->tag && *doc_e->tag)
128
- tmpb->tag=StrNew(doc_e->tag,doc->mem_task);
129
- else
130
- tmpb->tag=NULL;
131
- QueIns(tmpb,doc->bin_head.last);
132
- } else
133
- bin_num=0;
134
- DocDel(doc2);
135
- } else
136
- bin_num=0;
137
- Free(st2);
138
- Free(st);
139
- doc_e->bin_num=bin_num;
140
- }
141
- return bin_num;
142
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:a135e6aa549c452d66f3c3a9c772d393312a58f9b3c31922f97c5f1595dc7639
3
+ size 3088
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/DolDoc/DocChar.HC CHANGED
@@ -1,652 +1,3 @@
1
- #help_index "DolDoc/Editor"
2
-
3
- public I64 EdCurU8(CDoc *doc)
4
- {//Return cur U8. See $LK,"EdRenumAsm",A="MN:EdRenumAsm"$ for an example.
5
- Bool unlock=DocLock(doc);
6
- CDocEntry *doc_ce=doc->cur_entry;
7
- I64 res=-1;
8
- if (doc_ce->type_u8==DOCT_TEXT &&
9
- doc_ce->min_col<=doc->cur_col<doc_ce->max_col)
10
- res=doc_ce->tag[doc->cur_col];
11
- else if (doc_ce->type_u8==DOCT_TAB)
12
- res='\t';
13
- else if (doc_ce->type_u8==DOCT_NEW_LINE ||
14
- doc_ce->type_u8==DOCT_SOFT_NEW_LINE)
15
- res='\n';
16
- if (unlock)
17
- DocUnlock(doc);
18
- return res;
19
- }
20
-
21
- public U0 EdCursorLeft(CDoc *doc,I64 sc=I64_MIN)
22
- {//Move cursor left. Might need a call to $LK,"DocRecalc",A="MN:DocRecalc"$().
23
- //See $LK,"EdRenumAsm",A="MN:EdRenumAsm"$ for an example.
24
- U8 *dst;
25
- Bool unlock=DocLock(doc);
26
- CDocEntry *doc_ce=doc->cur_entry,*original_ce=doc_ce,*doc_ne;
27
- I64 cc=doc->cur_col,y=doc_ce->y;
28
- if (sc!=I64_MIN) sc=sc.u32[0];
29
- if (sc>=0 && sc&SCF_CTRL) {
30
- while (doc_ce->last!=doc && (doc_ce->last->y==y ||
31
- doc_ce->de_flags & (DOCEF_SKIP|DOCEF_FILTER_SKIP)))
32
- doc_ce=doc_ce->last; //TODO: sel? recurse?
33
- cc=doc_ce->min_col;
34
- } else {
35
- if (cc>doc_ce->min_col) {
36
- if (IsEditableText(doc_ce) && cc<doc_ce->max_col) {
37
- dst=doc_ce->tag+cc;
38
- doc_ne=DocEntryNewTag(doc,doc_ce,dst);
39
- *dst=0;
40
- doc_ce->max_col=cc;
41
- QueIns(doc_ne,doc_ce);
42
- }
43
- cc--;
44
- if (IsEditableText(doc_ce) && cc>doc_ce->min_col) {
45
- dst=doc_ce->tag+cc;
46
- doc_ne=DocEntryNewTag(doc,doc_ce,dst);
47
- *dst=0;
48
- doc_ce->max_col=cc;
49
- QueIns(doc_ne,doc_ce);
50
- doc_ce=doc_ne;
51
- cc=doc_ce->min_col;
52
- }
53
- if (sc>=0)
54
- BEqu(&doc_ce->type,DOCEt_SEL,sc&SCF_SHIFT);
55
- } else {
56
- cc=doc_ce->min_col;
57
- while (doc_ce->last!=doc &&
58
- (doc_ce->last->type_u8==DOCT_SOFT_NEW_LINE ||
59
- doc_ce->last->type_u8==DOCT_INDENT ||
60
- doc_ce->last->de_flags&(DOCEF_SKIP|DOCEF_FILTER_SKIP))) {
61
- doc_ce=doc_ce->last;
62
- if (sc>=0)
63
- BEqu(&doc_ce->type,DOCEt_SEL,sc&SCF_SHIFT);
64
- }
65
- if (doc_ce->last!=doc) {
66
- doc_ce=doc_ce->last;
67
- if (doc_ce->max_col>doc_ce->min_col) {
68
- cc=doc_ce->max_col-1;
69
- if (IsEditableText(doc_ce) && cc>doc_ce->min_col) {
70
- dst=doc_ce->tag+cc;
71
- doc_ne=DocEntryNewTag(doc,doc_ce,dst);
72
- *dst=0;
73
- doc_ce->max_col=cc;
74
- QueIns(doc_ne,doc_ce);
75
- doc_ce=doc_ne;
76
- cc=doc_ce->min_col;
77
- }
78
- } else
79
- cc=doc_ce->max_col;
80
- if (sc>=0)
81
- BEqu(&doc_ce->type,DOCEt_SEL,sc&SCF_SHIFT);
82
- }
83
- }
84
- }
85
- doc->cur_col=cc;
86
- doc->cur_entry=doc_ce;
87
- if (doc_ce!=original_ce)
88
- DocFormBwd(doc);
89
- if (unlock)
90
- DocUnlock(doc);
91
- }
92
-
93
- public U0 EdCursorRight(CDoc *doc,I64 sc=I64_MIN)
94
- {//Move cursor right. Might need a call to $LK,"DocRecalc",A="MN:DocRecalc"$().
95
- //See $LK,"EdRenumAsm",A="MN:EdRenumAsm"$ for an example.
96
- Bool unlock=DocLock(doc);
97
- U8 *dst;
98
- CDocEntry *doc_ce=doc->cur_entry,*original_ce=doc_ce,*doc_ne;
99
- I64 cc=doc->cur_col,y=doc_ce->y,old_de_flags,old_color;
100
- if (sc!=I64_MIN) sc=sc.u32[0];
101
- if (sc>=0 && sc&SCF_CTRL) {
102
- while (doc_ce!=doc && doc_ce->next->y==y &&
103
- doc_ce->next->type_u8!=DOCT_SOFT_NEW_LINE && doc_ce->next!=doc &&
104
- (doc_ce->next->type_u8!=DOCT_NEW_LINE || !(doc->flags & DOCF_FORM)) ||
105
- doc_ce->de_flags & (DOCEF_SKIP|DOCEF_FILTER_SKIP))
106
- doc_ce=doc_ce->next;
107
- if (doc_ce->max_col>doc_ce->min_col)
108
- cc=doc_ce->max_col-1;
109
- else
110
- cc=doc_ce->min_col;
111
- } else {
112
- if (cc<doc_ce->max_col) {
113
- if (IsEditableText(doc_ce) && cc>doc_ce->min_col) {
114
- dst=doc_ce->tag+cc;
115
- doc_ne=DocEntryNewTag(doc,doc_ce,dst);
116
- *dst=0;
117
- doc_ce->max_col=cc;
118
- QueIns(doc_ne,doc_ce);
119
- doc_ce=doc_ne;
120
- cc=doc_ce->min_col;
121
- }
122
- cc++;
123
- old_de_flags=doc_ce->de_flags;
124
- old_color=doc_ce->type;
125
- if (sc>=0)
126
- BEqu(&doc_ce->type,DOCEt_SEL,sc&SCF_SHIFT);
127
- if (IsEditableText(doc_ce) && cc<doc_ce->max_col) {
128
- dst=doc_ce->tag+cc;
129
- doc_ne=DocEntryNewTag(doc,doc_ce,dst);
130
- *dst=0;
131
- doc_ne->type=DOCT_TEXT | old_color & -0x100;
132
- doc_ne->de_flags=old_de_flags|doldoc.dft_de_flags[DOCT_TEXT];
133
- doc_ce->max_col=cc;
134
- QueIns(doc_ne,doc_ce);
135
- doc_ce=doc_ne;
136
- cc=doc_ce->min_col;
137
- } else if (cc>=doc_ce->max_col) {
138
- doc_ce=doc_ce->next;
139
- cc=doc_ce->min_col;
140
- }
141
- } else {
142
- if (doc_ce!=doc) {
143
- if (cc<=doc_ce->min_col && sc>=0)
144
- BEqu(&doc_ce->type,DOCEt_SEL,sc&SCF_SHIFT);
145
- doc_ce=doc_ce->next;
146
- while (doc_ce!=doc && doc_ce->de_flags&(DOCEF_SKIP|DOCEF_FILTER_SKIP)) {
147
- if (sc>=0)
148
- BEqu(&doc_ce->type,DOCEt_SEL,sc&SCF_SHIFT);
149
- doc_ce=doc_ce->next;
150
- }
151
- cc=doc_ce->min_col;
152
- if (doc_ce->type_u8==DOCT_SOFT_NEW_LINE) {
153
- if (sc>=0)
154
- BEqu(&doc_ce->type,DOCEt_SEL,sc&SCF_SHIFT);
155
- doc_ce=doc_ce->next;
156
- cc=doc_ce->min_col;
157
- }
158
- }
159
- }
160
- }
161
- doc->cur_col=cc;
162
- doc->cur_entry=doc_ce;
163
- if (doc_ce!=original_ce)
164
- DocFormFwd(doc);
165
- if (unlock)
166
- DocUnlock(doc);
167
- }
168
-
169
- public U0 EdLineUp(CDoc *doc,I64 sc=I64_MIN)
170
- {//Move cursor up. Might need a call to $LK,"DocRecalc",A="MN:DocRecalc"$().
171
- //See $LK,"EdRenumAsm",A="MN:EdRenumAsm"$ for an example.
172
- Bool unlock=DocLock(doc);
173
- U8 *dst;
174
- I64 y,x;
175
- CDocEntry *doc_ce=doc->cur_entry,*doc_ne;
176
-
177
- if (sc!=I64_MIN) sc=sc.u32[0];
178
- if (doc_ce->type_u8==DOCT_HEX_ED) {
179
- doc->cur_col=doc->cur_col-doc_ce->hex_ed_width*3;
180
- if (doc->cur_col>=0) {
181
- if (unlock)
182
- DocUnlock(doc);
183
- return;
184
- } else
185
- doc->cur_col=0;
186
- }
187
- x=doc->x; y=doc->y;
188
- if (IsEditableText(doc_ce)) {
189
- if (doc_ce->min_col<doc->cur_col<doc_ce->max_col-1) {
190
- dst=doc_ce->tag+doc->cur_col;
191
- doc_ne=DocEntryNewTag(doc,doc_ce,dst);
192
- *dst=0;
193
- doc_ne->x=doc_ce->x+doc->cur_col;
194
- doc_ce->max_col=doc->cur_col;
195
- QueIns(doc_ne,doc_ce);
196
- } else if (doc->cur_col==doc_ce->min_col && doc_ce->last!=doc)
197
- doc_ce=doc_ce->last;
198
- } else if (doc_ce->last!=doc)
199
- doc_ce=doc_ce->last;
200
- if (sc>=0)
201
- BEqu(&doc_ce->type,DOCEt_SEL,sc&SCF_SHIFT);
202
- doc->cur_entry=doc_ce;
203
- DocFormBwd(doc);
204
- doc_ce=doc->cur_entry;
205
- while (doc_ce->last!=doc && (doc_ce->y>=y ||
206
- doc_ce->de_flags & (DOCEF_SKIP|DOCEF_FILTER_SKIP))) {
207
- doc_ce=doc_ce->last;
208
- if (sc>=0)
209
- BEqu(&doc_ce->type,DOCEt_SEL,sc&SCF_SHIFT);
210
- }
211
- y=doc_ce->y;
212
- doc->y=y;
213
- while (doc_ce!=doc && (doc_ce->y>=y && doc_ce->x>=x ||
214
- doc_ce->de_flags & (DOCEF_SKIP|DOCEF_FILTER_SKIP))) {
215
- if (sc>=0)
216
- BEqu(&doc_ce->type,DOCEt_SEL,sc&SCF_SHIFT);
217
- doc_ce=doc_ce->last;
218
- }
219
-
220
- if (doc_ce==doc || doc_ce->y<y)
221
- doc_ce=doc_ce->next;
222
- else {
223
- if (!IsEditableText(doc_ce)) {
224
- if (sc>=0)
225
- BEqu(&doc_ce->type,DOCEt_SEL,sc&SCF_SHIFT);
226
- } else {
227
- if (doc_ce->next->x==x) {
228
- doc_ce=doc_ce->next;
229
- if (doc->flags & DOCF_FORM)
230
- while (doc_ce->next->x==x &&
231
- (!Bt(doldoc.type_flags_form,doc_ce->type_u8) &&
232
- !(doc_ce->de_flags&DOCEF_LINK)||
233
- doc_ce->de_flags&DOCEF_SKIP_IN_FORM))
234
- doc_ce=doc_ce->next;
235
- }
236
- }
237
- }
238
- if (doc_ce->de_flags&DOCEF_TAG) {
239
- doc->cur_col=x-doc_ce->x;
240
- if (IsEditableText(doc_ce)) {
241
- if (doc->cur_col>doc_ce->max_col)
242
- doc->cur_col=doc_ce->max_col;
243
- } else if (doc->cur_col>=doc_ce->max_col)
244
- doc->cur_col=doc_ce->max_col-1;
245
- if (doc->cur_col<doc_ce->min_col)
246
- doc->cur_col=doc_ce->min_col;
247
- } else {
248
- if (doc_ce->type_u8==DOCT_HEX_ED) {
249
- doc->cur_col=RoundI64((doc_ce->len-1)*3,doc_ce->hex_ed_width*3);
250
- if (doc->cur_col<0)
251
- doc->cur_col=0;
252
- } else
253
- doc->cur_col=doc_ce->min_col;
254
- }
255
- if (IsEditableText(doc_ce) && doc_ce->x<x) {
256
- if (doc->cur_col<doc_ce->max_col-1) {
257
- dst=doc_ce->tag+doc->cur_col;
258
- doc_ne=DocEntryNewTag(doc,doc_ce,dst);
259
- *dst=0;
260
- if (sc>=0) {
261
- if (sc&SCF_SHIFT)
262
- doc_ne->type=doc_ce->type | DOCET_SEL;
263
- else
264
- doc_ne->type=doc_ce->type & ~DOCET_SEL;
265
- }
266
- doc_ne->x=doc_ce->x+doc->cur_col;
267
- doc_ce->max_col=doc->cur_col;
268
- QueIns(doc_ne,doc_ce);
269
- doc_ce=doc_ne;
270
- doc->cur_col=doc_ce->min_col;
271
- }
272
- }
273
- doc->cur_entry=doc_ce;
274
- DocFormFwd(doc);
275
- doc->x=doc->cur_entry->x+doc->cur_col;
276
- if (unlock)
277
- DocUnlock(doc);
278
- }
279
-
280
- public U0 EdLineDown(CDoc *doc,I64 sc=I64_MIN)
281
- {//Move cursor down. Might need a call to $LK,"DocRecalc",A="MN:DocRecalc"$().
282
- //See $LK,"EdRenumAsm",A="MN:EdRenumAsm"$ for an example.
283
- Bool unlock=DocLock(doc);
284
- U8 *dst;
285
- I64 y,x,old_de_flags=0,old_color;
286
- CDocEntry *doc_ce=doc->cur_entry,*doc_ne,*doc_ce2;
287
- if (sc!=I64_MIN) sc=sc.u32[0];
288
- if (doc_ce->type_u8==DOCT_HEX_ED) {
289
- doc->cur_col=doc->cur_col+doc_ce->hex_ed_width*3;
290
- if (doc->cur_col>=doc_ce->len*3) {
291
- doc->cur_entry=doc_ce=doc_ce->next;
292
- doc->cur_col=doc_ce->min_col;
293
- doc->x=doc_ce->x+doc->cur_col;
294
- doc->y=doc_ce->y;
295
- }
296
- if (unlock)
297
- DocUnlock(doc);
298
- return;
299
- }
300
- x=doc->x; y=doc->y;
301
- if (IsEditableText(doc_ce)) {
302
- if (doc->cur_col>doc_ce->min_col && doc->cur_col<doc_ce->max_col-1) {
303
- dst=doc_ce->tag+doc->cur_col;
304
- doc_ne=DocEntryNewTag(doc,doc_ce,dst);
305
- *dst=0;
306
- if (sc>=0) {
307
- if (sc&SCF_SHIFT)
308
- doc_ne->type=doc_ce->type | DOCET_SEL;
309
- else
310
- doc_ne->type=doc_ce->type & ~DOCET_SEL;
311
- }
312
- doc_ne->x=doc_ce->x+doc->cur_col;
313
- doc_ce->max_col=doc->cur_col;
314
- QueIns(doc_ne,doc_ce);
315
- doc_ce=doc_ne;
316
- doc->cur_col=doc_ce->min_col;
317
- }
318
- }
319
- doc_ce2=doc_ce;
320
- while (doc_ce!=doc && (doc_ce->y<=y ||
321
- doc_ce->de_flags & (DOCEF_SKIP|DOCEF_FILTER_SKIP)))
322
- doc_ce=doc_ce->next;
323
- y=doc_ce->y;
324
- doc->y=y;
325
- while (doc_ce!=doc && (doc_ce->y<=y && doc_ce->x<=x ||
326
- doc_ce->de_flags & (DOCEF_SKIP|DOCEF_FILTER_SKIP))) {
327
- old_de_flags=doc_ce->de_flags;
328
- old_color=doc_ce->type;
329
- doc_ce=doc_ce->next;
330
- }
331
- if (doc_ce->last!=doc && (doc_ce->x>x && doc_ce->last->y>=y || doc_ce->y>y)) {
332
- doc_ce=doc_ce->last;
333
- doc->cur_entry=doc_ce;
334
- if (!((doc_ce->type_u8==DOCT_NEW_LINE ||
335
- doc_ce->type_u8==DOCT_SOFT_NEW_LINE ||
336
- doc_ce->type_u8==DOCT_INDENT) &&
337
- (doc_ce->last->type_u8==DOCT_NEW_LINE ||
338
- doc_ce->last->type_u8==DOCT_SOFT_NEW_LINE ||
339
- doc_ce->last->type_u8==DOCT_INDENT)))
340
- DocFormBwd(doc);
341
- doc_ce=doc->cur_entry;
342
- }
343
- while (doc_ce2!=doc && (doc_ce2!=doc_ce || IsEditableText(doc_ce))) {
344
- if ((doc_ce2->y<y || doc_ce2->x<x ||
345
- doc_ce2->de_flags & (DOCEF_SKIP|DOCEF_FILTER_SKIP) ||
346
- doc_ce2->x==x && !doc_ce2->max_col &&
347
- Bt(doldoc.type_flags_nontag_invis,doc_ce2->type_u8)) && sc>=0)
348
- BEqu(&doc_ce2->type,DOCEt_SEL,sc&SCF_SHIFT);
349
- if (doc_ce2==doc_ce) break;
350
- doc_ce2=doc_ce2->next;
351
- }
352
- if (doc_ce->de_flags&DOCEF_TAG) {
353
- doc->cur_col=x-doc_ce->x;
354
- if (IsEditableText(doc_ce)) {
355
- if (doc->cur_col>doc_ce->max_col)
356
- doc->cur_col=doc_ce->max_col;
357
- } else if (doc->cur_col>=doc_ce->max_col)
358
- doc->cur_col=doc_ce->max_col-1;
359
- if (doc->cur_col<doc_ce->min_col)
360
- doc->cur_col=doc_ce->min_col;
361
- } else
362
- doc->cur_col=doc_ce->min_col;
363
- if (IsEditableText(doc_ce)&&doc_ce->min_col<doc->cur_col<doc_ce->max_col-1) {
364
- dst=doc_ce->tag+doc->cur_col;
365
- doc_ne=DocEntryNewTag(doc,doc_ce,dst);
366
- *dst=0;
367
- doc_ne->type=DOCT_TEXT | old_color & -0x100;
368
- doc_ne->de_flags=old_de_flags|doldoc.dft_de_flags[DOCT_TEXT];
369
- doc_ce->max_col=doc->cur_col;
370
- doc_ne->x=doc_ce->x+doc->cur_col;
371
- QueIns(doc_ne,doc_ce);
372
- doc_ce=doc_ne;
373
- doc->cur_col=doc_ce->min_col;
374
- }
375
- doc->cur_entry=doc_ce;
376
- DocFormFwd(doc);
377
- if (!(doc->flags & DOCF_FORM))
378
- while (doc_ce!=doc && doc_ce!=doc->cur_entry) {
379
- if (sc>=0)
380
- BEqu(&doc_ce->type,DOCEt_SEL,sc&SCF_SHIFT);
381
- doc_ce=doc_ce->next;
382
- }
383
- doc->x=doc->cur_entry->x+doc->cur_col;
384
- if (unlock)
385
- DocUnlock(doc);
386
- }
387
-
388
- U0 EdCharDel(CDoc *doc)
389
- {
390
- Bool unlock=DocLock(doc);
391
- CDocEntry *doc_ce=doc->cur_entry;
392
-
393
- if (doc_ce==doc) {
394
- if (unlock)
395
- DocUnlock(doc);
396
- return;
397
- }
398
- if (doc_ce->max_col!=0 &&
399
- (IsEditableText(doc_ce)||doc_ce->type_u8==DOCT_DATA)) {
400
- if (doc_ce->type_u8==DOCT_DATA && doc_ce->de_flags & DOCEF_HAS_TERMINATOR &&
401
- doc->cur_col==doc_ce->max_col-1) {
402
- if (unlock)
403
- DocUnlock(doc);
404
- return;
405
- }
406
- if (doc->cur_col<doc_ce->max_col)
407
- StrCpy(doc_ce->tag+doc->cur_col,doc_ce->tag+doc->cur_col+1);
408
- if (doc->cur_col>=doc_ce->max_col-1) {
409
- doc->cur_entry=doc_ce->next;
410
- doc->cur_col=doc->cur_entry->min_col;
411
- }
412
- DocRemSoftNewLines(doc,doc->cur_entry);
413
- if (unlock)
414
- DocUnlock(doc);
415
- return;
416
- }
417
- doc->cur_entry=doc_ce->next;
418
- doc->cur_col=doc->cur_entry->min_col;
419
- if (!(doc_ce->de_flags&DOCEF_FILTER_SKIP))
420
- DocEntryDel(doc,doc_ce);
421
- DocRemSoftNewLines(doc,doc->cur_entry);
422
- if (unlock)
423
- DocUnlock(doc);
424
- }
425
-
426
- U0 ChkDollarBufSize(CDoc *doc)
427
- {
428
- U8 *b;
429
- if (doc->dollar_buf_ptr>=doc->dollar_buf_size-2) {
430
- doc->dollar_buf_size<<=1;
431
- b=MAlloc(doc->dollar_buf_size,doc->mem_task);
432
- MemCpy(b,doc->dollar_buf,doc->dollar_buf_ptr);
433
- Free(doc->dollar_buf);
434
- doc->dollar_buf=b;
435
- }
436
- }
437
-
438
- U0 EdCharIns(I64 ch,I64 sc,CDoc *doc)
439
- {
440
- Bool unlock=DocLock(doc);
441
- U8 *st,*src,*dst;
442
- CDocEntry *doc_ce=doc->cur_entry,*doc_ne;
443
- I64 i,j,m,y=doc_ce->y;
444
-
445
- if (doc->flags & DOCF_IN_DOLLAR) {
446
- if (!Bt(char_bmp_printable,ch))
447
- goto ic_done;
448
- ChkDollarBufSize(doc);
449
- doc->dollar_buf[doc->dollar_buf_ptr++]=ch;
450
- if (ch=='$$') {
451
- if (doc->dollar_buf_ptr==2) {
452
- doc->flags&=~DOCF_IN_DOLLAR;
453
- doc->dollar_buf_ptr=0;
454
- goto ic_cont;
455
- } else {
456
- doc->dollar_buf[doc->dollar_buf_ptr]=0;
457
- doc->flags&=~DOCF_IN_DOLLAR;
458
- DocPrint(doc,"%s",doc->dollar_buf);
459
- doc->dollar_buf_ptr=0;
460
- goto ic_done;
461
- }
462
- } else
463
- goto ic_done;
464
- }
465
- if (ch=='$$' && !(doc->flags & (DOCF_PLAIN_TEXT|DOCF_PLAIN_TEXT_TABS))) {
466
- doc->flags|=DOCF_IN_DOLLAR;
467
- doc->dollar_buf_ptr=0;
468
- doc->dollar_buf[doc->dollar_buf_ptr++]=ch;
469
- goto ic_done;
470
- }
471
- if (ch=='\r') goto ic_done;
472
-
473
- ic_cont:
474
- if ((ch==CH_SPACE || ch=='\n') &&
475
- !(sc & (SCF_CTRL|SCF_SHIFT)) &&
476
- doc_ce->de_flags &
477
- (DOCEF_LINK|DOCEF_TREE|DOCEF_LST|DOCEF_CHECK_COLLAPSABLE|
478
- DOCEF_LEFT_MACRO|DOCEF_LEFT_EXP|DOCEF_LEFT_CB|DOCEF_LEFT_IN_STR |
479
- DOCEF_RIGHT_MACRO|DOCEF_RIGHT_EXP|DOCEF_RIGHT_CB|DOCEF_RIGHT_IN_STR)) {
480
- doc->cmd_U8=ch;
481
- DocEntryRun(doc,doc_ce,FALSE);
482
- DocLock(doc);
483
- goto ic_done;
484
- }
485
- if (doc_ce->type_u8==DOCT_HEX_ED) {
486
- if (doc_ce->de_flags&DOCEF_DEREF_DATA &&
487
- !(doc_ce->de_flags&DOCEF_REMALLOC_DATA))
488
- st=doc_ce->data;
489
- else
490
- st=&doc_ce->data;
491
- i=doc->cur_col;
492
- j=i%(doc_ce->hex_ed_width*3);
493
- m=i/(doc_ce->hex_ed_width*3)*doc_ce->hex_ed_width;
494
- if (j>=doc_ce->hex_ed_width<<1)
495
- st[j-doc_ce->hex_ed_width<<1+m]=ch;
496
- else {
497
- ch=ToUpper(ch)-'0';
498
- if (ch>9) {
499
- ch+='0'-'A'+10;
500
- if (!(10<=ch<=15))
501
- goto ic_done;
502
- }
503
- m=j>>1+m;
504
- if (j & 1)
505
- st[m]=st[m] & 0xF0| ch;
506
- else
507
- st[m]=st[m] & 0xF | ch<<4;
508
- }
509
- doc->cur_col++;
510
- goto ic_done;
511
- }
512
- if (doc->flags & DOCF_OVERSTRIKE) {
513
- if (Bt(char_bmp_displayable,ch)) {
514
- ic_overstrike:
515
- if (IsEditableText(doc_ce)) {
516
- if (doc->cur_col<doc_ce->max_col) {
517
- if (doc_ce->tag[doc->cur_col]) {
518
- doc_ce->tag[doc->cur_col++]=ch;
519
- goto ic_done;
520
- }
521
- } else {
522
- doc_ce=doc_ce->next;
523
- doc->cur_entry=doc_ce;
524
- doc->cur_col=doc_ce->min_col;
525
- goto ic_overstrike;
526
- }
527
- } else if (doc_ce->type_u8==DOCT_DATA) {
528
- if (doc_ce->de_flags & DOCEF_HAS_TERMINATOR) {
529
- if (doc_ce->tag[doc->cur_col] &&
530
- doc->cur_col<doc_ce->min_col+doc_ce->len) {
531
- doc_ce->tag[doc->cur_col++]=ch;
532
- if ( ! doc_ce->tag[doc->cur_col]) {
533
- doc_ce->tag[doc->cur_col]='_';
534
- doc_ce->tag[doc->cur_col+1]=0;
535
- }
536
- } else if (doc_ce->de_flags & DOCEF_REMALLOC_DATA)
537
- goto ic_not_overstrike;
538
- } else if (doc_ce->tag[doc->cur_col])
539
- doc_ce->tag[doc->cur_col++]=ch;
540
- goto ic_done;
541
- }
542
- doc_ne=DocEntryNewTag(doc,doc_ce,&ch);
543
- doc_ne->type=DOCT_TEXT | doc->settings_head.dft_text_attr<<8;
544
- doc_ne->de_flags=doldoc.dft_de_flags[DOCT_TEXT];
545
- QueIns(doc_ne,doc_ce->last);
546
- } else if (ch=='\n') {
547
- while (doc->cur_entry->next!=doc && doc->cur_entry->y==y)
548
- doc->cur_entry=doc->cur_entry->next;
549
- doc->cur_col=doc->cur_entry->min_col;
550
- } else if (ch=='\t') {
551
- if (doc->flags&DOCF_FORM)
552
- goto ic_form_tab;
553
- }
554
- goto ic_done;
555
- }
556
- ic_not_overstrike:
557
- if (ch=='\n') {
558
- if (sc&SCF_CTRL && !(sc&SCF_SHIFT)) {
559
- doc_ne=DocEntryNewBase(doc,
560
- DOCT_PAGE_BREAK|doc->settings_head.dft_text_attr<<8);
561
- } else {
562
- doc_ne=DocEntryNewBase(doc,
563
- DOCT_NEW_LINE|doc->settings_head.dft_text_attr<<8);
564
- }
565
- DocInsEntry(doc,doc_ne);
566
- } else if (ch=='\t') {
567
- if (doc->flags&DOCF_FORM &&
568
- (Bt(doldoc.type_flags_form,doc->cur_entry->type_u8) ||
569
- doc->cur_entry->de_flags&DOCEF_LINK) &&
570
- !(doc->cur_entry->de_flags&DOCEF_SKIP_IN_FORM)) {
571
- ic_form_tab:
572
- doc->cur_entry=doc->cur_entry->next;
573
- doc->cur_col=doc->cur_entry->min_col;
574
- DocFormFwd(doc);
575
- goto ic_done;
576
- } else {
577
- doc_ne=DocEntryNewBase(doc,DOCT_TAB|doc->settings_head.dft_text_attr<<8);
578
- DocInsEntry(doc,doc_ne);
579
- }
580
- } else {
581
- if (Bt(char_bmp_displayable,ch)) {
582
- if (doc_ce->type_u8==DOCT_DATA) {
583
- while (TRUE) {
584
- i=doc_ce->len+doc_ce->min_col;
585
- if (doc_ce->de_flags & DOCEF_HAS_TERMINATOR)
586
- i++;
587
- if (doc_ce->max_col<i) {
588
- st=doc_ce->tag;
589
- doc_ce->max_col++;
590
- for (i=doc_ce->max_col;i>doc->cur_col;i--)
591
- st[i]=st[i-1];
592
- st[doc->cur_col++]=ch;
593
- break;
594
- } else if (doc_ce->de_flags & DOCEF_REMALLOC_DATA) {
595
- st=MAlloc(doc_ce->max_col+8,doc->mem_task);
596
- MemCpy(st,doc_ce->tag,doc_ce->max_col+1);
597
- Free(doc_ce->tag);
598
- doc_ce->tag=st;
599
- doc_ce->len=MSize(st)-doc_ce->min_col-2; //See $LK,"DataTagWidth",A="FA:::/Adam/DolDoc/DocPlain.HC,DataTagWidth"$
600
- Free(doc_ce->data);
601
- doc_ce->data=MAlloc(doc_ce->len+2,doc->mem_task);
602
- } else
603
- break;
604
- }
605
- } else if (IsEditableText(doc_ce)) {
606
- dst=st=MAlloc(doc_ce->max_col+2,doc->mem_task);
607
- src=doc_ce->tag;
608
- i=doc->cur_col;
609
- while (i-->0)
610
- *dst++=*src++;
611
- *dst++=ch;
612
- while (*dst++=*src++);
613
- Free(doc_ce->tag);
614
- doc_ce->tag=st;
615
- doc_ce->max_col++;
616
- doc->cur_col++;
617
- } else {
618
- doc_ne=DocEntryNewTag(doc,doc_ce,&ch);
619
- doc_ne->type=DOCT_TEXT | doc->settings_head.dft_text_attr<<8;
620
- doc_ne->de_flags=doldoc.dft_de_flags[DOCT_TEXT];
621
- doc_ne->x=doc_ce->x+1;
622
- QueIns(doc_ne,doc_ce->last);
623
- }
624
- }
625
- }
626
- ic_done:
627
- DocRemSoftNewLines(doc,doc->cur_entry);
628
- if (doc->cur_entry->de_flags & DOCEF_UPDATE_DATA &&
629
- (doc->cur_entry->type_u8==DOCT_DATA ||
630
- doc->cur_entry->type_u8==DOCT_CHECK_BOX))
631
- DocDataScan(doc,doc->cur_entry);
632
- if (unlock)
633
- DocUnlock(doc);
634
- }
635
-
636
- U0 EdLineDel(CDoc *doc)
637
- {
638
- CDocEntry *doc_ce=doc->cur_entry,*doc_ce2;
639
- I64 y;
640
- y=doc->y;
641
- while (doc_ce!=doc && doc_ce->y==y)
642
- doc_ce=doc_ce->next;
643
- doc->cur_entry=doc_ce;
644
- doc->cur_col=doc_ce->min_col;
645
- doc_ce=doc_ce->last;
646
- while (doc_ce!=doc && doc_ce->y==y) {
647
- doc_ce2=doc_ce->last;
648
- if (!(doc_ce->de_flags&DOCEF_FILTER_SKIP))
649
- DocEntryDel(doc,doc_ce);
650
- doc_ce=doc_ce2;
651
- }
652
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:5d72c1c0414514015cb565d4992481ab47c4ef8064176ee8f08246fe96098cb6
3
+ size 18775
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/DolDoc/DocClipBoard.HC CHANGED
@@ -1,125 +1,3 @@
1
- #help_index "DolDoc/Clip"
2
-
3
- sys_clip_doc=DocNew;
4
-
5
- public U0 ClipDel()
6
- {//Delete everything on clip.
7
- DocRst(sys_clip_doc,TRUE);
8
- }
9
-
10
- public U0 ClipCopy(CDoc *doc)
11
- {//Copy $LK,"DOCET_SEL",A="MN:DOCET_SEL"$ flagged entries to clip.
12
- CDoc *doc2=sys_clip_doc;
13
- Bool unlock_doc=DocLock(doc),
14
- unlock_doc2=DocLock(doc2);
15
- CDocEntry *doc_e=doc->head.next,*doc_ne;
16
- ClipDel;
17
- while (doc_e!=doc) {
18
- if (doc_e->type & DOCET_SEL) {
19
- doc_e->type&=~DOCET_SEL;
20
- if (!Bt(doldoc.type_flags_data,doc_e->type_u8)) {
21
- doc_ne=DocEntryCopy(doc2,doc_e);
22
- QueIns(doc_ne,doc2->head.last);
23
- }
24
- }
25
- doc_e=doc_e->next;
26
- }
27
- if (unlock_doc2)
28
- DocUnlock(doc2);
29
- if (unlock_doc)
30
- DocUnlock(doc);
31
- }
32
-
33
- public U0 ClipCut(CDoc *doc)
34
- {//Remove sel entries and place on clip.
35
- CDoc *doc2=sys_clip_doc;
36
- Bool unlock_doc=DocLock(doc),
37
- unlock_doc2=DocLock(doc2);
38
- CDocEntry *doc_e=doc->head.next,*doc_e1,*doc_ne,*doc_e2=NULL;
39
- ClipDel;
40
- while (doc_e!=doc) {
41
- doc_e1=doc_e->next;
42
- if (doc_e->type & DOCET_SEL) {
43
- doc_e->type&=~DOCET_SEL;
44
- if (!Bt(doldoc.type_flags_data,doc_e->type_u8)) {
45
- doc_ne=DocEntryCopy(doc2,doc_e);
46
- QueIns(doc_ne,doc2->head.last);
47
- }
48
- if (doc_e==doc->cur_entry || doc_e==doc_e2)
49
- doc_e2=doc_e->next;
50
- DocEntryDel(doc,doc_e);
51
- }
52
- doc_e=doc_e1;
53
- }
54
- if (doc_e2) {
55
- doc->cur_entry=doc_e2;
56
- doc->cur_col=doc_e2->min_col;
57
- }
58
- DocRemSoftNewLines(doc,NULL);
59
- if (unlock_doc2)
60
- DocUnlock(doc2);
61
- if (unlock_doc)
62
- DocUnlock(doc);
63
- }
64
-
65
- public U0 ClipPaste(CDoc *doc)
66
- {//Insert copy of clip at insert pt, cur_entry.
67
- CDoc *doc2=sys_clip_doc;
68
- Bool unlock_doc=DocLock(doc),
69
- unlock_doc2=DocLock(doc2);
70
- CDocEntry *doc_ce=doc->cur_entry,*doc_e;
71
- if (doc_ce->type_u8==DOCT_DATA) {
72
- doc_e=doc2->head.next;
73
- while (doc_e!=doc2) {
74
- if (doc_e->de_flags&DOCEF_TAG)
75
- DocPrintPartial(doc,"%s",doc_e->tag);
76
- doc_e=doc_e->next;
77
- }
78
- } else
79
- DocInsDoc(doc,doc2);
80
- if (unlock_doc2)
81
- DocUnlock(doc2);
82
- if (unlock_doc)
83
- DocUnlock(doc);
84
- }
85
-
86
- public U0 DocCut(CDoc *doc,CDocEntry *start,CDocEntry *end)
87
- {//Del start to end entry, including end points.
88
- Bool unlock_doc=DocLock(doc);
89
- CDocEntry *doc_e1;
90
- if (start!=doc && (start->last!=end || end==doc))
91
- do {
92
- doc_e1=start->next;
93
- if (start==doc->cur_entry) {
94
- doc->cur_entry=start->next;
95
- doc->cur_col=doc->cur_entry->min_col;
96
- }
97
- DocEntryDel(doc,start);
98
- if (start==end)
99
- break;
100
- start=doc_e1;
101
- } while (start!=doc);
102
- DocRemSoftNewLines(doc,NULL);
103
- if (unlock_doc)
104
- DocUnlock(doc);
105
- }
106
-
107
- public CDoc *DocCopy(CDoc *doc,CDocEntry *start,CDocEntry *end)
108
- {//Copies start to end entry, including end points.
109
- CDoc *doc2=DocNew;
110
- Bool unlock_doc=DocLock(doc);
111
- CDocEntry *doc_ne;
112
- if (start!=doc && (start->last!=end || end==doc))
113
- do {
114
- if (!Bt(doldoc.type_flags_data,start->type_u8)) {
115
- doc_ne=DocEntryCopy(doc2,start);
116
- QueIns(doc_ne,doc2->head.last);
117
- }
118
- if (start==end)
119
- break;
120
- start=start->next;
121
- } while (start!=doc);
122
- if (unlock_doc)
123
- DocUnlock(doc);
124
- return doc2;
125
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:713efea1fa827b2b0bdcd022ddd8276f007c9f1f87aacb12b2a99278577e38a7
3
+ size 3079
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/DolDoc/DocCodeTools.HC CHANGED
@@ -1,658 +1,3 @@
1
- #help_index "DolDoc/Misc"
2
-
3
- U0 EdReplaceTroubleOne(CDoc *doc,U8 *st_original,U8 *st_safe,I64 num,
4
- Bool to_safe,Bool sel)
5
- {
6
- U8 buf[STR_LEN];
7
- StrPrint(buf,st_safe,num);
8
- if (to_safe)
9
- EdReplace(doc,st_original,buf,sel);
10
- else
11
- EdReplace(doc,buf,st_original,sel);
12
- }
13
-
14
- U0 EdReplaceTroubleAll(CDoc *doc,Bool to_safe,Bool sel)
15
- {
16
- I64 i=0;
17
- EdReplaceTroubleOne(doc,"#assert" ,"//<@%d@>" ,i++,to_safe,sel);
18
- EdReplaceTroubleOne(doc,"#define" ,"//<@%d@>" ,i++,to_safe,sel);
19
- EdReplaceTroubleOne(doc,"#include","//<@%d@>" ,i++,to_safe,sel);
20
- //#if will match #if,#ifdef,#ifndef,#ifaot and #ifjit
21
- EdReplaceTroubleOne(doc,"#if" ,"//<@%d@>" ,i++,to_safe,sel);
22
- EdReplaceTroubleOne(doc,"#endif" ,"//<@%d@>" ,i++,to_safe,sel);
23
- //Convert #exe to union because we want that indent pattern.
24
- EdReplaceTroubleOne(doc,"#exe" ,"union @%d@",i++,to_safe,sel);
25
- EdReplaceTroubleOne(doc,"'{'" ,"'<@%d@>'" ,i++,to_safe,sel);
26
- EdReplaceTroubleOne(doc,"'}'" ,"'<@%d@>'" ,i++,to_safe,sel);
27
- }
28
-
29
- #define C_INDENT_SPACES 2
30
- #define ASM_RENUM_SPACING 5
31
-
32
- #define EF_REINDENT 0
33
- #define EF_CMP_CHK 1
34
- #define EF_RENUM_ASM 2
35
- #define EF_CTRL_SLIDER 3
36
- #define EF_CH_SC 4
37
-
38
- I64 PopUpEdFmt()
39
- {
40
- I64 i;
41
- CDoc *doc=DocNew;
42
- DocPrint(doc,"$$LTBLUE$$$$MU,\"Compile Check\",LE=EF_CMP_CHK$$\n"
43
- "$$MU,\"Reindent HolyC Fun (Beware braces in strings.)\","
44
- "LE=EF_REINDENT$$\n"
45
- "$$MU,\"Renum Asm Local @@ Labels for Fun\",LE=EF_RENUM_ASM$$\n"
46
- "$$MU,\"Insert Template Code: Ctrl Slider\",LE=EF_CTRL_SLIDER$$\n"
47
- "$$MU,\"Insert ASCII/Scan Code Hex Codes for key pressed\","
48
- "LE=EF_CH_SC$$\n\n"
49
- "$$MU,\"CANCEL\",LE=DOCM_CANCEL$$\n\n"
50
- "$$GREEN$$<ALT-BACKSPACE>$$FG$$ to undo if not happy\n"
51
- "with the ress.\n");
52
- i=PopUpMenu(doc);
53
- DocDel(doc);
54
- return i;
55
- }
56
-
57
- class CRILex
58
- {
59
- CCmpCtrl *cc1,*cc2;
60
- CQueVectU8 *indent;
61
- I64 depth,exp_depth,one_shot;
62
- Bool was_new_line,is_not_cont;
63
- };
64
-
65
- I64 EdRILex(CRILex *rx)
66
- {
67
- rx->is_not_cont=FALSE;
68
- I64 i;
69
- CLexFile *tmpf;
70
- do {
71
- Lex(rx->cc1);
72
- Lex(rx->cc2);
73
- i=PrsKeyWord(rx->cc2);
74
- if (rx->cc1->token=='\n' && rx->cc2->token==';' || rx->cc2->token=='{' ||
75
- rx->cc2->token=='}' || rx->cc2->token==':' || rx->cc2->token==')' &&
76
- !rx->exp_depth || i==KW_ELSE || i==KW_CATCH || i==KW_DO)
77
- rx->is_not_cont=TRUE;
78
- if (rx->was_new_line && (rx->cc1->token!=':' || i==KW_CASE ||
79
- i==KW_DFT || i==KW_START || i==KW_END)) {
80
- tmpf=rx->cc2->lex_include_stk;
81
- while (tmpf->next)
82
- tmpf=tmpf->next;
83
- QueVectU8Put(rx->indent,tmpf->cur_entry->y,rx->depth+rx->one_shot);
84
- rx->one_shot=0;
85
- }
86
- if (rx->cc2->token=='\n')
87
- rx->was_new_line=TRUE;
88
- else
89
- rx->was_new_line=FALSE;
90
- } while (rx->cc1->token=='\n');
91
- return rx->cc1->token;
92
- }
93
-
94
- U0 EdRIExp(CRILex *rx)
95
- {
96
- if (rx->cc1->token=='(') {
97
- if (!rx->exp_depth++)
98
- rx->depth+=3;
99
- EdRILex(rx);
100
- while (rx->cc1->token && rx->cc1->token!=')')
101
- EdRIExp(rx);
102
- if (!--rx->exp_depth) {
103
- rx->depth-=3;
104
- if (rx->depth<0) rx->depth=0;
105
- }
106
- } else if (rx->cc1->token=='[') {
107
- if (!rx->exp_depth++)
108
- rx->depth+=3;
109
- EdRILex(rx);
110
- while (rx->cc1->token && rx->cc1->token!=']')
111
- EdRIExp(rx);
112
- if (!--rx->exp_depth) {
113
- rx->depth-=3;
114
- if (rx->depth<0) rx->depth=0;
115
- }
116
- }
117
- EdRILex(rx);
118
- }
119
-
120
- U0 EdRIStmt(CRILex *rx,Bool indent)
121
- {
122
- I64 i;
123
- Bool cont;
124
- if (rx->cc1->token=='{') {
125
- rx->depth++;
126
- EdRILex(rx);
127
- while (rx->cc1->token && rx->cc1->token!='}')
128
- EdRIStmt(rx,FALSE);
129
- if (--rx->depth<0) rx->depth=0;
130
- EdRILex(rx);
131
- } else {
132
- if (indent) rx->depth++;
133
- do {
134
- cont=FALSE;
135
- switch (PrsKeyWord(rx->cc1)) {
136
- case KW_IF:
137
- EdRILex(rx);
138
- EdRIExp(rx);
139
- EdRIStmt(rx,TRUE);
140
- if (PrsKeyWord(rx->cc1)==KW_ELSE) {
141
- EdRILex(rx);
142
- if (PrsKeyWord(rx->cc1)==KW_IF && rx->cc2->token!='\n')
143
- EdRIStmt(rx,FALSE);
144
- else
145
- EdRIStmt(rx,TRUE);
146
- }
147
- break;
148
- case KW_TRY:
149
- EdRILex(rx);
150
- EdRIStmt(rx,TRUE);
151
- if (PrsKeyWord(rx->cc1)==KW_CATCH) {
152
- EdRILex(rx);
153
- EdRIStmt(rx,TRUE);
154
- }
155
- break;
156
- case KW_LOCK:
157
- EdRILex(rx);
158
- EdRIStmt(rx,TRUE);
159
- break;
160
- case KW_FOR:
161
- case KW_WHILE:
162
- EdRILex(rx);
163
- EdRIExp(rx);
164
- EdRIStmt(rx,TRUE);
165
- break;
166
- case KW_ASM:
167
- case KW_CLASS:
168
- case KW_UNION:
169
- if (EdRILex(rx)==TK_IDENT)
170
- EdRILex(rx);
171
- EdRIStmt(rx,TRUE);
172
- break;
173
- case KW_DO:
174
- EdRILex(rx);
175
- EdRIStmt(rx,TRUE);
176
- if (PrsKeyWord(rx->cc1)==KW_WHILE) {
177
- EdRILex(rx);
178
- EdRIExp(rx);
179
- }
180
- if (rx->cc1->token==';')
181
- EdRILex(rx);
182
- break;
183
- case KW_SWITCH:
184
- EdRILex(rx);
185
- EdRIExp(rx);
186
- if (rx->cc1->token=='{') {
187
- rx->depth++;
188
- EdRILex(rx);
189
- i=0;
190
- while (rx->cc1->token && rx->cc1->token!='}') {
191
- switch (PrsKeyWord(rx->cc1)) {
192
- case KW_START:
193
- rx->depth+=i; i=0;
194
- while (EdRILex(rx) && rx->cc1->token!=':');
195
- EdRILex(rx);
196
- i++;
197
- break;
198
- case KW_END:
199
- rx->depth+=i; i=0;
200
- if (--rx->depth<0) rx->depth=0;
201
- while (EdRILex(rx) && rx->cc1->token!=':');
202
- EdRILex(rx);
203
- break;
204
- case KW_CASE:
205
- case KW_DFT:
206
- rx->depth+=i; i=0;
207
- while (EdRILex(rx) && rx->cc1->token!=':');
208
- EdRILex(rx);
209
- break;
210
- default:
211
- if (rx->cc1->token)
212
- EdRIStmt(rx,TRUE);
213
- }
214
- }
215
- if (--rx->depth<0) rx->depth=0;
216
- EdRILex(rx);
217
- }
218
- break;
219
- default:
220
- if (rx->cc1->token==TK_IDENT && rx->cc1->hash_entry &&
221
- rx->cc1->hash_entry->type&(HTT_OPCODE|HTT_ASM_KEYWORD)) {
222
- // rx->one_shot=4-rx->depth;
223
- do EdRILex(rx);
224
- while (rx->cc2->token && rx->cc2->token!='\n');
225
- rx->is_not_cont=TRUE;
226
- } else {
227
- while (rx->cc1->token && rx->cc1->token!=';' &&
228
- rx->cc1->token!=':') {
229
- if (rx->cc2->token=='\n' && !rx->is_not_cont)
230
- rx->one_shot=3;
231
- EdRILex(rx);
232
- }
233
- if (rx->cc1->token==':')
234
- cont=TRUE;
235
- EdRILex(rx);
236
- }
237
- }
238
- } while (cont && rx->cc1->token!='}');
239
- if (indent && --rx->depth<0)
240
- rx->depth=0;
241
- }
242
- }
243
-
244
- CQueVectU8 *EdRICode(CDoc *doc)
245
- {
246
- CQueVectU8 *res;
247
- CRILex *rx=CAlloc(sizeof(CRILex));
248
-
249
- rx->cc1=CmpCtrlNew(,CCF_KEEP_NEW_LINES|CCF_DONT_FREE_BUF,doc->filename.name);
250
- Free(rx->cc1->lex_include_stk->full_name);
251
- LexAttachDoc(rx->cc1,rx->cc1->lex_include_stk,doc,,
252
- doc->cur_entry,doc->cur_col);
253
-
254
- rx->cc2=CmpCtrlNew(,CCF_KEEP_NEW_LINES|CCF_DONT_FREE_BUF,doc->filename.name);
255
- Free(rx->cc2->lex_include_stk->full_name);
256
- LexAttachDoc(rx->cc2,rx->cc2->lex_include_stk,doc,,
257
- doc->cur_entry,doc->cur_col);
258
-
259
- rx->indent=QueVectU8New(doc->cur_entry->y);
260
-
261
- Lex(rx->cc1);
262
- EdRIStmt(rx,FALSE);
263
-
264
- CmpCtrlDel(rx->cc1);
265
- CmpCtrlDel(rx->cc2);
266
- res=rx->indent;
267
- Free(rx);
268
- return res;
269
- }
270
-
271
- U0 EdRemFunLeadingSpace(CDoc *doc)
272
- {
273
- Bool unlock=DocLock(doc),
274
- start_of_line=TRUE;
275
- U8 *ptr;
276
- I64 ch,levels=1;
277
- CDocEntry *doc_e,*doc_e2;
278
-
279
- EdGoToFun(doc,FALSE,FALSE);
280
- doc_e=doc->cur_entry->next;
281
- do {
282
- doc_e2=doc_e->next;
283
- if (doc_e!=doc && doc_e!=doc->cur_entry &&
284
- !(doc_e->de_flags&(DOCEG_DONT_EDIT-DOCEF_SCROLLING_X)))
285
- switch (doc_e->type_u8) {
286
- case DOCT_TEXT:
287
- ptr=doc_e->tag;
288
- if (start_of_line) {
289
- while (*ptr==CH_SPACE)
290
- ptr++;
291
- if (*ptr)
292
- start_of_line=FALSE;
293
- ptr=StrNew(ptr,doc->mem_task);
294
- Free(doc_e->tag);
295
- doc_e->tag=ptr;
296
- }
297
- if (!*ptr)
298
- DocEntryDel(doc,doc_e);
299
- else {
300
- while (ch=*ptr++)
301
- if (ch=='{')
302
- levels++;
303
- else if (ch=='}') {
304
- if (!--levels)
305
- break;
306
- }
307
- if (!levels) goto ls_done;
308
- }
309
- break;
310
- case DOCT_TAB:
311
- if (start_of_line)
312
- DocEntryDel(doc,doc_e);
313
- break;
314
- case DOCT_NEW_LINE:
315
- start_of_line=TRUE;
316
- break;
317
- default:
318
- start_of_line=FALSE;
319
- }
320
- doc_e=doc_e2;
321
- } while (doc_e!=doc->cur_entry);
322
- ls_done:
323
- DocRecalc(doc);
324
- DocCenter(doc);
325
- if (unlock)
326
- DocUnlock(doc);
327
- }
328
-
329
- class CRenum
330
- {
331
- CRenum *next,*last;
332
- U8 label[sizeof(CEdFindText.find_text)];
333
- };
334
-
335
- I64 EdRAGetU8(CDoc *doc)
336
- {
337
- I64 res=-1;
338
- while (doc->cur_entry!=doc &&
339
- doc->cur_entry->type&DOCET_SEL && res<0) {
340
- res=EdCurU8(doc);
341
- EdCursorRight(doc);
342
- }
343
- return res;
344
- }
345
-
346
- U0 EdRACollect(CDoc *doc,CRenum *head)
347
- {
348
- I64 ch,i;
349
- CRenum *tmpr;
350
- U8 buf[sizeof(CEdFindText.find_text)];
351
- ch=EdRAGetU8(doc);
352
- while (ch>=0) {
353
- if (ch!='@')
354
- ch=EdRAGetU8(doc);
355
- else {
356
- ch=EdRAGetU8(doc);
357
- if (ch=='@') {
358
- ch=EdRAGetU8(doc);
359
- StrCpy(buf,"@@");
360
- i=2;
361
- while (ch>=0 && i<sizeof(CEdFindText.find_text)) {
362
- if (Bt(char_bmp_alpha_numeric,ch))
363
- buf[i++]=ch;
364
- else
365
- break;
366
- ch=EdRAGetU8(doc);
367
- }
368
- if (i<sizeof(CEdFindText.find_text)) {
369
- buf[i++]=0;
370
- while (ch>=0 && Bt(char_bmp_white_space,ch))
371
- ch=EdRAGetU8(doc);
372
- if (ch==':') {
373
- ch=EdRAGetU8(doc);
374
- tmpr=MAlloc(sizeof(CRenum));
375
- StrCpy(tmpr->label,buf);
376
- QueIns(tmpr,head->last);
377
- }
378
- }
379
- }
380
- }
381
- }
382
- //This is needed because we moved the
383
- //cursor and it didn't recalc.
384
- DocRecalc(doc);
385
- }
386
-
387
- U0 EdRenumAsm(CDoc *doc)
388
- {
389
- Bool unlock=DocLock(doc);
390
- I64 num=0;
391
- CRenum head,*tmpr,*tmpr1;
392
- U8 buf[sizeof(CEdFindText.find_text)],
393
- buf2[sizeof(CEdFindText.find_text)];
394
-
395
- QueInit(&head);
396
- EdSelFun(doc,TRUE);
397
- EdRACollect(doc,&head);
398
-
399
- tmpr=head.next;
400
- while (tmpr!=&head) {
401
- tmpr1=tmpr->next;
402
- num+=ASM_RENUM_SPACING;
403
- StrPrint(buf,"@#%02d",num);
404
- EdReplace(doc,tmpr->label,buf,TRUE,TRUE,TRUE);
405
- Free(tmpr);
406
- tmpr=tmpr1;
407
- }
408
-
409
- while (num) {
410
- StrPrint(buf, "@#%02d",num);
411
- StrPrint(buf2,"@@%02d",num);
412
- EdReplace(doc,buf,buf2,TRUE,TRUE,TRUE);
413
- num-=ASM_RENUM_SPACING;
414
- }
415
- EdSelAll(doc,FALSE);
416
- DocRecalc(doc);
417
- DocCenter(doc);
418
- if (unlock)
419
- DocUnlock(doc);
420
- }
421
-
422
- U0 EdCodeTools2(CDoc *doc,I64 tool_action,Bool beep=TRUE)
423
- {
424
- Bool okay,unlock=DocLock(doc),start_of_line=TRUE;
425
- CDocEntry *doc_e,*doc_ne;
426
- I64 i,start_y,end_y,x,r,goto_line_num;
427
- U8 *b,*st,*st2,*prj_file;
428
- CTask *task=NULL;
429
- CJob *tmpc;
430
- CQueVectU8 *indent;
431
-
432
- DocRecalc(doc);
433
- goto_line_num=doc->cur_entry->y+1;
434
-
435
- DocCaptureUndo(doc,TRUE);
436
- switch (tool_action) {
437
- case EF_CMP_CHK:
438
- okay=FALSE;
439
- if (doc->flags&DOCF_PLAIN_TEXT)
440
- DocFlagsToggle(doc,DOCF_PLAIN_TEXT);
441
- DocWrite(doc);
442
- task=Spawn(&SrvCmdLine,NULL,"Srv",,Fs);
443
- st2=DirCur;
444
- st=MStrPrint("Cd(\"%s\");",st2);
445
- tmpc=TaskExe(task,Fs,st,1<<JOBf_WAKE_MASTER|1<<JOBf_FOCUS_MASTER);
446
- Free(st2);
447
- Free(st);
448
- WinHorz(Fs->win_left,Fs->win_right, task);
449
- WinVert(Fs->win_top, Fs->win_bottom,task);
450
- if (JobResScan(tmpc,&r)) {
451
- st=DirFile(doc->filename.name,,"PRJ.Z");
452
- prj_file=FileNameAbs(st,FUF_Z_OR_NOT_Z);
453
- Free(st);
454
- if (FileFind(prj_file)) {
455
- st2=DirFile(prj_file),
456
- st=MStrPrint("Cd(\"%s\");",st2);
457
- Free(st2);
458
- tmpc=TaskExe(task,Fs,st,1<<JOBf_WAKE_MASTER|
459
- 1<<JOBf_FOCUS_MASTER|1<<JOBf_FREE_ON_COMPLETE);
460
- Free(st);
461
- st=MStrPrint("\"$$WW,1$$\";Cmp(\"%s\",\"SysTmp\",\"SysTmp\");",
462
- prj_file);
463
- tmpc=TaskExe(task,Fs,st,1<<JOBf_WAKE_MASTER|1<<JOBf_FOCUS_MASTER);
464
- Free(st);
465
- if (JobResScan(tmpc,&r))
466
- if (!r) {
467
- tmpc=TaskExe(task,Fs,
468
- "Load(\"SysTmp\",LDF_JUST_LOAD);",
469
- 1<<JOBf_WAKE_MASTER|1<<JOBf_FOCUS_MASTER);
470
- if (JobResScan(tmpc,&r))
471
- okay=TRUE;
472
- }
473
- tmpc=TaskExe(task,Fs,"Del(\"SysTmp.*\");",
474
- 1<<JOBf_WAKE_MASTER|1<<JOBf_FOCUS_MASTER);
475
- JobResScan(tmpc,&r);
476
- } else {
477
- Free(prj_file);
478
- st=DirFile(doc->filename.name,"Load","HC.Z");
479
- prj_file=FileNameAbs(st,FUF_Z_OR_NOT_Z);
480
- Free(st);
481
- if (FileFind(prj_file))
482
- st=MStrPrint("\"$$WW,1$$\";ExeFile(\"%s\",CCF_JUST_LOAD);",prj_file);
483
- else
484
- st=MStrPrint("\"$$WW,1$$\";ExeFile(\"%s\",CCF_JUST_LOAD);",
485
- doc->filename.name);
486
- tmpc=TaskExe(task,Fs,st,1<<JOBf_WAKE_MASTER|1<<JOBf_FOCUS_MASTER);
487
- Free(st);
488
- if (JobResScan(tmpc,&r) && r)
489
- okay=TRUE;
490
- }
491
- Free(prj_file);
492
- }
493
- if (!okay) {
494
- PopUpOk("Has Errors");
495
- while (LBts(&sys_semas[SEMA_FIX],0))
496
- Yield;
497
- ToFileLine(dbg.fix_file_line,&st,&i);
498
- LBtr(&sys_semas[SEMA_FIX],0);
499
- if (!StrCmp(st,doc->filename.name))
500
- goto_line_num=i;
501
- Free(st);
502
- }
503
- break;
504
- case EF_REINDENT:
505
- start_y=doc->cur_entry->y;
506
- EdReplaceTroubleAll(doc,TRUE,FALSE);
507
- DocGoToLine(doc,start_y+1);
508
- if (EdGoToFun(doc,FALSE,FALSE)) {
509
- start_y=doc->cur_entry->y;
510
- indent=EdRICode(doc);
511
- DocUnlock(doc);
512
- if (beep) {
513
- Snd(86); Sleep(150); Snd;
514
- Sleep(100);
515
- Snd(86); Sleep(150); Snd;
516
- }
517
- DocLock(doc);
518
- EdRemFunLeadingSpace(doc);
519
- DocGoToLine(doc,start_y+1);
520
- doc_e=doc->cur_entry;
521
- end_y=start_y+indent->total_cnt;
522
- while (start_y<=doc_e->y<end_y) {
523
- if (doc_e!=doc && doc_e!=doc->cur_entry &&
524
- !(doc_e->de_flags&(DOCEG_DONT_EDIT-DOCEF_SCROLLING_X))) {
525
- if (doc_e->type_u8==DOCT_NEW_LINE||
526
- doc_e->type_u8==DOCT_SOFT_NEW_LINE)
527
- start_of_line=TRUE;
528
- else {
529
- if (start_of_line) {
530
- i=QueVectU8Get(indent,doc_e->y)*C_INDENT_SPACES;
531
- x=doc_e->x+1;
532
- while (i>8) {
533
- doc_ne=DocEntryNewBase(doc,
534
- DOCT_TAB|doc->settings_head.dft_text_attr<<8,,
535
- x,doc_e->y,doc_e->page_line_num);
536
- MemCpy(&doc_ne->settings,
537
- &doc_e->settings,sizeof(CDocSettings));
538
- QueIns(doc_ne,doc_e->last);
539
- i-=8;
540
- x+=8;
541
- }
542
- if (i>0) {
543
- b=MAlloc(i+1,doc->mem_task);
544
- MemSet(b,CH_SPACE,i);
545
- b[i]=0;
546
- doc_ne=DocEntryNewBase(doc,
547
- DOCT_TEXT|doc->settings_head.dft_text_attr<<8,,
548
- x,doc_e->y,doc_e->page_line_num);
549
- doc_ne->tag=b;
550
- doc_ne->max_col=1;
551
- MemCpy(&doc_ne->settings,
552
- &doc_e->settings,sizeof(CDocSettings));
553
- QueIns(doc_ne,doc_e->last);
554
- }
555
- }
556
- start_of_line=FALSE;
557
- }
558
- }
559
- doc_e=doc_e->next;
560
- }
561
- QueVectU8Del(indent);
562
- }
563
- start_y=doc->cur_entry->y;
564
- EdReplaceTroubleAll(doc,FALSE,FALSE);
565
- DocGoToLine(doc,start_y+1);
566
- break;
567
- case EF_RENUM_ASM:
568
- if (EdGoToFun(doc,FALSE,TRUE)) {
569
- if (EdCurU8(doc)=='{') {
570
- EdCursorRight(doc);
571
- DocRecalc(doc);
572
- } else if (EdCurU8(doc)==':') {
573
- EdCursorRight(doc);
574
- if (EdCurU8(doc)==':')
575
- EdCursorRight(doc);
576
- DocRecalc(doc);
577
- }
578
- DocUnlock(doc);
579
- if (beep) {
580
- Snd(86); Sleep(150); Snd;
581
- Sleep(100);
582
- Snd(86); Sleep(150); Snd;
583
- }
584
- DocLock(doc);
585
- EdRenumAsm(doc);
586
- }
587
- break;
588
- }
589
-
590
- DocRecalc(doc);
591
- DocGoToLine(doc,goto_line_num);
592
-
593
- DocUnlock(doc);
594
- if (!unlock)
595
- DocLock(doc);
596
- if (task)
597
- Kill(task,FALSE);
598
- }
599
-
600
- U0 EdPopUpChSC(I64 *_ch,I64 *_sc)
601
- {
602
- I64 sc;
603
- "Press A Key\n";
604
- DocPut->flags|=DOCF_SIZE_MIN;
605
- do GetMsg(_ch,&sc,1<<MSG_KEY_DOWN);
606
- while (sc.u8[0]==SC_SHIFT || sc.u8[0]==SC_CTRL || sc.u8[0]==SC_ALT);
607
- *_sc=sc;
608
- }
609
-
610
- U0 EdChSC(CDoc *doc)
611
- {
612
- I64 ch,sc;
613
- U8 buf[STR_LEN];
614
- StrPrint(buf,"EdPopUpChSC(%d,%d);",&ch,&sc);
615
- PopUp(buf,Fs);
616
- if (ch==CH_BACKSPACE)
617
- DocPrint(doc,"CH_BACKSPACE,0x%X",sc);
618
- else if (ch=='\n')
619
- DocPrint(doc,"'\n',0x%X",sc);
620
- else if (CH_CTRLA<=ch<=CH_CTRLZ)
621
- DocPrint(doc,"CH_CTRL%C,0x%X",ch+'@',sc);
622
- else if (ch=='$$')
623
- DocPrint(doc,"'$$$$',0x%X",sc);
624
- else if (ch=='\\')
625
- DocPrint(doc,"'\\\\',0x%X",sc);
626
- else if (ch=='\'')
627
- DocPrint(doc,"'\\\'',0x%X",sc);
628
- else if (ch==CH_ESC)
629
- DocPrint(doc,"CH_ESC,0x%X",sc);
630
- else if (ch==CH_SHIFT_ESC)
631
- DocPrint(doc,"CH_SHIFT_ESC,0x%X",sc);
632
- else if (ch==CH_SPACE)
633
- DocPrint(doc,"CH_SPACE,0x%X",sc);
634
- else if (ch==CH_SHIFT_SPACE)
635
- DocPrint(doc,"CH_SHIFT_SPACE,0x%X",sc);
636
- else if (Bt(char_bmp_displayable,ch))
637
- DocPrint(doc,"'%c',0x%X",ch,sc);
638
- else
639
- DocPrint(doc,"0x%X,0x%X",ch,sc);
640
- }
641
-
642
- U0 EdCodeTools(CDoc *doc)
643
- {
644
- I64 tool_action=PopUpEdFmt;
645
- switch (tool_action) {
646
- case EF_CMP_CHK:
647
- case EF_REINDENT:
648
- case EF_RENUM_ASM:
649
- EdCodeTools2(doc,tool_action);
650
- break;
651
- case EF_CTRL_SLIDER:
652
- TemplateCtrlSlider(doc);
653
- break;
654
- case EF_CH_SC:
655
- EdChSC(doc);
656
- break;
657
- }
658
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:6c92698f2de45cdf3c21affc4d3cc1c085ce8947394af16654738ab9a9cd1096
3
+ size 15599
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/DolDoc/DocDblBuf.HC CHANGED
@@ -1,110 +1,3 @@
1
- #help_index "DolDoc/Task;StdOut/Task"
2
- public CDoc *DocPut(CTask *task=NULL)
3
- {//Current document that StdOut Put() goes to.
4
- //Basically, StdOut unless double buffering.
5
- CDoc *res;
6
- if (!task) task=Fs;
7
- if (Bt(&task->task_flags,TASKf_INPUT_FILTER_TASK))
8
- task=task->parent_task;
9
- if ((res=task->put_doc) && res->doc_signature==DOC_SIGNATURE_VAL)
10
- return res;
11
- else
12
- return NULL;
13
- }
14
-
15
- public CDoc *DocDisplay(CTask *task=NULL)
16
- {//StdOut displayed unless double buffering.
17
- CDoc *res;
18
- if (!task) task=Fs;
19
- if ((res=task->display_doc) && res->doc_signature==DOC_SIGNATURE_VAL)
20
- return res;
21
- else
22
- return NULL;
23
- }
24
-
25
- public CDoc *DocBorder(CTask *task=NULL)
26
- {//Doc holding border of window text.
27
- CDoc *res;
28
- if (!task) task=Fs;
29
- if ((res=task->border_doc) && res->doc_signature==DOC_SIGNATURE_VAL)
30
- return res;
31
- else
32
- return NULL;
33
- }
34
-
35
- public CDoc *DocDblBufStart(CTask *task=NULL)
36
- {//See $LK,"::/Demo/Spy.HC"$
37
- Bool unlock_ddoc;
38
- CDoc *pdoc=DocPut(task),*ddoc=DocDisplay(task),*res;
39
- if (!pdoc || !ddoc || pdoc!=ddoc)
40
- res=NULL; //Already Double buffering
41
- else {
42
- if (!task) task=Fs;
43
- unlock_ddoc=DocLock(ddoc); //dont change during winupdate, so lock DocPut$WW,0$
44
- res=DocNew(,task);
45
- res->win_task =ddoc->win_task;
46
- res->max_entries =ddoc->max_entries;
47
- MemCpy(res->find_replace,ddoc->find_replace,sizeof(CEdFindText));
48
- MemCpy(&res->filename,&ddoc->filename,sizeof(CEdFileName));
49
- res->left_click_link =ddoc->left_click_link;
50
- res->right_click_link =ddoc->right_click_link;
51
- res->user_put_data =ddoc->user_put_data;
52
- res->user_put_key =ddoc->user_put_key;
53
- res->user_put_s =ddoc->user_put_s;
54
- res->parent_doc =ddoc->parent_doc;
55
- res->desc =ddoc->desc;
56
- res->user_data =ddoc->user_data;
57
- res->flags|=ddoc->flags&DOCG_DBL_BUF_FLAGS | DOCF_DONT_SHOW;
58
- task->put_doc=res;
59
- if (unlock_ddoc)
60
- DocUnlock(ddoc);
61
- }
62
- return res;
63
- }
64
-
65
- public Bool DocDblBufEnd(CTask *task=NULL)
66
- {//See $LK,"::/Demo/Spy.HC"$
67
- Bool res=FALSE;
68
- CDoc *pdoc=DocPut(task),*ddoc=DocDisplay(task);
69
- if (pdoc && ddoc && pdoc!=ddoc) {//Double buffering?
70
- if (!task) task=Fs;
71
- ddoc->flags|=DOCF_DONT_SHOW;
72
- pdoc->flags&=~DOCF_DONT_SHOW;
73
- DocLock(ddoc);
74
- task->display_doc=pdoc;
75
- DocUnlock(ddoc);
76
- DocDel(ddoc);
77
- res=TRUE;
78
- }
79
- return res;
80
- }
81
-
82
- public Bool DocDblBufSwap(CTask *task=NULL)
83
- {//See $LK,"::/Demo/Spy.HC"$
84
- Bool res=FALSE;
85
- CDoc *pdoc=DocPut(task),*ddoc=DocDisplay(task);
86
- if (pdoc && ddoc && pdoc!=ddoc) {//Double buffering?
87
- if (!task) task=Fs;
88
- ddoc->flags|=DOCF_DONT_SHOW;
89
- pdoc->flags&=~DOCF_DONT_SHOW;
90
- DocLock(ddoc);
91
- task->display_doc=pdoc;
92
- DocUnlock(ddoc);
93
- DocRst(ddoc,TRUE);
94
- MemCpy(ddoc->find_replace,pdoc->find_replace,sizeof(CEdFindText));
95
- MemCpy(&ddoc->filename,&pdoc->filename,sizeof(CEdFileName));
96
- ddoc->max_entries =pdoc->max_entries;
97
- ddoc->flags =pdoc->flags&DOCG_DBL_BUF_FLAGS |
98
- ddoc->flags&~DOCG_DBL_BUF_FLAGS;
99
- ddoc->left_click_link =pdoc->left_click_link;
100
- ddoc->right_click_link =pdoc->right_click_link;
101
- ddoc->user_put_data =pdoc->user_put_data;
102
- ddoc->user_put_key =pdoc->user_put_key;
103
- ddoc->user_put_s =pdoc->user_put_s;
104
- ddoc->desc =pdoc->desc;
105
- ddoc->user_data =pdoc->user_data;
106
- task->put_doc=ddoc;
107
- res=TRUE;
108
- }
109
- return res;
110
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:ee9d9527aa646f0f8a619cc18b95215c77e4cde8eb8ea7562d4d4f6cf10da348
3
+ size 3340
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/DolDoc/DocEd.HC CHANGED
@@ -1,265 +1,3 @@
1
- #help_index "DolDoc/Output;StdOut/DolDoc"
2
-
3
- public Bool View()
4
- {//Go live for user interaction until <ESC> or <SHIFT-ESC>.
5
- I64 ch;
6
- do ch=DocGetKey;
7
- while (ch!=CH_ESC && ch!=CH_SHIFT_ESC);
8
- return ch==CH_ESC;
9
- }
10
-
11
- #help_index "DolDoc"
12
- U8 *EdOverStrikeCB(CDoc *,CDocEntry *doc_e,CTask *mem_task)
13
- {
14
- CDoc *doc=doc_e->user_data;
15
- U8 *st=MAlloc(8,mem_task);
16
- if (doc->flags & DOCF_OVERSTRIKE)
17
- *st='O';
18
- else
19
- *st='�';
20
- st[1]=0;
21
- return st;
22
- }
23
-
24
- U8 *EdAutoSaveCB(CDoc *,CDocEntry *doc_e,CTask *mem_task)
25
- {
26
- CDoc *doc=doc_e->user_data;
27
- U8 *st=MAlloc(8,mem_task);
28
- if (doc->flags & DOCF_AUTO_SAVE)
29
- *st='S';
30
- else
31
- *st='�';
32
- st[1]=0;
33
- return st;
34
- }
35
-
36
- U8 *EdFilterCB(CDoc *,CDocEntry *doc_e,CTask *mem_task)
37
- {
38
- CDoc *doc=doc_e->user_data;
39
- U8 *st=MAlloc(8,mem_task);
40
- if (doc->find_replace->filter_lines)
41
- *st='F';
42
- else
43
- *st='�';
44
- st[1]=0;
45
- return st;
46
- }
47
-
48
- U8 *EdDollarCB(CDoc *,CDocEntry *doc_e,CTask *mem_task)
49
- {
50
- CDoc *doc=doc_e->user_data;
51
- U8 *st=MAlloc(8,mem_task);
52
- if (doc->flags & DOCF_IN_DOLLAR)
53
- *st='$$';
54
- else
55
- *st='�';
56
- st[1]=0;
57
- return st;
58
- }
59
-
60
- U8 *EdMoreCB(CDoc *,CDocEntry *doc_e,CTask *mem_task)
61
- {
62
- CDoc *doc=doc_e->user_data;
63
- U8 *st=MAlloc(8,mem_task);
64
- if (doc->flags&DOCF_MORE)
65
- StrCpy(st,"More�");
66
- else
67
- StrCpy(st,"�����");
68
- return st;
69
- }
70
-
71
- U8 *EdDollarTypeCB(CDoc *,CDocEntry *doc_e,CTask *mem_task)
72
- {
73
- CDoc *doc=doc_e->user_data;
74
- U8 *src=DefineSub(doc->cur_entry->type_u8,"ST_DOC_CMDS"),
75
- *st=CAlloc(8,mem_task);
76
- if (doc->cur_entry==doc)
77
- src="EOF";
78
- else if (!src)
79
- src="ERR";
80
- StrPrint(st,"%-3ts",src);
81
- return st;
82
- }
83
-
84
- public Bool DocEd(CDoc *doc,I64 dof_flags=0)
85
- {//Live for user interaction. End on <ESC> or <SHIFT-ESC>.
86
- CDoc *old_put_doc =DocPut,
87
- *old_display_doc=DocDisplay,
88
- *old_border_doc =DocBorder,*bdoc;
89
- CDocEntry *doc_e;
90
- I64 old_attr=Fs->text_attr,
91
- old_top =Fs->win_top, old_bottom=Fs->win_bottom,
92
- old_left=Fs->win_left,old_right =Fs->win_right,
93
- old_title_src=Fs->title_src;
94
- Bool res,unlock;
95
- U8 *old_task_title;
96
- if (dof_flags&DOF_WIN_MAX)
97
- WinMax;
98
-
99
- unlock=DocLock(doc);
100
- doc->win_task=Fs;
101
- bdoc=DocNew;
102
- bdoc->flags|=DOCF_BORDER_DOC;
103
- DocPrint(bdoc,"$$CM+TY+LX+NC,0,-1$$");
104
- DocPrint(bdoc,"$$TX+RX+BD,\"[X]\"$$");
105
- DocPrint(bdoc,"$$BK,1$$$$TX+LX+BD,\"MENU\"$$$$BK,0$$");
106
-
107
- old_task_title=StrNew(Fs->task_title);
108
- if (Fs->title_src!=TTS_LOCKED_CONST) {
109
- Fs->title_src=TTS_ED_FILENAME;
110
- MemCpy(Fs->task_title,doc->filename.name,STR_LEN-1);
111
- }
112
- doc_e=DocPrint(bdoc,"$$DA-TRM-P+BD+RD+CX+IV,LEN=STR_LEN-1,"
113
- "A=\"%%s...\",SCX=16$$");
114
- doc_e->data=&Fs->task_title;
115
- DocDataFmt(bdoc,doc_e);
116
-
117
- if (doc->flags & DOCF_ALLOW_UNDO) {
118
- DocPrint(bdoc,"$$CM+BY+LX+NC,1,1$$");
119
- doc_e=DocPrint(bdoc,"$$DA+BD+RD-TRM,RT=U32,A=\"Undo:%%03d\"$$\n");
120
- doc_e->data=&doc->undo_cnt;
121
- DocDataFmt(bdoc,doc_e);
122
- }
123
-
124
- DocPrint(bdoc,"$$CM+BY+RX+NC,-31,1$$");
125
- doc_e=DocPrint(bdoc,"$$TX+BD+TC,\" \"$$");
126
- doc_e->user_data=doc;
127
- doc_e->tag_cb=&EdMoreCB;
128
- doc_e=DocPrint(bdoc,"$$TX+BD+TC,\" \"$$");
129
- doc_e->user_data=doc;
130
- doc_e->tag_cb=&EdDollarTypeCB;
131
- doc_e=DocPrint(bdoc,"$$TX+BD+TC,\" \"$$");
132
- doc_e->user_data=doc;
133
- doc_e->tag_cb=&EdFilterCB;
134
- doc_e=DocPrint(bdoc,"$$TX+BD+TC,\" \"$$");
135
- doc_e->user_data=doc;
136
- doc_e->tag_cb=&EdOverStrikeCB;
137
- doc_e=DocPrint(bdoc,"$$TX+BD+TC,\" \"$$");
138
- doc_e->user_data=doc;
139
- doc_e->tag_cb=&EdAutoSaveCB;
140
- doc_e=DocPrint(bdoc,"$$TX+BD+TC,\" \"$$");
141
- doc_e->user_data=doc;
142
- doc_e->tag_cb=&EdDollarCB;
143
- doc_e=DocPrint(bdoc,"$$DA+BD+RD-TRM,A=\"Line:%%04d \"$$");
144
- doc_e->data=&doc->line;
145
- DocDataFmt(bdoc,doc_e);
146
- doc_e=DocPrint(bdoc,"$$DA+BD+RD-TRM,A=\"Col:%%04d\"$$\n");
147
- doc_e->data=&doc->col;
148
- DocDataFmt(bdoc,doc_e);
149
-
150
- DocRecalc(bdoc);
151
- DocRecalc(doc);
152
- if (!(dof_flags&DOF_DONT_HOME))
153
- DocTop(doc);
154
- Fs->border_doc=bdoc;
155
- if (doc!=old_display_doc)
156
- doc->parent_doc=old_display_doc;
157
- Fs->put_doc=Fs->display_doc=doc;
158
- if (!(dof_flags&DOF_DONT_TEXT_ATTR))
159
- Fs->text_attr=DOC_ATTR_DFT_TEXT;
160
- if (!(dof_flags&DOF_DONT_SHOW)) {
161
- LBts(&Fs->display_flags,DISPLAYf_SHOW);
162
- WinZBufUpdate;
163
- }
164
- if (dof_flags&DOF_SIZE_MIN)
165
- doc->flags|=DOCF_SIZE_MIN;
166
-
167
- DocUnlock(doc);
168
- if (!(dof_flags&DOF_DONT_WINMGR_SYNC)) {
169
- Refresh(2,TRUE);
170
- if (doc->flags&DOCF_SIZE_MIN)
171
- Refresh(2,TRUE);
172
- }
173
- res=View;
174
-
175
- DocLock(doc);
176
- if (res) {
177
- doc_e=doc->head.next;
178
- while (doc_e!=doc) {
179
- if (doc_e->type_u8==DOCT_DATA || doc_e->type_u8==DOCT_CHECK_BOX)
180
- DocDataScan(doc,doc_e);
181
- doc_e=doc_e->next;
182
- }
183
- }
184
- if (unlock)
185
- DocUnlock(doc);
186
- Fs->border_doc =old_border_doc;
187
- Fs->display_doc=old_display_doc;
188
- Fs->put_doc =old_put_doc;
189
- Fs->text_attr =old_attr;
190
- if (Fs->title_src!=TTS_LOCKED_CONST) {
191
- Fs->title_src =old_title_src;
192
- StrCpy(Fs->task_title,old_task_title);
193
- }
194
- Free(old_task_title);
195
- DocDel(bdoc);
196
- if (dof_flags&DOF_SIZE_MIN) {
197
- WinHorz(old_left,old_right);
198
- WinVert(old_top,old_bottom);
199
- }
200
- return res;
201
- }
202
-
203
- #help_index "DolDoc/Cmd Line (Typically);Cmd Line (Typically)"
204
- public Bool Ed(U8 *link_st,I64 edf_dof_flags=0)
205
- {//Invoke document editor.
206
- U8 *filename,*needle_str;
207
- I64 i,num;
208
- Bool cont,res=FALSE;
209
- CDoc *doc;
210
-
211
- switch (i=EdLinkCvt(link_st,&filename,&needle_str,&num,edf_dof_flags)) {
212
- case -1:
213
- break;
214
- case LK_DEF:
215
- doc=DocNew;
216
- doc->desc='DictDef';
217
- ACDDefsPut(doc,filename,num);
218
- goto ej_doc;
219
- case LK_HELP_INDEX:
220
- doc=DocNew;
221
- doc->desc='HelpIndx';
222
- DocHelpIdx(doc,filename);
223
- ej_doc:
224
- if (!(edf_dof_flags&EDF_BAIL)) {
225
- DocEd(doc);
226
- DocDel(doc);
227
- }
228
- if (!(edf_dof_flags&EDF_WAS_WRITE))
229
- res=TRUE;
230
- break;
231
- default:
232
- if (IsRaw)
233
- res=EdLite(filename,num,edf_dof_flags);
234
- else {
235
- cont=TRUE;
236
- if (!(edf_dof_flags&EDF_BAIL) && !(LK_DOC<=i<=LK_DOC_LINE) &&
237
- !FilesFindMatch(filename,FILEMASK_TXT) &&
238
- !PopUpCancelOk(ST_WARN_ST "Not Text File\n\n"))
239
- cont=FALSE;
240
- if (cont)
241
- res=DocFileEd(i,filename,needle_str,&num,edf_dof_flags);
242
- }
243
- }
244
- Free(filename);
245
- Free(needle_str);
246
- return res;
247
- }
248
-
249
- public Bool Plain(U8 *filename,I64 edf_dof_flags=0)
250
- {//Edit document in plain text mode, so dollar signs are not special.
251
- Bool res;
252
- U8 *st=MStrPrint("PI:%s",filename);
253
- res=Ed(st,edf_dof_flags);
254
- Free(st);
255
- return res;
256
- }
257
-
258
- #help_index "DolDoc;Job/Exe;Task/Job/Exe"
259
- public I64 PopUpEd(U8 *filename,CTask *parent=NULL,CTask **_pu_task=NULL)
260
- {//Create PopUp win task and edit a doc.
261
- U8 *st=MStrPrint("Ed(\"%Q\");",filename);
262
- I64 res=PopUp(st,parent,_pu_task);
263
- Free(st);
264
- return res;
265
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:749746dae191c006baf4ab6c12d29909bd768e8f1854ac5afa34bc11abb6367f
3
+ size 6565
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/DolDoc/DocExt.HC CHANGED
@@ -1,14 +1,3 @@
1
- #help_index "DolDoc"
2
- extern Bool DocEd(CDoc *doc,I64 dof_flags=0);
3
- extern I64 DocEntryRun(CDoc *doc,CDocEntry *doc_e,
4
- Bool exited,I64 *_has_action=NULL);
5
- extern U0 DocFormBwd(CDoc *doc,Bool giveup=FALSE);
6
- extern Bool DocGoToLine(CDoc *doc,I64 line_num);
7
- extern U0 DocLoad(CDoc *doc,U8 *src2,I64 size);
8
- extern U0 DocPrintAtomic(CDoc *doc=NULL,U8 *fmt,...);
9
- extern U0 DocPrintPartial(CDoc *doc=NULL,U8 *fmt,...);
10
- extern CDocEntry *DocPutS(CDoc *doc,U8 *st);
11
- extern U8 *DocSave(CDoc *doc,I64 *_size=NULL);
12
- extern I64 EdLeftClickLink(CDoc *doc,CDocEntry *doc_e);
13
- extern I64 PopUpPickLst(U8 *lst);
14
- extern I64 TermRightClickLink(CDoc *doc,CDocEntry *doc_e);
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:f492ca1a9a3fd4b319685784d9df7c34cc65a5c2d830ca7426ffcceaffeda2ae
3
+ size 653
 
 
 
 
 
 
 
 
 
 
 
Adam/DolDoc/DocFile.HC CHANGED
@@ -1,357 +1,3 @@
1
- #help_index "DolDoc/File"
2
-
3
- public U0 DocLoad(CDoc *doc,U8 *src2,I64 size)
4
- {//Fetch doc from raw mem buf.
5
- I64 i;
6
- U8 *src;
7
- Bool unlock=DocLock(doc);
8
- CDocBin *tmpb;
9
- doc->find_replace->filter_lines=0;
10
- if (src2) {
11
- DocPutS(doc,src2); //Too big $LK,"DocPrint",A="MN:DocPrint"$() is wasteful.
12
- src=src2+StrLen(src2)+1;
13
- i=size-(offset(CDocBin.end)-offset(CDocBin.start));
14
- while (src<=src2+i) {
15
- tmpb=CAlloc(sizeof(CDocBin),doc->mem_task);
16
- MemCpy(&tmpb->start,src,offset(CDocBin.end)-offset(CDocBin.start));
17
- src+=offset(CDocBin.end)-offset(CDocBin.start);
18
- tmpb->data=MAlloc(tmpb->size,doc->mem_task);
19
- if (tmpb->size) {
20
- MemCpy(tmpb->data,src,tmpb->size);
21
- src+=tmpb->size;
22
- }
23
- QueIns(tmpb,doc->bin_head.last);
24
- if (tmpb->num>=doc->cur_bin_num)
25
- doc->cur_bin_num=tmpb->num+1;
26
- }
27
- }
28
- if (!(doc->flags & (DOCF_PLAIN_TEXT|DOCF_PLAIN_TEXT_TABS)))
29
- DocBinsValidate(doc);
30
- DocTop(doc); //Calls $LK,"DocRecalc",A="MN:DocRecalc"$(). DOCT_CURSOR will be set.
31
- if (unlock)
32
- DocUnlock(doc);
33
- }
34
-
35
- public CDoc *DocRead(U8 *name=NULL,I64 flags=0)
36
- {//Fetch doc from disk. See $LK,"flags",A="MN:DOCF_PLAIN_TEXT"$.
37
- CDoc *doc=DocNew;
38
- U8 *src,*name2;
39
- I64 size=0;
40
- CDirContext *dirc;
41
- if (!name) name=blkdev.tmp_filename;
42
- doc->flags|=flags;
43
- name2=FileNameAbs(name);
44
- StrCpy(doc->filename.name,name2);
45
- if (src=FileRead(name2,&size,&doc->file_attr)) {
46
- if (dirc=DirContextNew(name2)) {
47
- DocLoad(doc,src,size);
48
- DirContextDel(dirc);
49
- }
50
- Free(src);
51
- }
52
- Free(name2);
53
- return doc;
54
- }
55
-
56
- public U8 *DocSave(CDoc *doc,I64 *_size=NULL)
57
- {//Store doc to raw mem buf.
58
- CDocEntry *doc_e,*doc_e1;
59
- CDocBin *b;
60
- Bool unlock=DocLock(doc);
61
- I64 ch,cnt=1;//terminator
62
- U8 *st,*res,*dst,*src;
63
-
64
- if (!(doc->flags & (DOCF_PLAIN_TEXT|DOCF_PLAIN_TEXT_TABS)))
65
- DocBinsValidate(doc);
66
- if (doc->flags&DOCF_NO_CURSOR)
67
- DocRecalc(doc);
68
- else {
69
- DocRecalc(doc,RECALCF_ADD_CURSOR);
70
- if (doc->head.next->type_u8==DOCT_CURSOR)
71
- DocEntryDel(doc,doc->head.next); //If no cursor, $LK,"DocLoad",A="MN:DocLoad"$() puts at top.
72
- }
73
- for (doc_e=doc->head.next;doc_e!=doc;doc_e=doc_e->next) {
74
- if (!Bt(doldoc.type_flags_data,doc_e->type_u8)) {
75
- switch (doc_e->type_u8) {
76
- case DOCT_TAB:
77
- case DOCT_PAGE_BREAK:
78
- case DOCT_CURSOR:
79
- cnt++;
80
- break;
81
- case DOCT_NEW_LINE:
82
- if (doc->flags&DOCF_CARRIAGE_RETURN)
83
- cnt+=2;
84
- else
85
- cnt++;
86
- break;
87
- case DOCT_SOFT_NEW_LINE:
88
- break;
89
- case DOCT_TEXT:
90
- if (!(doc_e->de_flags & ~(DOCEF_TAG|DOCG_BL_IV_UL|DOCEF_WORD_WRAP|
91
- DOCEF_HIGHLIGHT|DOCEF_SKIP|DOCEF_FILTER_SKIP))&&
92
- !(doc_e->type&DOCG_BL_IV_UL)) {
93
- cnt+=StrLen(doc_e->tag);
94
- if (!(doc->flags & (DOCF_PLAIN_TEXT|DOCF_PLAIN_TEXT_TABS)) ||
95
- doc->flags&DOCF_DBL_DOLLARS)
96
- cnt+=StrOcc(doc_e->tag,'$$');
97
- break;
98
- }
99
- default:
100
- st=Doc2PlainText(doc,doc_e);
101
- cnt+=StrLen(st)+2;
102
- Free(st);
103
- }
104
- }
105
- }
106
- for (b=doc->bin_head.next;b!=&doc->bin_head;b=b->next)
107
- if (b->use_cnt>b->tmp_use_cnt)
108
- cnt+=offset(CDocBin.end)-offset(CDocBin.start)+b->size;
109
- res=MAlloc(cnt);
110
- dst=res;
111
- doc_e=doc->head.next;
112
- while (doc_e!=doc) {
113
- doc_e1=doc_e->next;
114
- if (!Bt(doldoc.type_flags_data,doc_e->type_u8))
115
- switch (doc_e->type_u8) {
116
- case DOCT_CURSOR:
117
- DocEntryDel(doc,doc_e);
118
- *dst++=CH_CURSOR;
119
- break;
120
- case DOCT_TAB:
121
- *dst++='\t';
122
- break;
123
- case DOCT_NEW_LINE:
124
- if (doc->flags&DOCF_CARRIAGE_RETURN)
125
- *dst++='\r';
126
- *dst++='\n';
127
- break;
128
- case DOCT_SOFT_NEW_LINE:
129
- break;
130
- case DOCT_TEXT:
131
- if (!(doc_e->de_flags & ~(DOCEF_TAG|DOCG_BL_IV_UL|DOCEF_WORD_WRAP|
132
- DOCEF_HIGHLIGHT|DOCEF_SKIP|DOCEF_FILTER_SKIP)) &&
133
- !(doc_e->type&DOCG_BL_IV_UL)) {
134
- src=doc_e->tag;
135
- while (ch=*src++) {
136
- *dst++=ch;
137
- if (ch=='$$' && (!(doc->flags & (DOCF_PLAIN_TEXT|
138
- DOCF_PLAIN_TEXT_TABS)) || doc->flags&DOCF_DBL_DOLLARS))
139
- *dst++=ch;
140
- }
141
- break;
142
- }
143
- default:
144
- *dst++='$$';
145
- st=Doc2PlainText(doc,doc_e);
146
- StrCpy(dst,st);
147
- dst+=StrLen(st);
148
- *dst++='$$';
149
- Free(st);
150
- }
151
- doc_e=doc_e1;
152
- }
153
- *dst++=0;
154
- b=doc->bin_head.next;
155
- if (b!=&doc->bin_head) {
156
- do {
157
- if (b->use_cnt>b->tmp_use_cnt) {
158
- MemCpy(dst,&b->start,offset(CDocBin.end)-offset(CDocBin.start));
159
- dst+=offset(CDocBin.end)-offset(CDocBin.start);
160
- MemCpy(dst,b->data,b->size);
161
- dst+=b->size;
162
- }
163
- b=b->next;
164
- } while (b!=&doc->bin_head);
165
- } else
166
- cnt--; //No terminator
167
- if (_size) *_size=cnt;
168
- if (unlock)
169
- DocUnlock(doc);
170
- return res;
171
- }
172
-
173
- public Bool DocWrite(CDoc *doc,Bool prompt=FALSE)
174
- {//Store doc to disk.
175
- I64 size;
176
- U8 *buf;
177
- if (prompt && !DocForm(&doc->filename) ||
178
- doc->filename.name[0]=='A' && doc->filename.name[2]==':')
179
- return FALSE; //CANCEL || LK_DOC,LK_DOC_ANCHOR,LK_DOC_FIND,LK_DOC_LINE?
180
- buf=DocSave(doc,&size);
181
- FileWrite(doc->filename.name,buf,size,0,doc->file_attr);
182
- Free(buf);
183
- return TRUE;
184
- }
185
-
186
- #help_index "DolDoc"
187
- public U0 DocInsDoc(CDoc *doc=NULL,CDoc *doc2)
188
- {//Insert copy of doc2 into doc at insert pt, cur_entry.
189
- //TODO: $LK,"DocRst",A="MN:DocRst"$
190
- U8 *dst;
191
- Bool unlock_doc,unlock_doc2=DocLock(doc2);
192
- CDocEntry *doc_ne,*doc_e=doc2->head.next,*doc_ce;
193
- if (!doc) doc=DocPut;
194
- unlock_doc=DocLock(doc),
195
- DocRemSoftNewLines(doc,NULL);
196
- doc_ce=doc->cur_entry;
197
- if (doc_ce->type_u8==DOCT_TEXT && doc->cur_col>doc_ce->min_col) {
198
- if (doc->cur_col<doc_ce->max_col) {
199
- dst=doc_ce->tag+doc->cur_col;
200
- doc_ne=DocEntryNewTag(doc,doc_ce,dst);
201
- *dst=0;
202
- doc_ne->type=DOCT_TEXT | doc_ce->type & 0xFFFFFF00;
203
- doc_ce->max_col=doc->cur_col;
204
- QueIns(doc_ne,doc_ce);
205
- doc->cur_entry=doc_ne;
206
- doc->cur_col=doc_ne->min_col;
207
- } else
208
- if (doc_ce!=doc)
209
- doc->cur_entry=doc_ce->next;
210
- }
211
- while (doc_e!=doc2) {
212
- if (doc_e->type_u8!=DOCT_SOFT_NEW_LINE) {
213
- doc_ne=DocEntryCopy(doc,doc_e);
214
- QueIns(doc_ne,doc->cur_entry->last);
215
- }
216
- doc_e=doc_e->next;
217
- }
218
- DocRecalc(doc);
219
- if (unlock_doc2)
220
- DocUnlock(doc2);
221
- if (unlock_doc)
222
- DocUnlock(doc);
223
- }
224
-
225
- #help_index "DolDoc/Compiler;Compiler/Directive"
226
- public U0 StreamDoc(CDoc *doc)
227
- {//Inject doc into compile stream. Use inside #exe{}.
228
- //TODO: $LK,"DocRst",A="MN:DocRst"$
229
- Bool unlock_doc=DocLock(doc);
230
- CDocEntry *doc_e=doc->head.next;
231
- while (doc_e!=doc) {
232
- if (doc_e->type_u8==DOCT_TEXT)
233
- StreamPrint("%s",doc_e->tag);
234
- else if (doc_e->type_u8==DOCT_NEW_LINE)
235
- StreamPrint("\n");
236
- else if (doc_e->type_u8==DOCT_TAB)
237
- StreamPrint("\t");
238
- doc_e=doc_e->next;
239
- }
240
- if (unlock_doc)
241
- DocUnlock(doc);
242
- }
243
-
244
- #help_index "DolDoc"
245
- Bool DocCaptureUndo(CDoc *doc,Bool force=FALSE)
246
- {
247
- Bool res=FALSE,unlock;
248
- I64 time_stamp,flags;
249
- CDocUndo *u;
250
- if (doc->flags&DOCF_ALLOW_UNDO) {
251
- unlock=DocLock(doc);
252
- time_stamp=GetTSC;
253
- if (doc->flags&DOCF_UNDO_DIRTY &&
254
- time_stamp>doc->undo_head.last->time_stamp+cnts.time_stamp_freq<<4 ||
255
- force) {
256
- u=CAlloc(sizeof(CDocUndo),doc->mem_task);
257
- u->time_stamp=time_stamp;
258
- flags=doc->flags;
259
- doc->flags&=~DOCF_NO_CURSOR;
260
- u->body=DocSave(doc,&u->size);
261
- doc->flags=flags;
262
- QueIns(u,doc->undo_head.last);
263
- doc->flags&=~DOCF_UNDO_DIRTY;
264
- doc->undo_cnt++;
265
- u->doc_flags=doc->flags;
266
- res=TRUE;
267
- if (doc->flags&DOCF_AUTO_SAVE)
268
- DocWrite(doc);
269
- }
270
- if (unlock)
271
- DocUnlock(doc);
272
- }
273
- return res;
274
- }
275
-
276
- U0 DocUndoRestore(CDoc *doc)
277
- {
278
- Bool unlock=DocLock(doc);
279
- CDocUndo *u=doc->undo_head.last,*u_next,*u_last;
280
- if (u!=&doc->undo_head) {
281
- QueRem(u);
282
- u_next=doc->undo_head.next;
283
- u_last=doc->undo_head.last;
284
- QueInit(&doc->undo_head);
285
- DocRst(doc,TRUE);
286
- doc->flags=u->doc_flags&~DOCF_NO_CURSOR;
287
- DocLoad(doc,u->body,u->size);
288
- doc->flags=u->doc_flags;
289
- DocUndoDel(doc,u);
290
- doc->undo_head.next=u_next;
291
- doc->undo_head.last=u_last;
292
- }
293
- DocUndoCntSet(doc);
294
- doc->flags&=~DOCF_UNDO_DIRTY;
295
- if (unlock)
296
- DocUnlock(doc);
297
- }
298
-
299
- #help_index "Graphics/GR Files;DolDoc/Output;StdOut/DolDoc"
300
- public Bool DocType(CDoc *doc=NULL,U8 *filename,I64 trailing_new_lines=1)
301
- {//Output txt or graphic file to document.
302
- Bool res=FALSE;
303
- CDoc *doc2;
304
- if (!doc && !(doc=DocPut) || doc->doc_signature!=DOC_SIGNATURE_VAL)
305
- return FALSE;
306
- if (FilesFindMatch(filename,FILEMASK_TXT)) {
307
- doc2=DocRead(filename);
308
- DocInsDoc(doc,doc2);
309
- if (IsRaw)
310
- DocDump(doc2,100000);
311
- DocDel(doc2);
312
- res=TRUE;
313
- } else if (FilesFindMatch(filename,"*.GR*")) {
314
- DocGR(doc,filename);
315
- res=TRUE;
316
- }
317
- if (res)
318
- DocPrint(doc,"%h*c",trailing_new_lines,'\n');
319
- return res;
320
- }
321
-
322
- #help_index "Graphics/GR Files;"\
323
- "File/Cmd Line (Typically);DolDoc/Cmd Line (Typically);"\
324
- "StdOut;Cmd Line (Typically)"
325
- public Bool Type(U8 *filename,I64 trailing_new_lines=1)
326
- {//Output txt or graphic file to command line.
327
- return DocType(,filename,trailing_new_lines);
328
- }
329
-
330
- #help_index "DolDoc/File"
331
-
332
- public U8 *DocLineRead(U8 *filename,I64 line,CTask *mem_task=NULL)
333
- {//Extract line from stored doc file. (Slow.)
334
- U8 *res=NULL;
335
- CDoc *doc=DocRead(filename,DOCF_PLAIN_TEXT_TABS|DOCF_NO_CURSOR);
336
- if (DocGoToLine(doc,line) && doc->cur_entry->type_u8==DOCT_TEXT)
337
- res=StrNew(doc->cur_entry->tag,mem_task);
338
- DocDel(doc);
339
- return res;
340
- }
341
-
342
- public U8 *DocLineWrite(U8 *filename,I64 line,U8 *st)
343
- {//Write line to stored doc file. (Slow.)
344
- U8 *res=NULL;
345
- CDoc *doc=DocRead(filename,DOCF_PLAIN_TEXT_TABS|DOCF_NO_CURSOR);
346
- if (DocGoToLine(doc,line)) {
347
- if (doc->cur_entry->type_u8==DOCT_TEXT) {
348
- Free(doc->cur_entry->tag);
349
- doc->cur_entry->tag=StrNew(st);
350
- } else
351
- DocPrint(doc,"%s",st);
352
- DocTop(doc);
353
- DocWrite(doc);
354
- }
355
- DocDel(doc);
356
- return res;
357
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:2a002427c34d07b09077dc82a811029473e9c6ab8114a2e87793d7fbc6c92580
3
+ size 9639
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/DolDoc/DocFind.HC CHANGED
@@ -1,584 +1,3 @@
1
- #help_index "DolDoc/Editor"
2
-
3
- public Bool DocGoToLine(CDoc *doc,I64 line_num) //one based
4
- {//Nearest to specified line num. Move cur_entry & center.
5
- Bool res=FALSE,unlock;
6
- if (doc) {
7
- unlock=DocLock(doc);
8
- doc->x=0;
9
- doc->y=line_num-1;
10
- DocRecalc(doc,RECALCt_FIND_CURSOR);
11
- DocCenter(doc);
12
- if (doc->cur_entry->y==line_num-1)
13
- res=TRUE;
14
- if (unlock)
15
- DocUnlock(doc);
16
- }
17
- return res;
18
- }
19
-
20
- public Bool DocFind(CDoc *haystack_doc,I64 start_line_num=I64_MIN,
21
- U8 *needle,I64 match=1)
22
- {//Find str by searching tags. Move cur_entry & center.
23
- Bool res=FALSE,unlock;
24
- CDocEntry *doc_e;
25
- U8 *ptr;
26
- I64 i;
27
- if (haystack_doc) {
28
- unlock=DocLock(haystack_doc);
29
- if (start_line_num==I64_MIN) {
30
- res=TRUE;
31
- doc_e=haystack_doc->head.next;
32
- } else {
33
- res=DocGoToLine(haystack_doc,start_line_num);
34
- doc_e=haystack_doc->cur_entry;
35
- }
36
- if (res) {
37
- if (needle) {
38
- res=FALSE;
39
- while (doc_e!=haystack_doc) {
40
- if (doc_e->de_flags&DOCEF_TAG && doc_e->tag &&
41
- //TODO: handle multi-DocEntry strs
42
- (ptr=StrIMatch(needle,doc_e->tag))) {
43
- i=ptr-doc_e->tag;
44
- if (!--match) {
45
- haystack_doc->cur_entry=doc_e;
46
- if (i<doc_e->min_col) i=doc_e->min_col;
47
- if (i>doc_e->max_col) i=doc_e->max_col;
48
- haystack_doc->cur_col=i;
49
- res=TRUE;
50
- break;
51
- }
52
- }
53
- doc_e=doc_e->next;
54
- }
55
- } else
56
- res=FALSE;
57
- }
58
- if (!res) DocBottom(haystack_doc);
59
- DocCenter(haystack_doc);
60
- if (unlock)
61
- DocUnlock(haystack_doc);
62
- }
63
- return res;
64
- }
65
-
66
- public Bool DocAnchorFind(CDoc *haystack_doc,U8 *needle_str)
67
- {//Find named anchor. Move cur_entry & center.
68
- Bool res=FALSE,unlock;
69
- CDocEntry *doc_e;
70
- if (haystack_doc) {
71
- unlock=DocLock(haystack_doc);
72
- doc_e=haystack_doc->head.next;
73
- if (needle_str)
74
- while (doc_e!=haystack_doc) {
75
- if (doc_e->type_u8==DOCT_ANCHOR && doc_e->de_flags & DOCEF_AUX_STR) {
76
- if (!StrCmp(needle_str,doc_e->aux_str)) {
77
- haystack_doc->cur_entry=doc_e;
78
- haystack_doc->cur_col=doc_e->min_col;
79
- res=TRUE;
80
- break;
81
- }
82
- }
83
- doc_e=doc_e->next;
84
- }
85
- if (!res) DocBottom(haystack_doc);
86
- DocCenter(haystack_doc);
87
- if (unlock)
88
- DocUnlock(haystack_doc);
89
- }
90
- return res;
91
- }
92
-
93
- public U0 EdFindNext(CDoc *doc)
94
- {//Editor F3 find next, possibly doing replaces.
95
- Bool unlock=DocLock(doc);
96
- U8 *ptr,*ptr2,*ptr3;
97
- CDocEntry *doc_ce=doc->cur_entry,*doc_e=doc_ce;
98
- I64 sf_flags;
99
- if (doc->find_replace->match_case)
100
- sf_flags=0;
101
- else
102
- sf_flags=SFF_IGNORE_CASE;
103
- if (doc->find_replace->whole_labels)
104
- sf_flags|=SFG_WHOLE_LABELS;
105
- do {
106
- if (doc_e!=doc) {
107
- if (doc_e->de_flags&DOCEF_TAG && doc_e->tag &&
108
- !(doc_e->de_flags&(DOCEG_DONT_EDIT|DOCEF_FILTER_SKIP))) {
109
- if (doc_e->type & DOCET_SEL ||
110
- !doc->find_replace->scan_sel_text) {
111
- if (doc->find_replace->scan_fwd) {
112
- if (doc_e==doc_ce) {
113
- ptr=doc_ce->tag+doc->cur_col+1;
114
- if (ptr-doc_ce->tag>=doc_ce->max_col)
115
- goto fn_skip;
116
- if (ptr-doc_ce->tag<doc_ce->min_col)
117
- ptr=doc_ce->tag+doc_ce->min_col;
118
- } else
119
- ptr=doc_e->tag;
120
- if (ptr=StrFind(doc->find_replace->find_text,ptr,sf_flags)) {
121
- doc->cur_entry=doc_e;
122
- doc->cur_col=ptr-doc_e->tag;
123
- if (doc->cur_col>=doc_e->max_col)
124
- doc->cur_col=doc_e->max_col-1;
125
- if (doc->cur_col<doc_e->min_col)
126
- doc->cur_col=doc_e->min_col;
127
- DocCenter(doc);
128
- if (unlock)
129
- DocUnlock(doc);
130
- return;
131
- }
132
- } else {
133
- ptr2=NULL;
134
- ptr=doc_e->tag+doc_e->min_col;
135
- if (doc_e==doc_ce)
136
- ptr3=doc_ce->tag+doc->cur_col;
137
- else
138
- ptr3=doc_e->tag+doc_e->max_col;
139
- while (ptr=StrFind(doc->find_replace->find_text,ptr,sf_flags)) {
140
- if (ptr>=ptr3)
141
- break;
142
- ptr2=ptr++;
143
- }
144
- if (ptr2 && ptr2<ptr3) {
145
- doc->cur_entry=doc_e;
146
- doc->cur_col=ptr2-doc_e->tag;
147
- if (doc->cur_col>=doc_e->max_col)
148
- doc->cur_col=doc_e->max_col-1;
149
- if (doc->cur_col<doc_e->min_col)
150
- doc->cur_col=doc_e->min_col;
151
- DocCenter(doc);
152
- if (unlock)
153
- DocUnlock(doc);
154
- return;
155
- }
156
- }
157
- }
158
- }
159
- }
160
- fn_skip:
161
- if (doc->find_replace->scan_fwd)
162
- doc_e=doc_e->next;
163
- else
164
- doc_e=doc_e->last;
165
- } while (doc_e!=doc_ce);
166
- if (unlock)
167
- DocUnlock(doc);
168
- }
169
-
170
- public U0 EdSelAll(CDoc *doc,Bool sel)
171
- {//Set state of $LK,"DOCET_SEL",A="MN:DOCET_SEL"$ on all entries.
172
- Bool unlock=DocLock(doc);
173
- CDocEntry *doc_e=doc->head.next;
174
- while (doc_e!=doc) {
175
- BEqu(&doc_e->type,DOCEt_SEL,sel);
176
- doc_e=doc_e->next;
177
- }
178
- if (unlock)
179
- DocUnlock(doc);
180
- }
181
-
182
- public Bool EdFindPaired(CDoc *doc,U8 plus,U8 minus,
183
- Bool fwd,Bool abort_on_dbl_colon=FALSE)
184
- {//Find { } or ( ) pair. Move cur_entry & center.
185
- Bool unlock=DocLock(doc),res=FALSE;
186
- U8 *ptr;
187
- I64 ch,levels=0,colons=0,original_col=doc->cur_col;
188
- CDocEntry *doc_ce=doc->cur_entry,*doc_e=doc_ce,*original_ce=doc_ce;
189
- if (abort_on_dbl_colon && EdCurU8(doc)==':')
190
- colons=1;
191
- else
192
- colons=0;
193
- do {
194
- if (doc_e!=doc) {
195
- if (doc_e->de_flags&DOCEF_TAG && doc_e->tag &&
196
- !(doc_e->de_flags&DOCEF_FILTER_SKIP)) {
197
- if (fwd) {
198
- if (doc_e==doc_ce)
199
- ptr=doc_e->tag+doc->cur_col+1;
200
- else
201
- ptr=doc_e->tag;
202
- if (ptr-doc_e->tag<doc_e->min_col)
203
- ptr=doc_e->tag+doc_e->min_col;
204
- if (ptr-doc_e->tag>=doc_e->max_col)
205
- goto pa_skip;
206
- while (ch=*ptr++)
207
- if (abort_on_dbl_colon && ch==':') {
208
- if (++colons==2) {
209
- doc->cur_entry=doc_e;
210
- doc->cur_col=ptr-doc_e->tag-1;
211
- EdCursorLeft(doc);
212
- res=FALSE;
213
- goto pa_done;
214
- }
215
- } else {
216
- colons=0;
217
- if (ch==plus)
218
- levels++;
219
- else if (ch==minus) {
220
- if (!levels--) {
221
- doc->cur_entry=doc_e;
222
- doc->cur_col=ptr-doc_e->tag-1;
223
- res=doc->cur_entry!=original_ce ||
224
- doc->cur_col!=original_col;
225
- goto pa_done;
226
- }
227
- }
228
- }
229
- } else {
230
- if (doc_e==doc_ce) {
231
- ptr=doc_e->tag+doc->cur_col-1;
232
- if (ptr-doc_e->tag>=doc_e->max_col)
233
- ptr=doc_e->tag+doc_e->max_col-1;
234
- } else
235
- ptr=doc_e->tag+doc_e->max_col-1;
236
- if (ptr-doc_e->tag<doc_e->min_col)
237
- goto pa_skip;
238
- while (ptr>=doc_e->tag+doc_e->min_col) {
239
- ch=*ptr--;
240
- if (abort_on_dbl_colon && ch==':') {
241
- if (++colons==2) {
242
- doc->cur_entry=doc_e;
243
- doc->cur_col=ptr-doc_e->tag+1;
244
- res=FALSE;
245
- goto pa_done;
246
- }
247
- } else {
248
- colons=0;
249
- if (ch==plus)
250
- levels++;
251
- else if (ch==minus) {
252
- if (!levels--) {
253
- doc->cur_entry=doc_e;
254
- doc->cur_col=ptr-doc_e->tag+1;
255
- res=doc->cur_entry!=original_ce ||
256
- doc->cur_col!=original_col;
257
- goto pa_done;
258
- }
259
- }
260
- }
261
- }
262
- }
263
- }
264
- }
265
- pa_skip:
266
- if (fwd)
267
- doc_e=doc_e->next;
268
- else
269
- doc_e=doc_e->last;
270
- } while (doc_e!=doc_ce);
271
- pa_done:
272
- DocRecalc(doc);
273
- DocCenter(doc);
274
- if (unlock)
275
- DocUnlock(doc);
276
- return res;
277
- }
278
-
279
- public Bool EdGoToFun(CDoc *doc,Bool fwd,Bool abort_on_dbl_colon)
280
- {//Move cur_entry to start of cur fun and center.(Shoddy)
281
- Bool unlock=DocLock(doc),res=FALSE;
282
- I64 ch,levels,colons;
283
- if (fwd) {
284
- levels=0;
285
- colons=0;
286
- while (doc->cur_entry!=doc) {
287
- ch=EdCurU8(doc);
288
- if (abort_on_dbl_colon && ch==':') {
289
- if (++colons==2) {
290
- EdCursorLeft(doc);
291
- break;
292
- }
293
- } else {
294
- colons=0;
295
- if (ch=='{')
296
- levels++;
297
- else if (ch=='}' && !levels--)
298
- break;
299
- }
300
- EdCursorRight(doc);
301
- }
302
- DocRecalc(doc);
303
- if (doc->cur_entry!=doc)
304
- res=TRUE;
305
- } else {
306
- while (EdFindPaired(doc,'}','{',FALSE,abort_on_dbl_colon));
307
- if (doc->cur_entry!=doc) {
308
- ch=EdCurU8(doc);
309
- if (abort_on_dbl_colon && ch==':')
310
- res=TRUE;
311
- else {
312
- if (ch=='{')
313
- res=TRUE;
314
- }
315
- }
316
- }
317
- if (unlock)
318
- DocUnlock(doc);
319
- return res;
320
- }
321
-
322
- public U0 EdSelFun(CDoc *doc,Bool abort_on_dbl_colon=FALSE)
323
- {//Set $LK,"DOCET_SEL",A="MN:DOCET_SEL"$ on all entries in cur fun.
324
- Bool unlock=DocLock(doc);
325
- U8 *ptr;
326
- I64 ch,levels=0,colons=0;
327
- CDocEntry *doc_e;
328
- EdSelAll(doc,FALSE);
329
- EdGoToFun(doc,FALSE,abort_on_dbl_colon);
330
- if (EdCurU8(doc)=='{')
331
- levels--;
332
- else if (abort_on_dbl_colon && EdCurU8(doc)==':') {
333
- EdCursorRight(doc);
334
- if (EdCurU8(doc)==':')
335
- EdCursorRight(doc);
336
- }
337
- doc_e=doc->cur_entry;
338
- while (doc_e!=doc) {
339
- doc_e->type|=DOCET_SEL;
340
- if (doc_e->de_flags&DOCEF_TAG && doc_e->tag) {
341
- ptr=doc_e->tag;
342
- if (doc_e==doc->cur_entry)
343
- ptr+=doc->cur_col;
344
- while (ch=*ptr++)
345
- if (abort_on_dbl_colon && ch==':') {
346
- if (++colons==2)
347
- goto sf_done;
348
- } else {
349
- colons=0;
350
- if (ch=='{')
351
- levels++;
352
- else if (ch=='}' && !levels--)
353
- goto sf_done;
354
- }
355
- }
356
- doc_e=doc_e->next;
357
- }
358
- sf_done:
359
- DocRecalc(doc);
360
- if (unlock)
361
- DocUnlock(doc);
362
- }
363
-
364
- #define RSAC_REPLACE 0
365
- #define RSAC_SKIP 1
366
- #define RSAC_ALL 2
367
-
368
- I64 PopUpReplaceSkipAllCancel(U8 *header=NULL,U8 *footer=NULL)
369
- {
370
- I64 i;
371
- CDoc *doc=DocNew;
372
- if (header) DocPrint(doc,"%s",header);
373
- DocPrint(doc,"$$CM+LX,1,4$$$$BT,\"REPLACE\",LE=RSAC_REPLACE$$"
374
- "$$CM+LX,17,0$$$$BT,\"SKIP\",LE=RSAC_SKIP$$"
375
- "$$CM+LX,1,3$$$$BT,\"ALL\",LE=RSAC_ALL$$"
376
- "$$CM+LX,17,0$$$$BT,\"CANCEL\",LE=DOCM_CANCEL$$\n");
377
- if (footer) DocPrint(doc,"%s",footer);
378
- i=PopUpMenu(doc);
379
- DocDel(doc);
380
- return i;
381
- }
382
-
383
- I64 EdFindReplace(CDoc *doc)
384
- {
385
- Bool found,unlock;
386
- I64 cmd,i,j,plen,rlen,dlen,res=-1,sf_flags;
387
- U8 *src,*dst,*dst2;
388
- CDocEntry *doc_ce,*doc_e,*doc_marker=NULL;
389
- if (doc->find_replace->pmt)
390
- cmd=RSAC_REPLACE;
391
- else
392
- cmd=RSAC_ALL;
393
- if (!doc->find_replace->pmt || DocForm(doc->find_replace)) {
394
- res=0;
395
- unlock=DocLock(doc);
396
- if (doc->find_replace->match_case || doc->find_replace->local_var)
397
- sf_flags=0;
398
- else
399
- sf_flags=SFF_IGNORE_CASE;
400
- if (doc->find_replace->whole_labels || doc->find_replace->local_var)
401
- sf_flags|=SFG_WHOLE_LABELS;
402
-
403
- if (i=doc->find_replace->filter_lines) {
404
- doc_ce=doc->head.next;
405
- while (doc_ce!=doc) {
406
- if (doc_ce->de_flags&DOCEF_TAG && doc_ce->tag &&
407
- !(doc_ce->de_flags&DOCEF_FILTER_SKIP) &&
408
- StrFind(doc->find_replace->find_text,doc_ce->tag,sf_flags)) {
409
- doc_ce->type|=DOCET_SEL;
410
- res++;
411
- } else
412
- doc_ce->type&=~DOCET_SEL;
413
- doc_ce=doc_ce->next;
414
- }
415
-
416
- doc_ce=doc->head.next;
417
- while (doc_ce!=doc) {
418
- if (!(doc_ce->de_flags&DOCEF_FILTER_SKIP)) {
419
- found=FALSE;
420
-
421
- doc_e=doc_ce;
422
- while (doc_e!=doc && doc_e->y>doc_ce->y-i) {
423
- if (doc_e->type&DOCET_SEL) {
424
- found=TRUE;
425
- break;
426
- } else
427
- doc_e=doc_e->last;
428
- }
429
-
430
- if (!found) {
431
- doc_e=doc_ce;
432
- while (doc_e!=doc && doc_e->y<doc_ce->y+i) {
433
- if (doc_e->type&DOCET_SEL) {
434
- found=TRUE;
435
- break;
436
- } else
437
- doc_e=doc_e->next;
438
- }
439
- }
440
-
441
- if (!found)
442
- doc_ce->de_flags|=DOCEF_FILTER_SKIP;
443
- }
444
-
445
- doc_ce=doc_ce->next;
446
- }
447
- EdSelAll(doc,FALSE);
448
- goto fr_unlock_done;
449
- }
450
-
451
- if (doc->find_replace->local_var)
452
- EdSelFun(doc);
453
-
454
- if (!doc->find_replace->replace && !doc->find_replace->local_var) {
455
- EdFindNext(doc);
456
- goto fr_unlock_done;
457
- }
458
- plen=StrLen(doc->find_replace->find_text);
459
- if (!plen)
460
- goto fr_unlock_done;
461
- rlen=StrLen(doc->find_replace->replace_text);
462
- if (doc->head.next!=doc) {
463
- doc_e=doc_marker=DocSplitTag(doc,doc->cur_entry,doc->cur_col,
464
- doc->cur_entry->x+doc->cur_col,doc->cur_entry->y,DOCT_MARKER);
465
- do {
466
- if (doc_e==doc) {
467
- if (doc->find_replace->scan_fwd)
468
- doc_e=doc_e->next;
469
- else
470
- doc_e=doc_e->last;
471
- if (doc_e==doc_marker)
472
- break;
473
- }
474
- if (doc_e->type_u8==DOCT_TEXT &&
475
- !(doc_e->de_flags&(DOCEG_DONT_EDIT|DOCEF_FILTER_SKIP)) &&
476
- (doc_e->type & DOCET_SEL ||
477
- !doc->find_replace->scan_sel_text&&
478
- !doc->find_replace->local_var)) {
479
- src=doc_e->tag;
480
- while (src) {
481
- src=StrFind(doc->find_replace->find_text,src,sf_flags);
482
- if (src) {
483
- doc->cur_col=src-doc_e->tag;
484
- doc->cur_entry=doc_e;
485
- if (cmd!=RSAC_ALL)
486
- DocCenter(doc);
487
- if (cmd!=RSAC_ALL) {
488
- DocUnlock(doc);
489
- cmd=PopUpReplaceSkipAllCancel("");
490
- DocLock(doc);
491
- if (cmd<0)
492
- goto fr_unlock_done;
493
- }
494
- doc_e=doc->cur_entry;
495
- src=doc->cur_col+doc_e->tag;
496
- if (cmd==RSAC_REPLACE || cmd==RSAC_ALL) {
497
- dlen=StrLen(doc_e->tag);
498
- doc_e->max_col=dlen+rlen-plen;
499
- dst=MAlloc(doc_e->max_col+1,doc->mem_task);
500
- dst2=dst;
501
- j=src-doc_e->tag;
502
- for (i=0;i<j;i++)
503
- *dst++=doc_e->tag[i];
504
- for (i=0;i<rlen;i++)
505
- *dst++=doc->find_replace->replace_text[i];
506
- src=dst;
507
- for (i=j+plen;i<=dlen;i++)
508
- *dst++=doc_e->tag[i];
509
- Free(doc_e->tag);
510
- doc_e->tag=dst2;
511
- doc->cur_col=src-doc_e->tag;
512
- doc->cur_entry=doc_e;
513
- if (cmd!=RSAC_ALL) {
514
- DocRemSoftNewLines(doc,doc->cur_entry);
515
- DocRecalc(doc);
516
- }
517
- doc_e=doc->cur_entry;
518
- src=doc->cur_col+doc_e->tag;
519
- res++;
520
- } else
521
- src++;
522
- }
523
- }
524
- }
525
- if (doc->find_replace->scan_fwd)
526
- doc_e=doc_e->next;
527
- else
528
- doc_e=doc_e->last;
529
- } while (doc_e!=doc_marker);
530
- }
531
- fr_unlock_done:
532
- if (doc_marker)
533
- DocEntryDel(doc,doc_marker);
534
- DocRemSoftNewLines(doc,NULL);
535
- DocRecalc(doc);
536
- DocCenter(doc);
537
- if (unlock)
538
- DocUnlock(doc);
539
- }
540
- return res;
541
- }
542
-
543
- public I64 EdReplace(CDoc *doc,U8 *find,U8 *replace,
544
- Bool sel=TRUE,Bool match_case=TRUE,Bool whole_labels=FALSE)
545
- {//Find & replace using editor's cmd.
546
- CEdFindText old_find_replace;
547
- Bool unlock;
548
- I64 i,res=-1;
549
- if (!doc) return -1;
550
- unlock=DocLock(doc);
551
- MemCpy(&old_find_replace,doc->find_replace,sizeof(CEdFindText));
552
- MemSet(doc->find_replace,0,sizeof(CEdFindText));
553
- i=StrLen(find);
554
- if (i<sizeof(CEdFindText.find_text)) {
555
- MemCpy(doc->find_replace->find_text,find,i+1);
556
- i=StrLen(replace);
557
- if (i<sizeof(CEdFindText.replace_text)) {
558
- MemCpy(doc->find_replace->replace_text,replace,i+1);
559
- doc->find_replace->replace=TRUE;
560
- doc->find_replace->scan_sel_text=sel;
561
- doc->find_replace->match_case=match_case;
562
- doc->find_replace->whole_labels=whole_labels;
563
- doc->find_replace->pmt=FALSE;
564
- res=EdFindReplace(doc);
565
- }
566
- }
567
- MemCpy(doc->find_replace,&old_find_replace,sizeof(CEdFindText));
568
- if (unlock)
569
- DocUnlock(doc);
570
- return res;
571
- }
572
-
573
- class CEdLineGoTo
574
- {
575
- I64 line format "$$DA,A=\"Go to Line:%d\"$$";
576
- };
577
-
578
- U0 EdGoToLine(CDoc *doc)
579
- {//Prompt with form and go to line num.
580
- CEdLineGoTo gtl;
581
- gtl.line=1;
582
- if (DocForm(&gtl))
583
- DocGoToLine(doc,gtl.line);
584
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:157922eb3bc8cd67ce5d10dc96ff6a3d1668bf91612ae24cdd6a0b4613ecabcc
3
+ size 14219
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/DolDoc/DocForm.HC CHANGED
@@ -1,344 +1,3 @@
1
- #help_index "DolDoc/Form"
2
-
3
- U0 DocFormFwd(CDoc *doc,Bool giveup=FALSE)
4
- {
5
- CDocEntry *doc_e=doc->cur_entry,*doc_e2=doc_e;
6
- if (doc->flags & DOCF_FORM) {
7
- if (doc_e==doc) goto ff_recover;
8
- while (!Bt(doldoc.type_flags_form,doc_e->type_u8) &&
9
- !(doc_e->de_flags&DOCEF_LINK) ||
10
- doc_e->de_flags&DOCEF_SKIP_IN_FORM) {
11
- doc_e=doc_e->next;
12
- if (doc_e==doc) {
13
- ff_recover:
14
- doc->cur_col=0;
15
- if (!giveup) {
16
- doc->cur_entry=doc_e->last;
17
- DocFormBwd(doc,TRUE);
18
- } else
19
- doc->cur_entry=doc;
20
- return;
21
- }
22
- }
23
- }
24
- while (doc_e->type_u8==DOCT_INDENT)
25
- doc_e=doc_e->next;
26
- if (doc_e!=doc_e2) {
27
- doc->cur_col=doc_e->min_col;
28
- doc->cur_entry=doc_e;
29
- }
30
- }
31
-
32
- U0 DocFormBwd(CDoc *doc,Bool giveup=FALSE)
33
- {
34
- CDocEntry *doc_e=doc->cur_entry,*doc_e2=doc_e;
35
- if (doc->flags & DOCF_FORM) {
36
- while (!Bt(doldoc.type_flags_form,doc_e->type_u8) &&
37
- !(doc_e->de_flags&DOCEF_LINK) ||
38
- doc_e->de_flags&DOCEF_SKIP_IN_FORM) {
39
- doc_e=doc_e->last;
40
- if (doc_e==doc) {
41
- doc->cur_col=0;
42
- if (!giveup) {
43
- doc->cur_entry=doc_e->next;
44
- DocFormFwd(doc,TRUE);
45
- } else
46
- doc->cur_entry=doc;
47
- return;
48
- }
49
- }
50
- }
51
- while (doc_e->type_u8==DOCT_INDENT)
52
- doc_e=doc_e->next;
53
- if (doc_e!=doc_e2) {
54
- doc->cur_col=doc_e->min_col;
55
- doc->cur_entry=doc_e;
56
- }
57
- }
58
-
59
- U0 DocDataFmt(CDoc *doc,CDocEntry *doc_e,I64 d=DOCM_CANCEL)
60
- {
61
- I64 i;
62
- U8 *ptr,*ptr2;
63
- CHashDefineStr *tmph;
64
- if (doc_e->type_u8==DOCT_DATA && doc_e->de_flags&DOCEF_AUX_STR ||
65
- doc_e->type_u8==DOCT_CHECK_BOX || doc_e->de_flags & DOCEF_LST) {
66
- if (d==DOCM_CANCEL) {
67
- if (doc_e->de_flags&DOCEF_DEREF_DATA &&
68
- !(doc_e->de_flags&DOCEF_REMALLOC_DATA)) {
69
- if (!(ptr=doc_e->data)) return;
70
- } else
71
- ptr=&doc_e->data;
72
- switch (doc_e->raw_type) {
73
- case RT_I0:
74
- case RT_U0: d=0; break;
75
- case RT_I8: d=*ptr(I8 *); break;
76
- case RT_U8: d=*ptr(U8 *); break;
77
- case RT_I16: d=*ptr(I16 *); break;
78
- case RT_U16: d=*ptr(U16 *); break;
79
- case RT_I32: d=*ptr(I32 *); break;
80
- case RT_U32: d=*ptr(U32 *); break;
81
- default: d=*ptr(I64 *);
82
- }
83
- }
84
- if (doc_e->type_u8==DOCT_DATA) {
85
- if (doc_e->de_flags & DOCEF_REMALLOC_DATA) {
86
- ptr=MStrPrint(doc_e->aux_str,d,doc_e->my_fmt_data);
87
- i=StrLen(ptr);
88
- if (!doc_e->data) {
89
- doc_e->data=CAlloc(2,doc->mem_task);
90
- doc_e->len=MSize(doc_e->data)-2;
91
- }
92
- if (doc_e->len+doc_e->min_col>i)
93
- MemCpy(doc_e->tag,ptr,i+1);
94
- else {
95
- ptr2=MAlloc(i+8,doc->mem_task);
96
- doc_e->len=MSize(ptr2)-doc_e->min_col-2; //See $LK,"DataTagWidth",A="FA:::/Adam/DolDoc/DocPlain.HC,DataTagWidth"$
97
- MemCpy(ptr2,ptr,i+1);
98
- Free(doc_e->tag);
99
- doc_e->tag=ptr2;
100
- }
101
- Free(ptr);
102
- } else {
103
- StrPrint(doc_e->tag,doc_e->aux_str,d,doc_e->my_fmt_data);
104
- i=StrLen(doc_e->tag);
105
- }
106
- if (doc_e->de_flags & DOCEF_HAS_TERMINATOR) {
107
- doc_e->tag[i++]='_';
108
- doc_e->tag[i]=0;
109
- }
110
- doc_e->max_col=i;
111
- } else if (doc_e->de_flags & DOCEF_LST) {
112
- if (doc_e->de_flags & DOCEF_DEFINE && (tmph=HashFind(doc_e->define_str,
113
- doc->win_task->hash_table,HTT_DEFINE_STR)) && 0<=d<tmph->cnt) {
114
- ptr=MStrPrint("[%s]",tmph->sub_idx[d]);
115
- Free(doc_e->tag);
116
- doc_e->tag=StrNew(ptr,doc->mem_task);
117
- Free(ptr);
118
- } else {
119
- Free(doc_e->tag);
120
- doc_e->tag=StrNew("[]",doc->mem_task);
121
- }
122
- } else {
123
- if (d)
124
- doc_e->de_flags|=DOCEF_CHECKED_COLLAPSED;
125
- else
126
- doc_e->de_flags&=~DOCEF_CHECKED_COLLAPSED;
127
- }
128
- }
129
- }
130
-
131
- U0 DocDataScan(CDoc *doc,CDocEntry *doc_e)
132
- {
133
- I64 i,d;
134
- U8 *ptr,*ptr1,*ptr2;
135
- CHashDefineStr *tmph;
136
- if (doc_e->type_u8==DOCT_DATA && doc_e->de_flags&DOCEF_AUX_STR ||
137
- doc_e->type_u8==DOCT_CHECK_BOX || doc_e->de_flags & DOCEF_LST) {
138
- if (doc_e->de_flags&DOCEF_DEREF_DATA &&
139
- !(doc_e->de_flags&DOCEF_REMALLOC_DATA)) {
140
- if (!(ptr=doc_e->data)) return;
141
- } else
142
- ptr=&doc_e->data;
143
- if (doc_e->type_u8==DOCT_DATA) {
144
- i=StrLen(doc_e->tag);
145
- if (doc_e->de_flags & DOCEF_HAS_TERMINATOR)
146
- doc_e->tag[--i]=0;
147
- if (i>doc_e->len+doc_e->min_col)
148
- doc_e->tag[doc_e->len+doc_e->min_col]=0;
149
- if (RT_I8<=doc_e->raw_type<=RT_U32) {
150
- StrScan(doc_e->tag,doc_e->aux_str,&d,doc_e->my_fmt_data);
151
- if (doc_e->de_flags & DOCEF_HAS_TERMINATOR)
152
- doc_e->tag[i]='_';
153
- } else if (RT_I64<=doc_e->raw_type<=RT_UF64) {
154
- if (doc_e->de_flags & DOCEF_REMALLOC_DATA) {
155
- ptr=MAlloc(i-doc_e->min_col+8,doc->mem_task);
156
- MemCpy(ptr,doc_e->tag+doc_e->min_col,i-doc_e->min_col+1);
157
- Free(doc_e->data);
158
- doc_e->data=ptr;
159
- doc_e->len=MSize(ptr)-1;
160
- } else
161
- StrScan(doc_e->tag,doc_e->aux_str,ptr,doc_e->my_fmt_data);
162
- if (doc_e->de_flags & DOCEF_HAS_TERMINATOR)
163
- doc_e->tag[i]='_';
164
- return;
165
- }
166
- } else if (doc_e->de_flags & DOCEF_LST) {
167
- d=0;
168
- if (doc_e->tag && doc_e->de_flags & DOCEF_DEFINE &&
169
- (tmph=HashFind(doc_e->define_str,
170
- doc->win_task->hash_table,HTT_DEFINE_STR))) {
171
- ptr1=ptr2=StrNew(doc_e->tag);
172
- if (*ptr2=='[') {
173
- ptr2++;
174
- i=StrLen(ptr2);
175
- if (ptr2[i-1]==']')
176
- ptr2[i-1]=0;
177
- }
178
- d=LstMatch(ptr2,tmph->data);
179
- Free(ptr1);
180
- }
181
- } else {
182
- if (doc_e->de_flags & DOCEF_CHECKED_COLLAPSED)
183
- d=TRUE;
184
- else
185
- d=FALSE;
186
- }
187
- switch (doc_e->raw_type) {
188
- case RT_I8:
189
- case RT_U8:
190
- *ptr(U8 *)=d;
191
- case RT_I0:
192
- case RT_U0:
193
- break;
194
- case RT_I16:
195
- case RT_U16:
196
- *ptr(U16 *)=d;
197
- break;
198
- case RT_I32:
199
- case RT_U32:
200
- *ptr(U32 *)=d;
201
- break;
202
- default:
203
- *ptr(I64 *)=d;
204
- }
205
- }
206
- }
207
-
208
- #help_index "DolDoc/Input;StdIn/DolDoc"
209
- public Bool DocForm(U8 *_d,U8 *class_name=lastclass,
210
- I64 dof_flags=0,U8 *header=NULL,U8 *footer=NULL)
211
- {//User input. Supply a class name that has format definitions.
212
- //See $LK,"::/Demo/DolDoc/Form.HC"$ and $LK,"::/Demo/LastClass.HC"$.
213
- CMemberLst *ml;
214
- CDocEntry *doc_e;
215
- U8 *format;
216
- CHashClass *tmpc,*tmpc2;
217
- CDoc *doc;
218
- Bool res=FALSE;
219
- I64 old_border_src=Fs->border_src,has_action;
220
- if (!(tmpc=HashFind(class_name,Fs->hash_table,HTT_CLASS)))
221
- return FALSE;
222
- doc=DocNew;
223
- doc->desc='Form';
224
- if (header) DocPrint(doc,"%s",header);
225
- doc->flags|=DOCF_OVERSTRIKE|DOCF_FORM;
226
- if (dof_flags&DOF_SIZE_MIN)
227
- doc->flags|=DOCF_SIZE_MIN;
228
- ml=tmpc->member_lst_and_root;
229
- while (ml) {
230
- if ((format=MemberMetaData("format",ml)) &&
231
- (doc_e=DocPrint(doc,"%s",format))) {
232
- tmpc2=ml->member_class;
233
- if ((doc_e->type_u8==DOCT_DATA || doc_e->type_u8==DOCT_LST ||
234
- doc_e->type_u8==DOCT_CHECK_BOX) && !tmpc2->ptr_stars_cnt) {
235
- tmpc2=OptClassFwd(tmpc2);
236
- tmpc2-=tmpc2->ptr_stars_cnt;
237
- if (tmpc2->type & HTT_INTERNAL_TYPE) {
238
- if (ml->dim.next) { //Array
239
- if (tmpc2->raw_type==RT_U8 &&
240
- LBtr(&doc_e->de_flags,&DOCEf_DFT_LEN)) {
241
- doc_e->len=ml->dim.total_cnt;
242
- if (doc_e->de_flags&DOCEF_HAS_TERMINATOR)
243
- doc_e->len--;
244
- Free(doc_e->tag); //See $LK,"DataTagWidth",A="FA:::/Adam/DolDoc/DocPlain.HC,DataTagWidth"$
245
- doc_e->tag=MAlloc(doc_e->len+doc_e->min_col+2,
246
- doc->mem_task); //+2 because "_\0"
247
- }
248
- } else if (LBtr(&doc_e->de_flags,DOCEf_DFT_RAW_TYPE))
249
- doc_e->raw_type=tmpc2->raw_type;
250
- }
251
- }
252
- if (doc_e->de_flags&DOCEF_REMALLOC_DATA) {
253
- doc_e->user_data=_d+ml->offset;
254
- doc_e->data=*doc_e->user_data(U8 **);
255
- } else
256
- doc_e->data=_d+ml->offset;
257
- doc_e->my_fmt_data=MemberMetaData("data",ml);
258
- DocDataFmt(doc,doc_e);
259
- }
260
- ml=ml->next;
261
- }
262
- if (footer) DocPrint(doc,"%s",footer);
263
- if (doc->head.next!=doc) {
264
- Fs->border_src=BDS_CONST;
265
- DocRecalc(doc);
266
- if (DocEd(doc,dof_flags)) {
267
- doc_e=doc->cur_entry;
268
- res=TRUE;
269
- if (doc_e!=doc) {
270
- if (DocEntryRun(doc,doc_e,TRUE,&has_action)==DOCM_CANCEL && has_action)
271
- res=FALSE;
272
- DocUnlock(doc);
273
- }
274
- }
275
- }
276
- doc_e=doc->head.next;
277
- while (doc_e!=doc) {
278
- if (doc_e->de_flags&DOCEF_REMALLOC_DATA) {
279
- *doc_e->user_data(U8 **)=doc_e->data;
280
- doc_e->data=NULL;
281
- }
282
- doc_e=doc_e->next;
283
- }
284
- DocDel(doc);
285
- Fs->border_src=old_border_src;
286
- return res;
287
- }
288
-
289
- U0 DocMenuEndTaskCB()
290
- {
291
- WinToTop;
292
- throw;
293
- }
294
-
295
- public I64 DocMenu(CDoc *m,I64 dof_flags=0)
296
- {//Run menu chooser doc. Returns menu doc unlocked.
297
- U8 *old_end_cb=Fs->task_end_cb;
298
- Bool old_break_shift_esc=LBts(&Fs->task_flags,TASKf_BREAK_TO_SHIFT_ESC);
299
- CDocEntry *doc_e;
300
- I64 old_border_src=Fs->border_src,res=DOCM_CANCEL,has_action;
301
- Fs->task_end_cb=&DocMenuEndTaskCB;
302
- try {
303
- if (m) {
304
- m->desc='Menu';
305
- Fs->border_src=BDS_CONST;
306
- dm_restart:
307
- if (DocEd(m,dof_flags)) {
308
- doc_e=m->cur_entry;
309
- if (doc_e!=m) {
310
- res=DocEntryRun(m,doc_e,TRUE,&has_action);
311
- DocUnlock(m);
312
- if (!has_action) {
313
- res=DOCM_CANCEL;
314
- dof_flags|=DOF_DONT_HOME;
315
- goto dm_restart;
316
- }
317
- }
318
- }
319
- }
320
- } catch {
321
- if (!Fs->except_ch) {
322
- if (!(dof_flags & DOF_INTERCEPT_TASK_END))
323
- Exit;
324
- Fs->catch_except=TRUE;
325
- }
326
- }
327
- LBEqu(&Fs->task_flags,TASKf_BREAK_TO_SHIFT_ESC,old_break_shift_esc);
328
- Fs->border_src=old_border_src;
329
- Fs->task_end_cb=old_end_cb;
330
- return res;
331
- }
332
-
333
- public I64 PopUpMenu(CDoc *doc,I64 dof_flags=0)
334
- {//Run menu chooser doc in PopUp win task.
335
- doc->flags|=DOCF_SIZE_MIN | DOCF_FORM;
336
- return PopUpPrint("DocMenu(0x%X,0x%X);",doc,dof_flags);
337
- }
338
-
339
- public Bool PopUpForm(U8 *_d,U8 *class_name=lastclass,
340
- I64 dof_flags=DOF_SIZE_MIN,U8 *header=NULL,U8 *footer=NULL)
341
- {//See $LK,"::/Demo/DolDoc/Form.HC"$ and $LK,"::/Demo/LastClass.HC"$.
342
- return PopUpPrint("DocForm(0x%X,0x%X,0x%X,0x%X,0x%X);",_d,class_name,
343
- dof_flags,header,footer);
344
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:051ad72fd292886b56a15a5ee067e6ee6e50e4b92d44290764f55ffd92ee5c43
3
+ size 9308
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/DolDoc/DocGet.HC CHANGED
@@ -1,243 +1,3 @@
1
- #help_index "DolDoc"
2
-
3
- U0 EdUndoFilter(CDoc *doc)
4
- {
5
- Bool unlock=DocLock(doc);
6
- CDocEntry *doc_ce=doc->head.next;
7
- while (doc_ce!=doc) {
8
- doc_ce->de_flags&=~DOCEF_FILTER_SKIP;
9
- doc_ce=doc_ce->next;
10
- }
11
- doc->find_replace->filter_lines=0;
12
- if (unlock)
13
- DocUnlock(doc);
14
- }
15
-
16
- public I64 DocGetKey(I64 *_sc=NULL)
17
- {//Called by $LK,"View",A="MN:View"$. You probably don't need this.
18
- I64 ch,sc;
19
- Bool cont,old_key_desc;
20
- do {
21
- old_key_desc=LBtr(&Fs->win_inhibit,WIf_SELF_KEY_DESC);
22
- do ch=GetKey(&sc,TRUE);
23
- while (sc&SCF_KEY_DESC);
24
- LBEqu(&Fs->win_inhibit,WIf_SELF_KEY_DESC,old_key_desc);
25
-
26
- DocRecalc(DocPut);
27
- cont=FALSE;
28
- if ((ch==CH_ESC || ch==CH_SHIFT_ESC) && //Check for exit filter mode
29
- DocPut && DocPut->find_replace->filter_lines) {
30
- EdUndoFilter(DocPut);
31
- cont=TRUE;
32
- }
33
- } while (cont);
34
- if (_sc) *_sc=sc;
35
- return ch;
36
- }
37
-
38
- #help_index "DolDoc/Input;StdIn/DolDoc"
39
- public U8 *DocScanLine(CDoc *doc,CDocEntry *doc_e,
40
- I64 *cur_col=NULL,CDocEntry **_do_e_end=NULL)
41
- {//Start at entry in doc,make and return one line as str.
42
- CDocEntry *doc_e2=doc_e;
43
- Bool unlock=DocLock(doc);
44
- U8 *dst,*src,*start,*res;
45
- I64 i=0;
46
- if (cur_col)
47
- *cur_col=-1;
48
- while (doc_e2!=doc && doc_e2->type_u8!=DOCT_NEW_LINE) {
49
- if (doc_e2->de_flags&DOCEF_TAG && doc_e2->tag) {
50
- src=doc_e2->tag;
51
- i+=StrLen(src);
52
- } else if (doc_e2->type_u8==DOCT_TAB)
53
- i++;
54
- else if (doc_e2->type_u8==DOCT_SHIFTED_X ||
55
- doc_e2->type_u8==DOCT_SHIFTED_Y) {
56
- if (doc_e2->attr<0)
57
- i++;
58
- i+=6; //$$SY,3$$
59
- }
60
- doc_e2=doc_e2->next;
61
- }
62
- res=MAlloc(i+1);
63
- dst=res;
64
- while (doc_e!=doc && doc_e->type_u8!=DOCT_NEW_LINE) {
65
- start=dst;
66
- if (doc_e->de_flags&DOCEF_TAG && doc_e->tag) {
67
- src=doc_e->tag;
68
- while (*src)
69
- *dst++=*src++;
70
- } else if (doc_e->type_u8==DOCT_TAB)
71
- *dst++='\t';
72
- else if (doc_e->type_u8==DOCT_SHIFTED_Y) {
73
- *dst(U32 *)++='$$SY,';
74
- if (doc_e->attr<0)
75
- *dst++='-';
76
- *dst++='0'+AbsI64(doc_e->attr); //Supposedly -7 to 7 (single digit)
77
- *dst++='$$';
78
- } else if (doc_e->type_u8==DOCT_SHIFTED_X) {
79
- *dst(U32 *)++='$$SX,';
80
- if (doc_e->attr<0)
81
- *dst++='-';
82
- *dst++='0'+AbsI64(doc_e->attr); //Supposedly -7 to 7 (single digit)
83
- *dst++='$$';
84
- }
85
- if (doc_e==doc->cur_entry && cur_col)
86
- *cur_col=start-res+doc->cur_col;
87
- doc_e=doc_e->next;
88
- }
89
- if (_do_e_end) *_do_e_end=doc_e;
90
- *dst=0;
91
- if (doc_e==doc->cur_entry && cur_col && !doc->cur_col)
92
- *cur_col=dst-res;
93
- if (unlock)
94
- DocUnlock(doc);
95
- return res;
96
- }
97
-
98
- U8 *DocGetStr2(I64 flags=0)
99
- {//$LK,"Flags",A="MN:GSF_SHIFT_ESC_EXIT"$
100
- CDoc *doc;
101
- CDocEntry *doc_e,*doc_e_end;
102
- U8 *st,*st2,*res;
103
- I64 ch,sc;
104
- "$$PT$$";
105
- do {
106
- ch=DocGetKey(&sc);
107
- if (ch==CH_ESC) {
108
- if (doc=DocPut) {
109
- DocLock(doc);
110
- if (doc->doc_signature==DOC_SIGNATURE_VAL && doc->cur_entry!=doc) {
111
- doc_e=DocEntryCopy(doc,doc->cur_entry);
112
- DocBottom(doc);
113
- DocEntryRun(doc,doc_e,TRUE);
114
- DocEntryDel(doc,doc_e);
115
- }
116
- DocUnlock(doc);
117
- }
118
- if (flags&GSF_WITH_NEW_LINE)
119
- break;
120
- } if (ch==CH_SHIFT_ESC) {
121
- if (flags&GSF_SHIFT_ESC_EXIT)
122
- Exit;
123
- else {
124
- res=StrNew("");
125
- goto gs_done;
126
- }
127
- }
128
- //<CTRL-SHIFT-ENTER> is a blank line without entry
129
- } while (flags&GSF_WITH_NEW_LINE || ch!='\n' ||
130
- sc&SCF_CTRL && sc&SCF_SHIFT);
131
-
132
- doc=DocPut;
133
- DocLock(doc);
134
- if (flags&GSF_WITH_NEW_LINE) {
135
- doc_e=doc->cur_entry;
136
- do doc_e=doc_e->last;
137
- while (doc_e!=doc && doc_e->type_u8!=DOCT_PMT);
138
- doc_e=doc_e->next;
139
- if (res=DocScanLine(doc,doc_e,NULL,&doc_e_end)) {
140
- while (doc_e_end!=doc && doc_e_end->type_u8==DOCT_NEW_LINE) {
141
- st2=MStrPrint("%s\n",res);
142
- Free(res);
143
- res=st2;
144
- if (st=DocScanLine(doc,doc_e_end->next,NULL,&doc_e_end)) {
145
- st2=MStrPrint("%s%s",res,st);
146
- Free(st);
147
- Free(res);
148
- res=st2;
149
- }
150
- }
151
- }
152
- } else {
153
- doc_e=doc->cur_entry;
154
- do doc_e=doc_e->last;
155
- while (doc_e!=doc && doc_e->type_u8!=DOCT_NEW_LINE &&
156
- doc_e->type_u8!=DOCT_PMT);
157
- if (doc_e!=doc && doc_e->type_u8!=DOCT_PMT) {
158
- do doc_e=doc_e->last;
159
- while (doc_e!=doc && doc_e->type_u8!=DOCT_NEW_LINE &&
160
- doc_e->type_u8!=DOCT_PMT);
161
- }
162
- doc_e=doc_e->next;
163
- res=DocScanLine(doc,doc_e,NULL);
164
- }
165
- DocUnlock(doc);
166
- gs_done:
167
- "$$PT$$$$FG$$$$BG$$";
168
- return res;
169
- }
170
-
171
- #help_index "Keyboard Devices;Char/Input;StdIn"
172
- public I64 GetI64(U8 *msg=NULL,I64 dft=0,I64 lo=I64_MIN,I64 hi=I64_MAX)
173
- {//Prompt user for I64 expression.
174
- Bool okay;
175
- U8 *st;
176
- I64 res;
177
- while (TRUE) {
178
- if (msg)
179
- "" msg,dft;
180
- st=GetStr;
181
- if (!*st) {
182
- Free(st);
183
- return dft;
184
- }
185
- try {
186
- res=ExePrint2("ToI64(%s);",st);
187
- okay=TRUE;
188
- } catch {
189
- Fs->catch_except=TRUE;
190
- okay=FALSE;
191
- }
192
- Free(st);
193
- if (okay && lo<=res<=hi)
194
- return res;
195
- }
196
- }
197
-
198
- public F64 GetF64(U8 *msg=NULL,F64 dft=0,F64 lo=F64_MIN,F64 hi=F64_MAX)
199
- {//Prompt user for F64 expression.
200
- Bool okay;
201
- U8 *st;
202
- F64 res;
203
- while (TRUE) {
204
- if (msg)
205
- "" msg,dft;
206
- st=GetStr;
207
- if (!*st) {
208
- Free(st);
209
- return dft;
210
- }
211
- try {
212
- res=ExePrint2("ToF64(%s);",st)(F64);
213
- okay=TRUE;
214
- } catch {
215
- Fs->catch_except=TRUE;
216
- okay=FALSE;
217
- }
218
- Free(st);
219
- if (okay && lo<=res<=hi)
220
- return res;
221
- }
222
- }
223
-
224
- public CDate GetDate(U8 *msg=NULL,CDate dft=I64_MIN,
225
- CDate lo=I64_MIN,CDate hi=I64_MAX)
226
- {//Prompt user for date expression. (Use $LK,"Now",A="MN:Now"$() if you want current time.)
227
- U8 *st;
228
- CDate res;
229
- if (dft==I64_MIN) dft=Now;
230
- while (TRUE) {
231
- if (msg)
232
- "" msg,dft,dft;
233
- st=GetStr;
234
- if (!*st) {
235
- Free(st);
236
- return dft;
237
- }
238
- res=Str2Date(st);
239
- Free(st);
240
- if (res>=lo && res<=hi)
241
- return res;
242
- }
243
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:c79833e28649227c24111abafef88d0bcd7f5e083d1236056ad510455d9a24a0
3
+ size 5723
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/DolDoc/DocGr.HC CHANGED
@@ -1,163 +1,3 @@
1
- #help_index "Graphics/Input"
2
-
3
- public I64 PopUpColor(U8 *header=NULL,
4
- Bool allow_transparent=TRUE,Bool allow_dft=TRUE)
5
- {//Chooser for 16-color, default or transparent.
6
- I64 i;
7
- CDoc *doc=DocNew;
8
- if (header)
9
- DocPrint(doc,"%s",header);
10
- if (allow_transparent)
11
- DocPrint(doc,"$$MU,\"TRANSPARENT\",LE=TRANSPARENT$$\n");
12
- for (i=0;i<COLORS_NUM;i++)
13
- DocPrint(doc,"$$BG,%d$$$$MU,\"__%-8Z__\",LE=%d$$$$BG$$\n",i,i,"ST_COLORS",i);
14
- if (allow_dft)
15
- DocPrint(doc,"$$BG,WHITE$$$$MU,\"DEFAULT\",LE=DOC_DFT$$$$BG$$");
16
- i=PopUpMenu(doc);
17
- DocDel(doc);
18
- return i;
19
- }
20
-
21
- public I64 PopUpColorLighting(U8 *header=NULL)
22
- {//Chooser for std TempleOS $LK,"DCLighting",A="MN:DCLighting"$() color.
23
- I64 i;
24
- CDoc *doc=DocNew;
25
- if (header)
26
- DocPrint(doc,"%s",header);
27
- DocPrint(doc,"\nSingle-Sided means front and back different."
28
- "\nDouble-Sided means front and back same."
29
- "\n"
30
- "\nHalf-Range means 0 to [0,7]"
31
- "\n [8,15]-8 to [8,15]"
32
- "\nFull-Range means 0 to [0,7] to [0,7]+8"
33
- "\n");
34
- DocPrint(doc,
35
- "\n$$LTPURPLE$$Single-Sided Full-Range Double-Sided Full-Range\n$$BLACK$$");
36
- for (i=0;i<COLORS_NUM/2;i++) {
37
- DocPrint(doc,"$$BG,%d$$$$MU,\"__%-19Z__\",LE=%d$$$$BG$$ ",i,i,"ST_COLORS",i);
38
- DocPrint(doc,"$$BG,%d$$$$MU,\"__%-19Z__\",LE=%d$$$$BG$$\n",i,i,"ST_COLORS",
39
- ROPF_TWO_SIDED+i);
40
- }
41
- DocPrint(doc,
42
- "\n$$LTPURPLE$$Single-Sided Half-Range Double-Sided Half-Range\n$$BLACK$$");
43
- for (i=0;i<COLORS_NUM;i++) {
44
- DocPrint(doc,"$$BG,%d$$$$MU,\"__%-19Z__\",LE=%d$$$$BG$$ ",
45
- i,i,"ST_COLORS",ROPF_HALF_RANGE_COLOR+i);
46
- DocPrint(doc,"$$BG,%d$$$$MU,\"__%-19Z__\",LE=%d$$$$BG$$\n",
47
- i,i,"ST_COLORS",ROPF_TWO_SIDED+ROPF_HALF_RANGE_COLOR+i);
48
- }
49
- i=PopUpMenu(doc);
50
- DocDel(doc);
51
- return i;
52
- }
53
-
54
- class CTransformForm
55
- {
56
- F64 x_scale format "$$DA-TRM,A=\"X Scale :%12.6f\"$$\n";
57
- F64 y_scale format "$$DA-TRM,A=\"Y Scale :%12.6f\"$$\n";
58
- F64 z_scale format "$$DA-TRM,A=\"Z Scale :%12.6f\"$$\n";
59
- F64 �_z format "\nAngles are in degrees\n"
60
- "$$DA-TRM,A=\"Z-Axis :%12.6f\"$$\n";
61
- F64 �_y format "$$DA-TRM,A=\"Y-Axis :%12.6f\"$$\n";
62
- F64 �_x format "$$DA-TRM,A=\"X-Axis :%12.6f\"$$\n";
63
- F64 x_offset format "\n$$DA-TRM,A=\"X Offset:%12.6f\"$$\n";
64
- F64 y_offset format "$$DA-TRM,A=\"Y Offset:%12.6f\"$$\n";
65
- F64 z_offset format "$$DA-TRM,A=\"Z Offset:%12.6f\"$$\n";
66
- };
67
-
68
- #help_index "Graphics/Input;Graphics/Math/3D Transformation"
69
- public Bool PopUpTransform(I64 *r)
70
- {//Prompt for Mat4x4 transform.
71
- CTransformForm *tf=MAlloc(sizeof(CTransformForm));
72
- tf->x_scale=1.0;
73
- tf->y_scale=1.0;
74
- tf->z_scale=1.0;
75
- tf->�_x=0.0;
76
- tf->�_y=0.0;
77
- tf->�_z=0.0;
78
- tf->x_offset=0.0;
79
- tf->y_offset=0.0;
80
- tf->z_offset=0.0;
81
- if (PopUpForm(tf)) {
82
- MemSet(r,0,16*sizeof(I64));
83
- r[0] =tf->x_scale*GR_SCALE;
84
- r[5] =tf->y_scale*GR_SCALE;
85
- r[10]=tf->z_scale*GR_SCALE;
86
- r[15]=GR_SCALE;
87
-
88
- Mat4x4RotZ(r,tf->�_z*�/180.0);
89
- Mat4x4RotY(r,tf->�_y*�/180.0);
90
- Mat4x4RotX(r,tf->�_x*�/180.0);
91
-
92
- r[3] =tf->x_offset*GR_SCALE;
93
- r[7] =tf->y_offset*GR_SCALE;
94
- r[11]=tf->z_offset*GR_SCALE;
95
- return TRUE;
96
- } else
97
- return FALSE;
98
- }
99
-
100
- #help_index "Graphics/Input"
101
- #define PU_SPACING 10
102
- U0 DrawIt(CTask *task,CDC *dc)
103
- {
104
- I64 i,j,i1,j1;
105
- CDoc *doc=DocPut(task);
106
- for (j=0;j<17;j++)
107
- for (i=0;i<17;i++) {
108
- if (j<16)
109
- j1=j;
110
- else
111
- j1=TRANSPARENT;
112
- if (i<16)
113
- i1=i;
114
- else
115
- i1=TRANSPARENT;
116
- dc->color=j1+i1<<16+ROPF_DITHER;
117
- GrRect(dc,i*PU_SPACING,j*PU_SPACING+FramePtr("DitherFrame",task),
118
- PU_SPACING,PU_SPACING);
119
- }
120
- i=(17*PU_SPACING+FONT_WIDTH-1)/FONT_WIDTH;
121
- if (doc->max_x>i) i=doc->max_x;
122
- WinHorz(task->win_left,task->win_left+i,task);
123
- WinVert(task->win_top,task->win_top+doc->max_y+
124
- (17*PU_SPACING+FONT_WIDTH-1)/FONT_WIDTH,task);
125
- }
126
-
127
- I64 DitherColor2(U8 *header=NULL)
128
- {
129
- I64 msg_code,arg1,arg2,res=-1,i,j;
130
- DocClear;
131
- "%s",header;
132
- DocRecalc(DocPut);
133
- FramePtrAdd("DitherFrame",(DocPut->max_y+1)*FONT_HEIGHT);
134
- SettingsPush; //See $LK,"SettingsPush",A="MN:SettingsPush"$
135
- Fs->draw_it=&DrawIt;
136
- do {
137
- msg_code=GetMsg(&arg1,&arg2,1<<MSG_MS_L_DOWN|1<<MSG_KEY_DOWN);
138
- if (msg_code==MSG_MS_L_DOWN) {
139
- msg_code=GetMsg(&arg1,&arg2,1<<MSG_MS_L_UP);
140
- i=arg1/PU_SPACING;
141
- j=(arg2-FramePtr("DitherFrame"))/PU_SPACING;
142
- if (arg1>=0 && arg2>=0 && 0<=j<17 && 0<=i<17) {
143
- if (j==16) j=TRANSPARENT;
144
- if (i==16) i=TRANSPARENT;
145
- res=j+i<<16+ROPF_DITHER;
146
- goto dc_done;
147
- }
148
- }
149
- } while (!(msg_code==MSG_KEY_DOWN && (arg1==CH_ESC || arg1==CH_SHIFT_ESC)));
150
- do GetMsg(&arg1,&arg2,1<<MSG_KEY_UP);
151
- while (!arg1);
152
- dc_done:
153
- SettingsPop;
154
- FramePtrDel("DitherFrame");
155
- return res;
156
- }
157
-
158
- public I64 PopUpColorDither(U8 *header=NULL)
159
- {//Chooser for 2 x 16 colors or transparent.
160
- U8 buf[STR_LEN];
161
- StrPrint(buf,"DitherColor2(0x%X);",header);
162
- return PopUp(buf,Fs);
163
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:8484a4c677e7c5e408c4ede6f4557e204c29c0144ce63e482a8719cb342e3bac
3
+ size 4794
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/DolDoc/DocHighlight.HC CHANGED
@@ -1,160 +1,3 @@
1
- #help_index "DolDoc/Misc"
2
-
3
- CColorROPU32 highlight_hash_type_colors[HTt_TYPES_NUM]=
4
- DOC_COLOR_EXPORT_SYS_SYM,0,DOC_COLOR_DEFINE_STR,DOC_COLOR_GLBL_VAR,
5
- DOC_COLOR_CLASS,DOC_COLOR_KEYWORD,DOC_COLOR_FUN,0,0,DOC_COLOR_KEYWORD,
6
- DOC_COLOR_KEYWORD,DOC_COLOR_KEYWORD,DOC_COLOR_REG,0,0,0,0};
7
-
8
- U32 *DocHighlight(CDocEntry *doc_e,U8 *src,I64 len,I64 _tmp_u32_attr)
9
- {//Be aware of $LK,"::/Demo/ToHtmlToTXTDemo/ToHtml.HC"$.
10
- U32 *res=MAlloc((len+1)*sizeof(U32)),*dst=res;
11
- U8 *ptr;
12
- CDocSettings *s=&doc_e->settings;
13
- I64 ch,ch1,last_ch,tmp_u32_attr,mask_tmp_u32_attr=_tmp_u32_attr&0xFFFFF000,
14
- comment_depth,brace_depth=s->brace_depth,paren_depth=s->paren_depth;
15
- CHash *tmph;
16
- switch [s->state] {
17
- case DOCSS_NORMAL:
18
- hl_normal:
19
- while (len) {
20
- while (len && !Bt(char_bmp_alpha_numeric,*src)) {
21
- tmp_u32_attr=_tmp_u32_attr;
22
- ch1=*src++;
23
- switch (ch1) {
24
- case '/':
25
- if (len>=2) {
26
- if (*src=='/') {
27
- tmp_u32_attr=DOC_COLOR_COMMENT<<8|mask_tmp_u32_attr;
28
- *dst++=ch1+tmp_u32_attr;
29
- *dst++=*src++ +tmp_u32_attr;
30
- len-=2;
31
- goto hl_cpp_comment;
32
- } else if (*src=='*') {
33
- tmp_u32_attr=DOC_COLOR_COMMENT<<8|mask_tmp_u32_attr;
34
- *dst++=ch1+tmp_u32_attr;
35
- *dst++=*src++ +tmp_u32_attr;
36
- len-=2;
37
- comment_depth=1;
38
- goto hl_comment;
39
- }
40
- }
41
- break;
42
- case '\'':
43
- tmp_u32_attr=DOC_COLOR_CHAR_CONST<<8|mask_tmp_u32_attr;
44
- *dst++=ch1+tmp_u32_attr;
45
- len--;
46
- goto hl_single_quote;
47
- case '\"':
48
- tmp_u32_attr=DOC_COLOR_STR<<8|mask_tmp_u32_attr;
49
- *dst++=ch1+tmp_u32_attr;
50
- len--;
51
- goto hl_dbl_quote;
52
- case '(':
53
- if (paren_depth++&1)
54
- tmp_u32_attr=DOC_COLOR_ALT_TEXT<<8|mask_tmp_u32_attr;
55
- break;
56
- case ')':
57
- if (--paren_depth&1)
58
- tmp_u32_attr=DOC_COLOR_ALT_TEXT<<8|mask_tmp_u32_attr;
59
- break;
60
- case '{':
61
- if (brace_depth++&1)
62
- tmp_u32_attr=DOC_COLOR_ALT_TEXT<<8|mask_tmp_u32_attr;
63
- break;
64
- case '}':
65
- if (--brace_depth&1)
66
- tmp_u32_attr=DOC_COLOR_ALT_TEXT<<8|mask_tmp_u32_attr;
67
- break;
68
- }
69
- *dst++=ch1+tmp_u32_attr;
70
- if (!--len) goto hl_normal_done;
71
- }
72
- ptr=src;
73
- while (len && Bt(char_bmp_alpha_numeric,*src)) {
74
- src++;
75
- len--;
76
- }
77
- ch=*src;
78
- *src=0;
79
- if (tmph=HashFind(ptr,adam_task->hash_table,
80
- HTT_EXPORT_SYS_SYM|HTT_DEFINE_STR|HTT_GLBL_VAR|HTT_CLASS|
81
- HTT_INTERNAL_TYPE|HTT_FUN|HTT_KEYWORD|HTT_ASM_KEYWORD|
82
- HTT_OPCODE|HTT_REG))
83
- tmp_u32_attr=highlight_hash_type_colors[HashTypeNum(tmph)]<<8|
84
- mask_tmp_u32_attr;
85
- else
86
- tmp_u32_attr=_tmp_u32_attr;
87
- while (ch1=*ptr++)
88
- *dst++=ch1+tmp_u32_attr;
89
- *src=ch;
90
- }
91
- hl_normal_done:
92
- s->state=DOCSS_NORMAL;
93
- s->comment_depth=0;
94
- break;
95
- case DOCSS_SINGLE_QUOTE:
96
- tmp_u32_attr=DOC_COLOR_CHAR_CONST<<8|mask_tmp_u32_attr;
97
- hl_single_quote:
98
- last_ch=0;
99
- while (len--) {
100
- ch1=*src++;
101
- *dst++=ch1+tmp_u32_attr;
102
- if (last_ch!='\\' && ch1=='\'')
103
- goto hl_normal;
104
- if (last_ch=='\\' && ch1=='\\')
105
- last_ch=0;
106
- else
107
- last_ch=ch1;
108
- }
109
- s->state=DOCSS_SINGLE_QUOTE;
110
- s->comment_depth=0;
111
- break;
112
- case DOCSS_DBL_QUOTE:
113
- tmp_u32_attr=DOC_COLOR_CHAR_CONST<<8|mask_tmp_u32_attr;
114
- hl_dbl_quote:
115
- last_ch=0;
116
- while (len--) {
117
- ch1=*src++;
118
- *dst++=ch1+tmp_u32_attr;
119
- if (last_ch!='\\' && ch1=='\"')
120
- goto hl_normal;
121
- if (last_ch=='\\' && ch1=='\\')
122
- last_ch=0;
123
- else
124
- last_ch=ch1;
125
- }
126
- s->state=DOCSS_DBL_QUOTE;
127
- s->comment_depth=0;
128
- break;
129
- case DOCSS_COMMENT:
130
- tmp_u32_attr=DOC_COLOR_COMMENT<<8|mask_tmp_u32_attr;
131
- comment_depth=s->comment_depth;
132
- hl_comment:
133
- last_ch=0;
134
- while (len--) {
135
- ch1=*src++;
136
- *dst++=ch1+tmp_u32_attr;
137
- if (last_ch=='*' && ch1=='/') {
138
- if (!--comment_depth)
139
- goto hl_normal;
140
- } else if (last_ch=='/' && ch1=='*')
141
- comment_depth++;
142
- last_ch=ch1;
143
- }
144
- s->state=DOCSS_COMMENT;
145
- s->comment_depth=comment_depth;
146
- break;
147
- case DOCSS_CPP_Z_COMMENT:
148
- tmp_u32_attr=DOC_COLOR_COMMENT<<8|mask_tmp_u32_attr;
149
- hl_cpp_comment:
150
- while (len--)
151
- *dst++=*src++ +tmp_u32_attr;
152
- s->state=DOCSS_CPP_Z_COMMENT;
153
- s->comment_depth=0;
154
- break;
155
- }
156
- s->paren_depth=paren_depth;
157
- s->brace_depth=brace_depth;
158
- *dst=0;
159
- return res;
160
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:8f087d674a7d0b452b280947906bb62dc2f115fd2d60591ee57cf6caa684ea13
3
+ size 4239
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/DolDoc/DocInit.HC CHANGED
@@ -1,112 +1,3 @@
1
- #help_index "DolDoc"
2
-
3
- U0 DocInit()
4
- {//$LK-UL,"CMD Defines",A="MN:DOCT_TEXT"$
5
- CCmpCtrl *cc;
6
- I64 i;
7
- CHashGeneric *tmph;
8
-
9
- DefineLstLoad("ST_DOC_CMDS",
10
- "TX\0CR\0SR\0TB\0PB\0CU\0MK\0PT\0CL\0PL\0LM\0RM\0HD\0FO\0ID\0FG\0"
11
- "BG\0FD\0BD\0WW\0HL\0BK\0IV\0UL\0SX\0SY\0CM\0AN\0LK\0BT\0"
12
- "DA\0CB\0LS\0MA\0MU\0HX\0TR\0SP\0IB\0IS\0SO\0HC\0ER\0");
13
- DefineLstLoad("ST_DOC_FLAGS",
14
- "T\0LEN\0A\0D\0HTML\0LE\0LM\0RE\0RM\0BI\0BP\0RT\0SX\0SY\0SCX\0U\0"
15
- "LC\0LIS\0RC\0RIS\0LX\0CX\0RX\0TY\0CY\0BY\0"
16
- "HL\0WW\0BK\0IV\0SEL\0UL\0"
17
- "TC\0PRY\0MRX\0WR\0L\0X\0Q\0FST\0B\0S\0BD\0C\0CA\0RD\0UD\0P\0M\0"
18
- "TRM\0Z\0H\0TR\0LS\0SK\0PU\0SIF\0FS\0NC\0DD\0DL\0DRT\0");
19
- DefineLstLoad("ST_LINK_TYPES",
20
- "FI\0FA\0FF\0FL\0MN\0PI\0PF\0PL\0BF\0DN\0HI\0AD\0AI\0AA\0AF\0AL\0");
21
-
22
- doldoc.hash=HashTableNew(512);
23
- HashDefineLstAdd("ST_DOC_CMDS",DHT_DOC_CMD,doldoc.hash);
24
- HashDefineLstAdd("ST_DOC_FLAGS",DHT_DOC_FLAG,doldoc.hash);
25
- HashDefineLstAdd("ST_COLORS",DHT_COLOR,doldoc.hash);
26
-
27
- MemSet(doldoc.dft_de_flags, 0,sizeof(doldoc.dft_de_flags));
28
- MemSet(doldoc.dft_type_flags, 0,sizeof(doldoc.dft_type_flags));
29
- cc=CmpCtrlNew("TX+T;DA+P+TRM+T+DL+DRT;CM+LE+RE;AN+T;LK+L+UL+T;MA+X+UL+T;"
30
- "MU+X+UL+T;BT+X+B+T;CB+CA+P+T+DRT;LS+LS+P+T+DRT;HX+P+Z;TR+TR+C+CA+UL+T;"
31
- "SP+T;IB+T;IS+T;SO+T;HC+T;",CCF_DONT_FREE_BUF);
32
- cc->htc.hash_table_lst=NULL;
33
- Lex(cc);
34
- while (cc->token==TK_IDENT) {
35
- if (tmph=HashFind(cc->cur_str,doldoc.hash,DHT_DOC_CMD)) {
36
- i=tmph->user_data0;
37
- Lex(cc);
38
- PrsDocFlags(cc,&doldoc.dft_de_flags[i],&doldoc.dft_type_flags[i]);
39
- }
40
- if (cc->token==';')
41
- Lex(cc);
42
- }
43
- CmpCtrlDel(cc);
44
-
45
- for (i=0;i<DOCT_TYPES_NUM;i++)
46
- doldoc.dft_de_flags[i]&=~DOCG_BL_IV_UL;
47
-
48
- doldoc.type_flags_form[0]=0;
49
- for (i=0;i<DOCT_TYPES_NUM;i++)
50
- if (Bt(&doldoc.dft_de_flags[i],DOCEf_TAG) && i!=DOCT_TEXT || i==DOCT_HEX_ED)
51
- Bts(doldoc.type_flags_form,i);
52
-
53
- //Don't forget $LK,"cmp_type_flags_src_code",A="MN:cmp_type_flags_src_code"$.
54
- doldoc.type_flags_nontag_invis[0]=
55
- 1<<DOCT_PMT|
56
- 1<<DOCT_PAGE_LEN|
57
- 1<<DOCT_LEFT_MARGIN|
58
- 1<<DOCT_RIGHT_MARGIN|
59
- 1<<DOCT_HEADER|
60
- 1<<DOCT_FOOTER|
61
- 1<<DOCT_INDENT|
62
- 1<<DOCT_FOREGROUND|
63
- 1<<DOCT_BACKGROUND|
64
- 1<<DOCT_DFT_FOREGROUND|
65
- 1<<DOCT_DFT_BACKGROUND|
66
- 1<<DOCT_WORD_WRAP|
67
- 1<<DOCT_HIGHLIGHT|
68
- 1<<DOCT_BLINK|
69
- 1<<DOCT_INVERT|
70
- 1<<DOCT_UNDERLINE|
71
- 1<<DOCT_SHIFTED_X|
72
- 1<<DOCT_SHIFTED_Y|
73
- 1<<DOCT_SPRITE;
74
-
75
- doldoc.type_flags_data[0]=1<<DOCT_DATA|1<<DOCT_HEX_ED|1<<DOCT_CHECK_BOX;
76
-
77
- doldoc.type_flags_chk_dup[0]=
78
- 1<<DOCT_LEFT_MARGIN|
79
- 1<<DOCT_RIGHT_MARGIN|
80
- 1<<DOCT_HEADER|
81
- 1<<DOCT_FOOTER|
82
- 1<<DOCT_FOREGROUND|
83
- 1<<DOCT_BACKGROUND|
84
- 1<<DOCT_DFT_FOREGROUND|
85
- 1<<DOCT_DFT_BACKGROUND|
86
- 1<<DOCT_WORD_WRAP|
87
- 1<<DOCT_HIGHLIGHT|
88
- 1<<DOCT_BLINK|
89
- 1<<DOCT_INVERT|
90
- 1<<DOCT_UNDERLINE|
91
- 1<<DOCT_SHIFTED_X|
92
- 1<<DOCT_SHIFTED_Y;
93
-
94
- Bts(doldoc.clean_scan_codes,SC_CURSOR_RIGHT);
95
- Bts(doldoc.clean_scan_codes,SC_CURSOR_LEFT);
96
- Bts(doldoc.clean_scan_codes,SC_CURSOR_UP);
97
- Bts(doldoc.clean_scan_codes,SC_CURSOR_DOWN);
98
- Bts(doldoc.clean_scan_codes,SC_PAGE_UP);
99
- Bts(doldoc.clean_scan_codes,SC_PAGE_DOWN);
100
- Bts(doldoc.clean_scan_codes,SC_ALT);
101
- Bts(doldoc.clean_scan_codes,SC_CTRL);
102
- Bts(doldoc.clean_scan_codes,SC_SHIFT);
103
- Bts(doldoc.clean_scan_codes,SC_CAPS);
104
- Bts(doldoc.clean_scan_codes,SC_NUM);
105
- Bts(doldoc.clean_scan_codes,SC_SCROLL);
106
- Bts(doldoc.clean_scan_codes,SC_HOME);
107
- Bts(doldoc.clean_scan_codes,SC_END);
108
- Bts(doldoc.clean_scan_codes,SC_GUI);
109
- Bts(doldoc.clean_scan_codes,SC_BACKSPACE); //Handled specially
110
- }
111
-
112
- DocInit;
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:632323687ace48932393ed987431a780bf0e901f192968be9113e6e82942a4aa
3
+ size 3479
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/DolDoc/DocLink.HC CHANGED
@@ -1,358 +1,3 @@
1
- #help_index "DolDoc/Link"
2
-
3
- /* See $LK,"TempleOS Link Types",A="MN:ST_LINK_TYPES"$.
4
- "filename"
5
- "FI:filename"
6
- "FA:haystack_filename,needle_anchor_str"
7
- "FF:haystack_filename,needle_str"
8
- "FF:haystack_filename,needle_str:occurnum"
9
- "FL:filename,linenum"
10
- "MN:SymName"
11
- "PI:filename"
12
- "PF:haystack_filename,needle_str"
13
- "PF:haystack_filename,needle_str:occurnum"
14
- "PL:filename,linenum"
15
- "BF:haystack_bible_book,needle_str"
16
- "DN:word"
17
- "DN:word,defnum"
18
- "HI:index"
19
- "AD:code_address_number"
20
-
21
- To edit a doc structure already in memory. See $LK,"SpriteEdText",A="MN:SpriteEdText"$().
22
- "AI:doc_address"
23
- "AA:haystack_doc_address,needle_anchor_str"
24
- "AF:haystack_doc_address,needle_str"
25
- "AF:haystack_doc_address,needle_str:occurnum"
26
- "AL:doc_address,linenum"
27
- */
28
-
29
- #define LK_FILE 0
30
- #define LK_FILE_ANCHOR 1
31
- #define LK_FILE_FIND 2
32
- #define LK_FILE_LINE 3
33
- #define LK_MAN_PAGE 4
34
- #define LK_PLAIN 5
35
- #define LK_PLAIN_FIND 6
36
- #define LK_PLAIN_LINE 7
37
- #define LK_BIBLE_FIND 8
38
- #define LK_DEF 9
39
- #define LK_HELP_INDEX 10
40
- #define LK_ADDR 11
41
- #define LK_DOC 12 //See $LK,"SpriteEdText",A="MN:SpriteEdText"$()
42
- #define LK_DOC_ANCHOR 13
43
- #define LK_DOC_FIND 14
44
- #define LK_DOC_LINE 15
45
- #define LK_PLACE_ANCHOR 16
46
-
47
- public U8 *DocEntryLink(CDoc *doc,CDocEntry *doc_e)
48
- {//MAlloc new str, either tag or aux_str if link.
49
- if (doc_e->de_flags&DOCEF_LINK) {
50
- if (doc_e->de_flags & DOCEF_AUX_STR)
51
- return StrNew(doc_e->aux_str,doc->mem_task);
52
- else if (doc_e->de_flags & DOCEF_TAG)
53
- return StrNew(doc_e->tag,doc->mem_task);
54
- }
55
- return NULL;
56
- }
57
-
58
- Bool DocFileEd(I64 _type,U8 *filename,
59
- U8 *needle_str,I64 *_num,I64 edf_dof_flags)
60
- {
61
- I64 type=_type,flags=0,old_border_src=Fs->border_src;
62
- CDocEntry *doc_e;
63
- CDoc *doc;
64
- Bool old_silent=Bt(&Fs->display_flags,DISPLAYf_SILENT),
65
- res=FALSE,other_found=FALSE;
66
- U8 *st1,*st2;
67
- try {
68
- switch (type) {
69
- case LK_PLAIN:
70
- flags=DOCF_PLAIN_TEXT|DOCF_NO_CURSOR;
71
- case LK_DOC:
72
- type=LK_FILE;
73
- break;
74
- case LK_DOC_ANCHOR:
75
- type=LK_FILE_ANCHOR;
76
- break;
77
- case LK_PLAIN_FIND:
78
- flags=DOCF_PLAIN_TEXT|DOCF_NO_CURSOR;
79
- case LK_DOC_FIND:
80
- type=LK_FILE_FIND;
81
- break;
82
- case LK_PLAIN_LINE:
83
- flags=DOCF_PLAIN_TEXT|DOCF_NO_CURSOR;
84
- case LK_DOC_LINE:
85
- type=LK_FILE_LINE;
86
- break;
87
- case LK_BIBLE_FIND:
88
- flags=DOCF_PLAIN_TEXT|DOCF_NO_CURSOR;
89
- break;
90
- }
91
-
92
- flags|=DOCF_ALLOW_UNDO;
93
-
94
- if (LK_DOC<=_type<=LK_DOC_LINE) {
95
- doc=Str2I64(filename);//See $LK,"SpriteEdText",A="MN:SpriteEdText"$()
96
- res=TRUE;
97
- } else {
98
- st1=StrNew(filename);
99
- st2=StrNew(filename);
100
- StrLastRem(st1,"/",st2); //st2 is name without dir
101
- if (!FileNameChk(st2))
102
- doc=NULL;
103
- else {
104
- Silent;
105
- if (Bt(&edf_dof_flags,EDf_BAIL)) //if bail, scan parents
106
- res=FileFind(filename,,
107
- FUF_JUST_FILES|FUF_Z_OR_NOT_Z|FUF_SCAN_PARENTS);
108
- else if (!(res=FileFind(filename,,FUF_JUST_FILES)))
109
- other_found=FileFind(filename,,
110
- FUF_JUST_FILES|FUF_Z_OR_NOT_Z|FUF_SCAN_PARENTS);
111
- doc=DocRead(filename,flags);
112
- doc->desc='Edit';
113
- Silent(old_silent);
114
- Fs->border_src=BDS_ED_FILENAME_DRV;
115
- }
116
- Free(st1);
117
- Free(st2);
118
- }
119
- if (!doc||doc->doc_signature!=DOC_SIGNATURE_VAL)
120
- res=FALSE;
121
- else {
122
- if (Bt(&edf_dof_flags,EDf_COLLAPSE))
123
- DocCollapse(TRUE,doc);
124
- else if (Bt(&edf_dof_flags,EDf_UNCOLLAPSE))
125
- DocCollapse(FALSE,doc);
126
-
127
- if (res || other_found)
128
- switch (type) {
129
- case LK_FILE_LINE:
130
- res=DocGoToLine(doc,*_num);
131
- break;
132
- case LK_FILE_ANCHOR:
133
- res=DocAnchorFind(doc,needle_str);
134
- break;
135
- case LK_FILE_FIND:
136
- res=DocFind(doc,,needle_str,*_num);
137
- break;
138
- case LK_BIBLE_FIND:
139
- res=DocFind(doc,*_num,needle_str);
140
- break;
141
- default:
142
- DocCenter(doc);
143
- }
144
- *_num=doc->cur_entry->y+1;
145
-
146
- if (edf_dof_flags&EDF_WAS_WRITE)
147
- res=FALSE;
148
- if (!(edf_dof_flags&EDF_BAIL)) {
149
- if (*doc->filename.name)
150
- doc->filename.dirc=DirContextNew(doc->filename.name);
151
- else
152
- doc->filename.dirc=NULL;
153
- if (DocEd(doc,edf_dof_flags|DOF_DONT_HOME)) {
154
- DocLock(doc);
155
- doc_e=doc->cur_entry;
156
- if (doc_e!=doc)
157
- DocEntryRun(doc,doc_e,TRUE);
158
- DocUnlock(doc);
159
- if (!(LK_DOC<=_type<=LK_DOC_LINE)) {
160
- DocWrite(doc);
161
- if (edf_dof_flags&EDF_WAS_WRITE)
162
- res=TRUE;
163
- }
164
- }
165
- DirContextDel(doc->filename.dirc);
166
- }
167
- if (!(LK_DOC<=_type<=LK_DOC_LINE))
168
- DocDel(doc);
169
- }
170
- } catch {
171
- Silent(old_silent);
172
- res=FALSE;
173
- }
174
- Fs->border_src=old_border_src;
175
- return res;
176
- }
177
-
178
- #define DFT_ADDR_LINK_BIN_SIZE 64
179
-
180
- public I64 EdLinkCvt(U8 *link_st,U8 **_filename=NULL,U8 **_needle_str=NULL,
181
- I64 *_num=NULL,I64 edf_dof_flags=0)
182
- {//$LK,"Editor Link",A="MN:LK_FILE"$--> filename, needle_str and line number.
183
- U8 *st,*ptr,*src,*filename=NULL,*needle_str=NULL,*filename2;
184
- I64 res,i,num=1;
185
- CHashSrcSym *tmph;
186
- if (!link_st||!*link_st) {
187
- if (edf_dof_flags&EDF_BAIL)
188
- return -1;
189
- link_st=blkdev.tmp_filename;
190
- }
191
- st=StrNew(link_st);
192
- res=LK_FILE;
193
- if (StrLen(st)>3 && st[2]==':') {
194
- st[2]=0;
195
- filename2=st+3;
196
- switch (res=DefineMatch(st,"ST_LINK_TYPES",LMF_IGNORE_CASE)) {
197
- case LK_MAN_PAGE:
198
- if (tmph=HashFind(filename2,Fs->hash_table,HTG_SRC_SYM))
199
- res=EdLinkCvt(tmph->src_link,&filename,
200
- &needle_str,&num,edf_dof_flags);
201
- else
202
- res=-1;
203
- goto lc_done;
204
- case LK_ADDR:
205
- if (ptr=StrLastOcc(filename2,",")) {
206
- *ptr=0;
207
- i=Str2I64(ptr+1);
208
- } else
209
- i=DFT_ADDR_LINK_BIN_SIZE;
210
- if (ptr=SrcEdLink(ExePrint("%s;",filename2),i)) {
211
- res=EdLinkCvt(ptr,&filename,&needle_str,&num,edf_dof_flags);
212
- Free(ptr);
213
- } else
214
- res=-1;
215
- goto lc_done;
216
- case LK_DEF:
217
- if (ptr=StrLastOcc(filename2,",")) {
218
- *ptr=0;
219
- i=Str2I64(ptr+1);
220
- } else
221
- i=-1;
222
- filename=StrNew(filename2);
223
- num=i;
224
- goto lc_done;
225
- case LK_HELP_INDEX:
226
- filename=StrNew(filename2);
227
- goto lc_done;
228
- case LK_BIBLE_FIND:
229
- if (ptr=StrLastOcc(filename2,",")) {
230
- *ptr=0;
231
- src=ptr+1;
232
- while (*src) { //We do not allow ending verse
233
- if (*src=='-')
234
- *src=0;
235
- src++;
236
- }
237
- needle_str=StrNew(ptr+1);
238
- }
239
- i=DefineMatch(filename2,"ST_BIBLE_BOOKS",LMF_IGNORE_CASE);
240
- if (i<0)
241
- res=-1;
242
- else {
243
- num=Str2I64(DefineSub(i,"ST_BIBLE_BOOK_LINES"));
244
- filename2=BIBLE_FILENAME;
245
- }
246
- break;
247
- case LK_FILE_LINE:
248
- case LK_PLAIN_LINE:
249
- case LK_DOC_LINE:
250
- if (ptr=StrLastOcc(filename2,",")) {
251
- *ptr=0;
252
- num=Str2I64(ptr+1);
253
- }
254
- break;
255
- case LK_FILE_ANCHOR:
256
- case LK_DOC_ANCHOR:
257
- if (ptr=StrLastOcc(filename2,",")) {
258
- *ptr=0;
259
- needle_str=StrNew(ptr+1);
260
- }
261
- break;
262
- case LK_FILE_FIND:
263
- case LK_PLAIN_FIND:
264
- case LK_DOC_FIND:
265
- if (ptr=StrLastOcc(filename2,",")) {
266
- *ptr=0;
267
- needle_str=StrNew(ptr+1);
268
- if (ptr=StrLastOcc(needle_str,":")) {
269
- *ptr=0;
270
- num=Str2I64(ptr+1);
271
- }
272
- }
273
- break;
274
- }
275
- } else
276
- filename2=st;
277
- if (res>=0) {
278
- if (LK_DOC<=res<=LK_DOC_LINE)
279
- filename=StrNew(filename2); //Holds document address as number.
280
- else
281
- filename=FileNameAbs(filename2,FUF_Z_OR_NOT_Z);
282
- }
283
- lc_done:
284
- Free(st);
285
- if (_filename)
286
- *_filename=filename;
287
- else
288
- Free(filename);
289
- if (_needle_str)
290
- *_needle_str=needle_str;
291
- else
292
- Free(needle_str);
293
- if (_num)
294
- *_num=num;
295
- return res;
296
- }
297
-
298
- public Bool DocLinkChk(CDoc *doc,U8 *link_st)
299
- {//Check for bad $LK,"Editor Link",A="MN:LK_FILE"$.
300
- U8 *filename,*st;
301
- Bool res=FALSE;
302
- CDirContext *dirc;
303
- if (link_st) {
304
- st=FileNameAbs(doc->filename.name);
305
- dirc=DirContextNew(st);
306
- Free(st);
307
- switch (EdLinkCvt(link_st,&filename)) {
308
- case -1:
309
- break;
310
- case LK_FILE_LINE:
311
- case LK_PLAIN_LINE:
312
- case LK_FILE:
313
- //We don't check line number
314
- res=FileFind(filename,,
315
- FUF_JUST_FILES|FUF_Z_OR_NOT_Z|FUF_SCAN_PARENTS);
316
- break;
317
- case LK_BIBLE_FIND:
318
- st=StrNew(link_st+3);
319
- if (StrOcc(st,','))
320
- StrLastRem(st,",");
321
- if (DefineMatch(st,"ST_BIBLE_BOOKS",LMF_IGNORE_CASE)>=0)
322
- res=TRUE;
323
- Free(st);
324
- break;
325
- default://TODO: Need to validate HI: and DN:
326
- if (Ed(link_st,EDF_BAIL))
327
- res=TRUE;
328
- }
329
- Free(filename);
330
- DirContextDel(dirc);
331
- }
332
- return res;
333
- }
334
-
335
- public U8 *DocLinkFile(U8 *link_st,CTask *mem_task=NULL)
336
- {//Return the file for an $LK,"Editor Link Types",A="MN:LK_FILE"$.
337
- U8 *filename=NULL,*st,*res=NULL;
338
- if (link_st) {
339
- switch (EdLinkCvt(link_st,&filename)) {
340
- case LK_FILE:
341
- case LK_FILE_ANCHOR:
342
- case LK_FILE_FIND:
343
- case LK_FILE_LINE:
344
- case LK_PLAIN:
345
- case LK_PLAIN_FIND:
346
- case LK_PLAIN_LINE:
347
- st=FileNameAbs(filename,FUF_Z_OR_NOT_Z|FUF_SCAN_PARENTS);
348
- res=StrNew(st);
349
- Free(st);
350
- break;
351
- case LK_BIBLE_FIND:
352
- res=StrNew(BIBLE_FILENAME,mem_task);
353
- break;
354
- }
355
- Free(filename);
356
- }
357
- return res;
358
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:6b3fa97ab46facf4543f5abfa5375215f46bc576a3ac2d2d6df12d1ab5f1ee1c
3
+ size 8571
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/DolDoc/DocMacro.HC CHANGED
@@ -1,211 +1,3 @@
1
- #help_index "DolDoc/Misc"
2
-
3
- U8 captured_macro_name[STR_LEN];
4
- StrCpy(captured_macro_name,"Test");
5
-
6
- I64 sys_macro_repeat_n=1;
7
-
8
- U0 SysMacroStripKey(CJob *macro_head,I64 arg1,I64 arg2)
9
- {
10
- CJob *tmpc,*tmpc1;
11
- tmpc=macro_head->next;
12
- while (tmpc!=macro_head) {
13
- tmpc1=tmpc->next;
14
- if (tmpc->job_code==JOBT_MSG &&
15
- (tmpc->msg_code==MSG_KEY_DOWN || tmpc->msg_code==MSG_KEY_UP ||
16
- tmpc->msg_code==MSG_KEY_DOWN_UP) &&
17
- arg1 && tmpc->aux1==arg1 || !arg1 && tmpc->aux2==arg2) {
18
- QueRem(tmpc);
19
- JobDel(tmpc);
20
- }
21
- tmpc=tmpc1;
22
- }
23
- }
24
-
25
- #define MT_NULL 0
26
- #define MT_MSG 1
27
- #define MT_CHAR 2
28
-
29
- class CMacroTmp
30
- {
31
- CMacroTmp *next,*last;
32
- I64 type;
33
- U8 buf[STR_LEN];
34
- };
35
-
36
- CMacroTmp *Cmd2MT(CJob *tmpc)
37
- {
38
- U8 buf[8];
39
- CMacroTmp *tmpmt=CAlloc(sizeof(CMacroTmp));
40
- if (Bt(char_bmp_macro,tmpc->aux1) && tmpc->msg_code==MSG_KEY_DOWN) {
41
- tmpmt->type=MT_CHAR;
42
- buf[0]=tmpc->aux1;
43
- buf[1]=0;
44
- StrPrint(tmpmt->buf,"%Q",buf);
45
- } else {
46
- tmpmt->type=MT_MSG;
47
- StrPrint(tmpmt->buf,"Msg(0x%X,0x%X,0x%X);",
48
- tmpc->msg_code,tmpc->aux1,tmpc->aux2);
49
- }
50
- return tmpmt;
51
- }
52
-
53
- U8 *SysMacro2Str(CJob *macro_head)
54
- {
55
- CJob *tmpc;
56
- I64 cnt=1; //terminating zero
57
- U8 *ptr,*m;
58
- CMacroTmp *tmpmt,*tmpmt1,head;
59
- LBtr(&sys_semas[SEMA_RECORD_MACRO],0);
60
-
61
- QueInit(&head);
62
- head.type=MT_NULL;
63
- tmpc=macro_head->next;
64
- while (tmpc!=macro_head) {
65
- tmpmt=Cmd2MT(tmpc);
66
- QueIns(tmpmt,head.last);
67
- cnt+=StrLen(tmpmt->buf);
68
- if (tmpmt->type==MT_CHAR) {
69
- if (tmpmt->last->type!=MT_CHAR)
70
- cnt+=StrLen("\"");
71
- if (tmpmt->next->type!=MT_CHAR)
72
- cnt+=StrLen("\";");
73
- }
74
- tmpc=tmpc->next;
75
- }
76
-
77
- m=MAlloc(cnt);
78
- ptr=m;
79
-
80
- tmpmt=head.next;
81
- while (tmpmt!=&head) {
82
- tmpmt1=tmpmt->next;
83
- if (tmpmt->type==MT_MSG) {
84
- StrCpy(ptr, tmpmt->buf);
85
- ptr+=StrLen(tmpmt->buf);
86
- } else {
87
- if (tmpmt->last->type!=MT_CHAR) {
88
- StrCpy(ptr, "\"");
89
- ptr+=StrLen("\"");
90
- }
91
- StrCpy(ptr,tmpmt->buf);
92
- ptr+=StrLen(tmpmt->buf);
93
- if (tmpmt->next->type!=MT_CHAR) {
94
- StrCpy(ptr, "\";");
95
- ptr+=StrLen("\";");
96
- }
97
- }
98
- Free(tmpmt);
99
- tmpmt=tmpmt1;
100
- }
101
- *ptr=0;
102
- return m;
103
- }
104
-
105
- U0 PlaySysMacro(I64 n=1)
106
- {
107
- CTask *task=sys_focus_task;
108
- U8 *m;
109
- if (TaskValidate(task)) {
110
- LBtr(&sys_semas[SEMA_RECORD_MACRO],0);
111
- m=SysMacro2Str(&sys_macro_head);
112
- while (n-- && TaskValidate(task)) {
113
- if (task==Fs)
114
- InStr("%s",m);
115
- else
116
- XTalkStrWait(task,"%s",m);
117
- }
118
- Free(m);
119
- }
120
- }
121
-
122
- U0 EdInsCapturedMacro()
123
- {
124
- U8 *st=SysMacro2Str(&sys_macro_head);
125
- if (sys_focus_task) {
126
- XTalk(sys_focus_task,"$$MA+LIS,T=\"%s\",LM=\"%$$Q\"$$",
127
- captured_macro_name,st);
128
- Free(st);
129
- }
130
- }
131
-
132
- #define SM_RECORD 0
133
- #define SM_INS 1
134
- #define SM_PLAY 2
135
- #define SM_REPEAT_N 3
136
- #define SM_STOP 4
137
-
138
- I64 PopUpMacroMenu()
139
- {
140
- I64 res=0;
141
- U8 buf[STR_LEN];
142
- CJob *tmpc;
143
- CDoc *doc=DocNew;
144
- CDocEntry *doc_e=DocPrint(doc,"$$DA-P,LEN=STR_LEN-1,A=\"Name:%%s\"$$");
145
- doc_e->data=captured_macro_name;
146
- DocDataFmt(doc,doc_e);
147
-
148
- doc_e=DocPrint(doc,"\n$$DA,A=\"Repeat N:%%d\"$$");
149
- doc_e->data=&sys_macro_repeat_n;
150
- DocDataFmt(doc,doc_e);
151
-
152
- DocPrint(doc,"\n"
153
- "$$CM+LX,1,3$$$$BT,\"RECORD\",LE=SM_RECORD$$"
154
- "$$CM+LX,17,0$$$$BT,\"INSERT\",LE=SM_INS$$"
155
- "$$CM+LX,1,3$$$$BT,\"PLAY\",LE=SM_PLAY$$"
156
- "$$CM+LX,17,0$$$$BT,\"REPEAT N\",LE=SM_REPEAT_N$$"
157
- "$$CM+LX,1,3$$$$BT,\"STOP\",LE=SM_STOP$$"
158
- "$$CM+LX,17,0$$$$BT,\"CANCEL\",LE=DOCM_CANCEL$$"
159
- "\n\n\n$$GREEN$$SHIFT-F2$$FG$$ will play macro.\n");
160
- doc->flags|=DOCF_SIZE_MIN | DOCF_FORM;
161
- StrPrint(buf,"DocMenu(%d);",doc);
162
- sys_macro_task=Spawn(&SrvCmdLine,NULL,"Macro Popup",,Fs);
163
- Fs->popup_task=sys_macro_task;
164
- LBts(&sys_macro_task->display_flags,DISPLAYf_WIN_ON_TOP);
165
- tmpc=TaskExe(sys_macro_task,Fs,buf,
166
- 1<<JOBf_WAKE_MASTER|1<<JOBf_FOCUS_MASTER);
167
- JobResScan(tmpc,&res);
168
- Fs->popup_task=NULL;
169
- Kill(sys_macro_task);
170
- sys_macro_task=NULL;
171
- DocDataScan(doc,doc_e);
172
- DocDel(doc);
173
- return res;
174
- }
175
-
176
- U0 MacroTask(I64)
177
- {
178
- I64 i;
179
- StrCpy(captured_macro_name,"Click Here");
180
- sys_macro_repeat_n=1;
181
- do {
182
- i=PopUpMacroMenu;
183
- WinRefocus(sys_focus_task);
184
- switch (i) {
185
- case SM_RECORD:
186
- LBtr(&sys_semas[SEMA_RECORD_MACRO],0);
187
- QueDel(&sys_macro_head,TRUE);
188
- LBts(&sys_semas[SEMA_RECORD_MACRO],0);
189
- break;
190
- case SM_PLAY:
191
- PlaySysMacro;
192
- break;
193
- case SM_REPEAT_N:
194
- PlaySysMacro(sys_macro_repeat_n);
195
- break;
196
- case SM_STOP:
197
- LBtr(&sys_semas[SEMA_RECORD_MACRO],0);
198
- break;
199
- case SM_INS:
200
- LBtr(&sys_semas[SEMA_RECORD_MACRO],0);
201
- EdInsCapturedMacro;
202
- break;
203
- }
204
- } while (i>=0);
205
- }
206
-
207
- U0 EdMacroUtil()
208
- {
209
- if (!sys_macro_task)
210
- Spawn(&MacroTask,NULL,"Macro");
211
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:4f77cd40ed193dd35d4e88ef650e32902dd73f451abb245b68f1b65e8110be37
3
+ size 4585
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/DolDoc/DocNew.HC CHANGED
@@ -1,385 +1,3 @@
1
- #help_index "DolDoc"
2
-
3
- public Bool DocLock(CDoc *doc)
4
- {//Make this task have exclusive access to this doc.
5
- if (!Bt(&doc->locked_flags,DOClf_LOCKED) || doc->owning_task!=Fs) {
6
- while (LBts(&doc->locked_flags,DOClf_LOCKED))
7
- Yield;
8
- if (doc->owning_task!=Fs)
9
- LBEqu(&doc->flags,DOCf_BREAK_UNLOCKED,BreakLock(Fs));
10
- doc->owning_task=Fs;
11
- return TRUE;
12
- } else
13
- return FALSE;
14
- }
15
-
16
- public Bool DocUnlock(CDoc *doc)
17
- {//Release exclusive lock on access to doc.
18
- Bool unlock_break;
19
- if (Bt(&doc->locked_flags,DOClf_LOCKED) && doc->owning_task==Fs) {
20
- doc->owning_task=0;
21
- unlock_break=Bt(&doc->flags,DOCf_BREAK_UNLOCKED);
22
- LBtr(&doc->locked_flags,DOClf_LOCKED);
23
- if (unlock_break)
24
- BreakUnlock(Fs);
25
- return TRUE;
26
- } else
27
- return FALSE;
28
- }
29
-
30
- Bool IsEditableText(CDocEntry *doc_e)
31
- {
32
- if (doc_e->type_u8==DOCT_TEXT&&!(doc_e->de_flags&DOCEG_DONT_EDIT))
33
- return TRUE;
34
- else
35
- return FALSE;
36
- }
37
-
38
- CDocEntry *DocEntryNewBase(CDoc *doc,I64 type,I64 de_flags=0,
39
- I64 x=0,I64 y=0,I64 page_line_num=0)
40
- {//See also $LK,"MAllocIdent",A="FF:::/Adam/DolDoc/DocRecalc.HC,MAllocIdent"$ and $MA-X+PU,"CDocEntry",LM="F(\"sizeof(CDocEntry)\");View;"$.
41
- CDocEntry *res=CAlloc(sizeof(CDocEntryBase),doc->mem_task);
42
- res->type=type;
43
- res->de_flags=de_flags|doldoc.dft_de_flags[type.u8[0]];
44
- res->x=x;
45
- res->y=y;
46
- res->page_line_num=page_line_num;
47
- return res;
48
- }
49
-
50
- CDocEntry *DocEntryNewTag(CDoc *doc,CDocEntry *doc_ce,U8 *tag)
51
- {
52
- I64 l=StrLen(tag);
53
- CDocEntry *res=DocEntryNewBase(doc,doc_ce->type,doc_ce->de_flags,
54
- doc_ce->x,doc_ce->y,doc_ce->page_line_num);
55
- res->de_flags=doc_ce->de_flags; //Override
56
- res->max_col=l;
57
- res->tag=MAlloc(l+1,doc->mem_task);
58
- MemCpy(res->tag,tag,l+1);
59
- MemCpy(&res->settings,&doc_ce->settings,sizeof(CDocSettings));
60
- return res;
61
- }
62
-
63
- public U0 DocEntryDel(CDoc *doc,CDocEntry *doc_e)
64
- {//Free entry and all parts of entry.
65
- if (!doc || doc==doc_e)
66
- RawPrint(3000,"DocEntryDel");
67
- else {
68
- if (doc->cur_entry==doc_e)
69
- doc->cur_entry=doc_e->next;
70
- QueRem(doc_e);
71
- if (doc_e->de_flags & DOCEF_TAG)
72
- Free(doc_e->tag);
73
- if (doc_e->de_flags & DOCEF_AUX_STR)
74
- Free(doc_e->aux_str);
75
- if (doc_e->de_flags & DOCEF_DEFINE)
76
- Free(doc_e->define_str);
77
- if (doc_e->de_flags & DOCEF_HTML_LINK)
78
- Free(doc_e->html_link);
79
- if (doc_e->de_flags & DOCEF_LEFT_MACRO)
80
- Free(doc_e->left_macro);
81
- if (doc_e->de_flags & DOCEF_RIGHT_MACRO)
82
- Free(doc_e->right_macro);
83
- if (doc_e->de_flags & DOCEF_BIN_PTR_LINK)
84
- Free(doc_e->bin_ptr_link);
85
- if (doc_e->de_flags & DOCEF_HAS_BIN)
86
- DocBinDel(doc,doc_e->bin_data);
87
- if (doc_e->de_flags & DOCEF_REMALLOC_DATA)
88
- Free(doc_e->data);
89
- Free(doc_e);
90
- }
91
- }
92
-
93
- public I64 DocEntrySize(CDoc *,CDocEntry *doc_e)
94
- {//Mem size of entry and all parts.
95
- I64 res;
96
- if (!doc_e) return 0;
97
- res=MSize2(doc_e);
98
- if (doc_e->de_flags & DOCEF_TAG)
99
- res+=MSize2(doc_e->tag);
100
- if (doc_e->de_flags & DOCEF_AUX_STR)
101
- res+=MSize2(doc_e->aux_str);
102
- if (doc_e->de_flags & DOCEF_DEFINE)
103
- res+=MSize2(doc_e->define_str);
104
- if (doc_e->de_flags & DOCEF_HTML_LINK)
105
- res+=MSize2(doc_e->html_link);
106
- if (doc_e->de_flags & DOCEF_LEFT_MACRO)
107
- res+=MSize2(doc_e->left_macro);
108
- if (doc_e->de_flags & DOCEF_RIGHT_MACRO)
109
- res+=MSize2(doc_e->right_macro);
110
- if (doc_e->de_flags & DOCEF_BIN_PTR_LINK)
111
- res+=MSize2(doc_e->bin_ptr_link);
112
- if (doc_e->de_flags & DOCEF_REMALLOC_DATA)
113
- res+=MSize2(doc_e->data);
114
- return res;
115
- }
116
-
117
- U0 DocUndoDel(CDoc *,CDocUndo *u)
118
- {
119
- Free(u->body);
120
- Free(u);
121
- }
122
-
123
- U0 DocUndoCntSet(CDoc *doc)
124
- {
125
- Bool unlock=DocLock(doc);
126
- CDocUndo *u=doc->undo_head.next;
127
- doc->undo_cnt=0;
128
- while (u!=&doc->undo_head) {
129
- doc->undo_cnt++;
130
- u=u->next;
131
- }
132
- if (unlock)
133
- DocUnlock(doc);
134
- }
135
-
136
- public CDocEntry *DocEntryCopy(CDoc *doc,CDocEntry *doc_e)
137
- {//Make copy of entry and all parts of entry.
138
- CDocEntry *doc_ne;
139
- CDocBin *tmpb;
140
- CTask *task=doc->mem_task;
141
- doc_ne=MAllocIdent(doc_e,task);
142
- doc_ne->next=doc_ne;
143
- doc_ne->last=doc_ne;
144
- if (doc_e->de_flags & DOCEF_TAG)
145
- doc_ne->tag=MAllocIdent(doc_e->tag,task);
146
- if (doc_e->de_flags & DOCEF_AUX_STR)
147
- doc_ne->aux_str=MAllocIdent(doc_e->aux_str,task);
148
- if (doc_e->de_flags & DOCEF_DEFINE)
149
- doc_ne->define_str=MAllocIdent(doc_e->define_str,task);
150
- if (doc_e->de_flags & DOCEF_HTML_LINK)
151
- doc_ne->html_link=MAllocIdent(doc_e->html_link,task);
152
- if (doc_e->de_flags & DOCEF_LEFT_MACRO)
153
- doc_ne->left_macro=MAllocIdent(doc_e->left_macro,task);
154
- if (doc_e->de_flags & DOCEF_RIGHT_MACRO)
155
- doc_ne->right_macro=MAllocIdent(doc_e->right_macro,task);
156
- if (doc_e->de_flags & DOCEF_BIN_PTR_LINK)
157
- doc_ne->bin_ptr_link=MAllocIdent(doc_e->bin_ptr_link,task);
158
- if (doc_e->de_flags & DOCEF_HAS_BIN) {
159
- tmpb=MAllocIdent(doc_e->bin_data,task);
160
- tmpb->data=MAllocIdent(doc_e->bin_data->data,task);
161
- doc_ne->bin_num=doc->cur_bin_num;
162
- tmpb->num=doc->cur_bin_num++;
163
- doc_ne->bin_data=tmpb;
164
- if (doc_e->de_flags&DOCEF_TAG && doc_e->tag && *doc_e->tag)
165
- tmpb->tag=StrNew(doc_e->tag,task);
166
- else
167
- tmpb->tag=NULL;
168
- QueIns(tmpb,doc->bin_head.last);
169
- }
170
- if (doc_e->de_flags & DOCEF_REMALLOC_DATA)
171
- doc_ne->data=MAllocIdent(doc_e->data,task);
172
- return doc_ne;
173
- }
174
-
175
- U0 DocRemSoftNewLines(CDoc *doc=NULL,CDocEntry *doc_e=NULL)
176
- {
177
- CDocEntry *doc_e2,*saved_ll=doc_e;
178
- Bool unlock;
179
- if (!doc && !(doc=DocPut))
180
- return;
181
- unlock=DocLock(doc);
182
- if (!doc_e) doc_e=doc->head.next;
183
- while (doc_e!=doc) {
184
- doc_e2=doc_e->next;
185
- if (doc_e->type_u8==DOCT_SOFT_NEW_LINE) {
186
- if (doc->cur_entry==doc_e) {
187
- doc->cur_entry=doc_e2;
188
- doc->cur_col=doc->cur_entry->min_col;
189
- }
190
- DocEntryDel(doc,doc_e);
191
- } else if (saved_ll && doc_e->type_u8==DOCT_NEW_LINE)
192
- break;
193
- doc_e=doc_e2;
194
- }
195
- if (unlock)
196
- DocUnlock(doc);
197
- }
198
-
199
- public U0 DocInsEntry(CDoc *doc,CDocEntry *doc_e)
200
- {//Insert entry into doc, updating its vals.
201
- U8 *dst;
202
- Bool unlock=DocLock(doc);
203
- CDocEntry *doc_ce=doc->cur_entry,*doc_ne;
204
-
205
- doc_e->x=doc_ce->x;
206
- doc_e->y=doc_ce->y;
207
- doc_e->page_line_num=doc_ce->page_line_num;
208
- MemCpy(&doc_e->settings,&doc_ce->settings,sizeof(CDocSettings));
209
- if (doc->cur_col>0 &&
210
- doc_ce->type_u8==DOCT_TEXT &&
211
- !(doc_ce->de_flags&(DOCEF_TAG_CB|DOCEF_DEFINE|DOCEF_AUX_STR|
212
- DOCEF_HTML_LINK|DOCEF_BIN_PTR_LINK)) &&
213
- doc->cur_col<doc_ce->max_col) {
214
- dst=doc_ce->tag+doc->cur_col;
215
- doc_ne=DocEntryNewTag(doc,doc_ce,dst);
216
- *dst=0;
217
- doc_ne->type=DOCT_TEXT|doc_ce->type&0xFFFFFF00;
218
- doc_ce->max_col=doc->cur_col;
219
- QueIns(doc_ne,doc_ce);
220
- doc->cur_col=0;
221
- doc_ce=doc_ne;
222
- }
223
- if (doc_ce->type_u8==DOCT_TEXT && doc->cur_col>=doc_ce->max_col) {
224
- QueIns(doc_e,doc_ce);
225
- doc->cur_entry=doc_e->next;
226
- } else {
227
- QueIns(doc_e,doc_ce->last);
228
- doc->cur_entry=doc_ce;
229
- }
230
- doc->cur_col=doc->cur_entry->min_col;
231
- DocRemSoftNewLines(doc,doc->cur_entry);
232
- if (unlock)
233
- DocUnlock(doc);
234
- }
235
-
236
- public U0 DocRst(CDoc *doc,Bool is_old)
237
- {//Del all entries and set doc to dfts.
238
- Bool unlock;
239
- CDocEntry *doc_e,*doc_e2;
240
- CDocUndo *u,*u8;
241
- CDocSettings *s;
242
- CDocBin *b,*b1;
243
- if (!doc && !(doc=DocPut))
244
- return;
245
- unlock=DocLock(doc);
246
- if (is_old) {
247
- doc_e=doc->head.next;
248
- while (doc_e!=doc) {
249
- doc_e2=doc_e->next;
250
- DocEntryDel(doc,doc_e);
251
- doc_e=doc_e2;
252
- }
253
- u=doc->undo_head.next;
254
- while (u!=&doc->undo_head) {
255
- u8=u->next;
256
- DocUndoDel(doc,u);
257
- u=u8;
258
- }
259
- b=doc->bin_head.next;
260
- while (b!=&doc->bin_head) {
261
- b1=b->next;
262
- QueRem(b);
263
- Free(b->data);
264
- Free(b);
265
- b=b1;
266
- }
267
- }
268
- //Check $LK,"DocInsDoc",A="MN:DocInsDoc"$
269
- doc->flags&=DOCF_BREAK_UNLOCKED;
270
- doc->head.next=doc->head.last=doc;
271
- QueInit(&doc->bin_head);
272
- QueInit(&doc->undo_head);
273
- doc->undo_head.time_stamp=0;
274
- doc->undo_cnt=0;
275
- doc->cur_bin_num=1;
276
- doc->dollar_buf_ptr=0;
277
- doc->cmd_U8=CH_SPACE;
278
- doc->page_line_num=0;
279
- doc->best_d=I64_MAX;
280
-
281
- s=&doc->settings_head;
282
- s->left_margin=DOC_DFT;
283
- s->right_margin=DOC_DFT;
284
- s->indent=0;
285
- s->page_len=66;
286
- s->header=DOC_DFT;
287
- s->footer=DOC_DFT;
288
- s->state=DOCSS_NORMAL;
289
- s->comment_depth=0;
290
- s->paren_depth=0;
291
- s->brace_depth=0;
292
- s->shifted_x=0;
293
- s->shifted_y=0;
294
- s->cur_text_attr=s->dft_text_attr=DOC_ATTR_DFT_TEXT;
295
-
296
- doc_e=&doc->head;
297
- doc_e->type=DOCT_ERROR;
298
- doc_e->de_flags=0;
299
- doc_e->x=0;
300
- doc_e->y=0;
301
- doc_e->min_col=0;
302
- doc_e->max_col=0;
303
- doc_e->page_line_num=doc->page_line_num;
304
- MemCpy(&doc_e->settings,s,sizeof(CDocSettings));
305
-
306
- DocTop(doc);
307
- if (unlock)
308
- DocUnlock(doc);
309
- }
310
-
311
- public U0 DocDel(CDoc *doc)
312
- {//Free entire doc and entries.
313
- if (!doc || doc->doc_signature!=DOC_SIGNATURE_VAL) return;
314
- DocLock(doc);
315
- doc->doc_signature=0;
316
- DocRst(doc,TRUE);
317
- Free(doc->find_replace);
318
- Free(doc->dollar_buf);
319
- DocUnlock(doc);
320
- Free(doc);
321
- }
322
-
323
- public I64 DocSize(CDoc *doc)
324
- {//Mem size of doc and all its entries.
325
- Bool unlock;
326
- CDocEntry *doc_e;
327
- CDocUndo *u;
328
- CDocBin *b;
329
- I64 res=0;
330
-
331
- if (!doc || doc->doc_signature!=DOC_SIGNATURE_VAL) return 0;
332
- unlock=DocLock(doc);
333
-
334
- doc_e=doc->head.next;
335
- while (doc_e!=doc) {
336
- res+=DocEntrySize(doc,doc_e);
337
- doc_e=doc_e->next;
338
- }
339
-
340
- u=doc->undo_head.next;
341
- while (u!=&doc->undo_head) {
342
- res+=MSize2(u->body);
343
- res+=MSize2(u);
344
- u=u->next;
345
- }
346
-
347
- b=doc->bin_head.next;
348
- while (b!=&doc->bin_head) {
349
- res+=MSize2(b->data);
350
- res+=MSize2(b);
351
- b=b->next;
352
- }
353
-
354
- res+=MSize2(doc->find_replace);
355
- res+=MSize2(doc->dollar_buf);
356
- res+=MSize2(doc);
357
- if (unlock)
358
- DocUnlock(doc);
359
- return res;
360
- }
361
-
362
- #help_index "DolDoc"
363
- public CDoc *DocNew(U8 *filename=NULL,CTask *task=NULL)
364
- {//MAlloc new $LK,"DolDoc",A="FI:::/Doc/DolDocOverview.DD"$. (Begin a new doc.)
365
- CDoc *doc;
366
- if (!task) task=Fs;
367
- doc=CAlloc(sizeof(CDoc),task);
368
- if (filename)
369
- StrCpy(doc->filename.name,filename);
370
- else
371
- StrCpy(doc->filename.name,blkdev.tmp_filename);
372
- doc->find_replace=CAlloc(sizeof(CEdFindText),task);
373
- doc->find_replace->scan_fwd=TRUE;
374
- doc->find_replace->match_case=TRUE;
375
- doc->find_replace->pmt=TRUE;
376
- doc->left_click_link=&EdLeftClickLink;
377
- doc->dollar_buf_size=84;
378
- doc->dollar_buf=MAlloc(doc->dollar_buf_size,task);
379
- doc->max_entries=I64_MAX;
380
- doc->win_task=task;
381
- doc->mem_task=task;
382
- DocRst(doc,FALSE);
383
- doc->doc_signature=DOC_SIGNATURE_VAL;
384
- return doc;
385
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:c98920a4cb23a0dbbbdbc45367d5c65aa6963a886b03869d5940c3ee13bc6f6f
3
+ size 10277
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/DolDoc/DocPlain.HC CHANGED
@@ -1,611 +1,3 @@
1
- #help_index "DolDoc"
2
-
3
- I64 PrsDocFlagSingle(CCmpCtrl *cc,I64 *_de_flags,U32 *_type,Bool turn_on)
4
- {
5
- I64 res=-1;
6
- CHashGeneric *tmph;
7
- if (cc->token==TK_IDENT &&
8
- (tmph=HashFind(cc->cur_str,doldoc.hash,DHT_DOC_FLAG))) {
9
- res=tmph->user_data0;
10
- if (res<64) {
11
- BEqu(_de_flags,res,turn_on);
12
- switch (res) {
13
- case DOCEf_BLINK:
14
- case DOCEf_INVERT:
15
- case DOCEf_UNDERLINE:
16
- case DOCEf_SEL:
17
- BEqu(_type,res,turn_on);
18
- break;
19
- }
20
- }
21
- Lex(cc); //skip flag
22
- }
23
- return res;
24
- }
25
-
26
- I64 PrsDocFlags(CCmpCtrl *cc,I64 *_de_flags,U32 *_type)
27
- {
28
- I64 res=-1;
29
- Bool turn_on;
30
- while (TRUE) {
31
- if (cc->token=='+')
32
- turn_on=TRUE;
33
- else if (cc->token=='-')
34
- turn_on=FALSE;
35
- else
36
- break;
37
- Lex(cc);
38
- res=PrsDocFlagSingle(cc,_de_flags,_type,turn_on);
39
- }
40
- return res;
41
- }
42
-
43
- U8 *Doc2PlainText(CDoc *doc,CDocEntry *doc_e)
44
- {//TODO: break strs
45
- I64 i,j,attr=doc_e->attr,
46
- t1,f1,de_flags,type;
47
- U8 *buf,*buf2;
48
-
49
- if (doc_e->type_u8==DOCT_FOREGROUND &&
50
- doc->flags&DOCF_COLOR_NAMES && 0<=attr<COLORS_NUM) {
51
- buf=StrNew(DefineSub(attr,"ST_COLORS"));
52
- attr=DOC_DFT;
53
- } else
54
- buf=StrNew(DefineSub(doc_e->type_u8,"ST_DOC_CMDS"));
55
- if (doc_e->type_u8!=DOCT_ERROR) {
56
- f1=doldoc.dft_de_flags[doc_e->type_u8];
57
- t1=doc_e->type_u8|doldoc.dft_type_flags[doc_e->type_u8];
58
-
59
- de_flags=doc_e->de_flags&~(DOCG_BL_IV_UL|DOCEF_SEL|
60
- DOCEF_HIGHLIGHT|DOCEF_WORD_WRAP|DOCEF_SKIP|DOCEF_FILTER_SKIP);
61
- for (i=0;i<DOCEf_FLAGS_NUM;i++)
62
- if (Bt(&f1,i)!=Bt(&de_flags,i)) {
63
- if (Bt(&de_flags,i)) {
64
- if (!(1<<i&DOCEG_HAS_ARG)) {
65
- buf2=MStrPrint("%s+%Z",buf,i,"ST_DOC_FLAGS");
66
- Free(buf); buf=buf2;
67
- }
68
- } else {
69
- buf2=MStrPrint("%s-%Z",buf,i,"ST_DOC_FLAGS");
70
- Free(buf); buf=buf2;
71
- }
72
- }
73
- type=doc_e->type&~DOCET_SEL;
74
- for (i=DOCEt_BLINK;i<=DOCEt_UNDERLINE;i++)
75
- if (Bt(&t1,i)!=Bt(&type,i)) {
76
- if (Bt(&type,i))
77
- buf2=MStrPrint("%s+%Z",buf,i,"ST_DOC_FLAGS");
78
- else
79
- buf2=MStrPrint("%s-%Z",buf,i,"ST_DOC_FLAGS");
80
- Free(buf); buf=buf2;
81
- }
82
- buf2=MStrPrint("%s,",buf);
83
- Free(buf); buf=buf2;
84
- switch [doc_e->type_u8] {
85
- case DOCT_HEX_ED:
86
- buf2=MStrPrint("%s%d,",buf,doc_e->len);
87
- Free(buf); buf=buf2;
88
- buf2=MStrPrint("%s%d,",buf,doc_e->hex_ed_width);
89
- Free(buf); buf=buf2;
90
- break;
91
- case DOCT_FOREGROUND:
92
- case DOCT_BACKGROUND:
93
- case DOCT_DFT_FOREGROUND:
94
- case DOCT_DFT_BACKGROUND:
95
- if (doc->flags&DOCF_COLOR_NAMES && 0<=attr<COLORS_NUM) {
96
- buf2=MStrPrint("%s%Z,",buf,doc_e->attr,"ST_COLORS");
97
- Free(buf); buf=buf2;
98
- break;
99
- }
100
- case DOCT_PAGE_LEN:
101
- case DOCT_LEFT_MARGIN:
102
- case DOCT_RIGHT_MARGIN:
103
- case DOCT_HEADER:
104
- case DOCT_FOOTER:
105
- case DOCT_INDENT:
106
- case DOCT_WORD_WRAP:
107
- case DOCT_HIGHLIGHT:
108
- case DOCT_BLINK:
109
- case DOCT_INVERT:
110
- case DOCT_UNDERLINE:
111
- case DOCT_SHIFTED_X:
112
- case DOCT_SHIFTED_Y:
113
- if (attr!=DOC_DFT) {
114
- buf2=MStrPrint("%s%d,",buf,doc_e->attr);
115
- Free(buf); buf=buf2;
116
- }
117
- case DOCT_TYPES_NUM-1: //nobound switch
118
- break;
119
- }
120
- de_flags=doc_e->de_flags & DOCEG_HAS_ARG;
121
- while (de_flags) {
122
- j=Bsf(de_flags);
123
- Btr(&de_flags,j);
124
- switch [j] {
125
- case DOCEf_TAG:
126
- if (doc_e->type_u8==DOCT_DATA || doc_e->type_u8==DOCT_MACRO &&
127
- (doc_e->de_flags&DOCEF_LEFT_MACRO &&
128
- !StrCmp(doc_e->tag,doc_e->left_macro) ||
129
- doc_e->de_flags&DOCEF_RIGHT_MACRO &&
130
- !StrCmp(doc_e->tag,doc_e->right_macro)) ||
131
- doc_e->de_flags&DOCEF_LST && !StrCmp(doc_e->tag,"[]") &&
132
- doc_e->de_flags&DOCEF_DEFINE) {
133
- buf2=buf;
134
- buf=NULL;
135
- } else {
136
- if (doc_e->type_u8==DOCT_CHECK_BOX) {
137
- if (StrLen(doc_e->tag)>=4)
138
- buf2=doc_e->tag+4;
139
- else
140
- buf2="";
141
- } else if (doc_e->de_flags & DOCEF_TREE) {
142
- if (StrLen(doc_e->tag)>=3)
143
- buf2=doc_e->tag+3;
144
- else
145
- buf2="";
146
- } else
147
- buf2=doc_e->tag;
148
- if (Bt(&doldoc.dft_de_flags[doc_e->type_u8],DOCEf_TAG))
149
- buf2=MStrPrint("%s\"%$$Q\",",buf,buf2);
150
- else
151
- buf2=MStrPrint("%sT=\"%$$Q\",",buf,buf2);
152
- }
153
- break;
154
- case DOCEf_LEN:
155
- buf2=MStrPrint("%sLEN=%d,",buf,doc_e->len);
156
- break;
157
- case DOCEf_AUX_STR:
158
- buf2=MStrPrint("%sA=\"%$$Q\",",buf,doc_e->aux_str);
159
- break;
160
- case DOCEf_DEFINE:
161
- buf2=MStrPrint("%sD=\"%$$Q\",",buf,doc_e->define_str);
162
- break;
163
- case DOCEf_HTML_LINK:
164
- buf2=MStrPrint("%sHTML=\"%$$Q\",",buf,doc_e->html_link);
165
- break;
166
- case DOCEf_LEFT_EXP:
167
- buf2=MStrPrint("%sLE=%d,",buf,doc_e->left_exp);
168
- break;
169
- case DOCEf_LEFT_MACRO:
170
- buf2=MStrPrint("%sLM=\"%$$Q\",",buf,doc_e->left_macro);
171
- break;
172
- case DOCEf_RIGHT_EXP:
173
- buf2=MStrPrint("%sRE=%d,",buf,doc_e->right_exp);
174
- break;
175
- case DOCEf_RIGHT_MACRO:
176
- buf2=MStrPrint("%sRM=\"%$$Q\",",buf,doc_e->right_macro);
177
- break;
178
- case DOCEf_HAS_BIN:
179
- buf2=MStrPrint("%sBI=%d,",buf,doc_e->bin_num);
180
- break;
181
- case DOCEf_BIN_PTR_LINK:
182
- buf2=MStrPrint("%sBP=\"%$$Q\",",buf,doc_e->bin_ptr_link);
183
- break;
184
- case DOCEf_RAW_TYPE:
185
- if (doc_e->type_u8==DOCT_CHECK_BOX&&doc_e->raw_type!=RT_I8 ||
186
- doc_e->type_u8!=DOCT_CHECK_BOX&&doc_e->raw_type!=RT_I64)
187
- buf2=MStrPrint("%sRT=%Z,",buf,doc_e->raw_type,"ST_RAW_TYPES");
188
- break;
189
- case DOCEf_SHIFTED_X:
190
- j=doc_e->type.u16[1]&0x1F;
191
- if (j&0x10) j|=0xFFFFFFF0;
192
- buf2=MStrPrint("%sSX=%d,",buf,j);
193
- break;
194
- case DOCEf_SHIFTED_Y:
195
- j=doc_e->type>>21 &0x1F;
196
- if (j&0x10) j|=0xFFFFFFF0;
197
- buf2=MStrPrint("%sSY=%d,",buf,j);
198
- break;
199
- case DOCEf_SCROLLING_X:
200
- buf2=MStrPrint("%sSCX=%d,",buf,doc_e->scroll_len);
201
- break;
202
- case DOCEf_USER_DATA:
203
- buf2=MStrPrint("%sU=0x%X,",buf,doc_e->user_data);
204
- break;
205
- case DOCEf_FLAGS_NUM-1: //nobound switch
206
- break;
207
- }
208
- Free(buf); buf=buf2;
209
- }
210
- buf[StrLen(buf)-1]=0; //Kill last comma
211
- }
212
- buf2=StrNew(buf,doc->mem_task); //exact allocation
213
- Free(buf);
214
- return buf2;
215
- }
216
-
217
- CDocEntry *PrsDollarCmd(CDoc *doc,U8 *st)
218
- {//Uses $LK-UL,"Lex",A="MN:Lex"$() to parse a string and make Doc entries.
219
- I64 i,j,de_flags,processed_flags,attr=DOC_DFT;
220
- U8 *ptr,*st2;
221
- CDocEntry *doc_e=NULL;
222
- CHashGeneric *tmph;
223
- CCmpCtrl *cc=CmpCtrlNew(st,CCF_DONT_FREE_BUF);
224
- CHashTable *old_hash_table_lst=cc->htc.hash_table_lst;
225
- try {
226
- cc->htc.hash_table_lst=NULL;
227
- if (Lex(cc)==TK_IDENT) {
228
- if (tmph=HashFind(cc->cur_str,doldoc.hash,DHT_DOC_CMD|DHT_COLOR)) {
229
- if (tmph->type&DHT_DOC_CMD)
230
- i=tmph->user_data0;
231
- else {//DHT_COLOR
232
- i=DOCT_FOREGROUND;
233
- attr=tmph->user_data0;
234
- }
235
- } else
236
- goto pd_err;
237
- Lex(cc); //skip cmd code
238
- doc_e=CAlloc(sizeof(CDocEntry),doc->mem_task);
239
- doc_e->type=i;
240
- doc_e->de_flags=doldoc.dft_de_flags[i];
241
- doc_e->type|=doldoc.dft_type_flags[i];
242
- doc_e->raw_type=RT_I64;
243
- doc_e->len=DOCE_LEN_DFT;
244
- j=PrsDocFlags(cc,&doc_e->de_flags,&doc_e->type);
245
- cc->htc.hash_table_lst=old_hash_table_lst;
246
- switch [i] {
247
- case DOCT_CHECK_BOX:
248
- doc_e->raw_type=RT_I8;
249
- break;
250
- case DOCT_HEX_ED:
251
- while (cc->token==',')
252
- Lex(cc);
253
- if (cc->token)
254
- doc_e->len=LexExpressionI64(cc);
255
- else
256
- goto pd_err;
257
- while (cc->token==',')
258
- Lex(cc);
259
- if (cc->token)
260
- doc_e->hex_ed_width=LexExpressionI64(cc);
261
- else
262
- goto pd_err;
263
- break;
264
- case DOCT_PAGE_LEN:
265
- case DOCT_LEFT_MARGIN:
266
- case DOCT_RIGHT_MARGIN:
267
- case DOCT_HEADER:
268
- case DOCT_FOOTER:
269
- case DOCT_INDENT:
270
- case DOCT_FOREGROUND:
271
- case DOCT_BACKGROUND:
272
- case DOCT_DFT_FOREGROUND:
273
- case DOCT_DFT_BACKGROUND:
274
- case DOCT_WORD_WRAP:
275
- case DOCT_HIGHLIGHT:
276
- case DOCT_BLINK:
277
- case DOCT_INVERT:
278
- case DOCT_UNDERLINE:
279
- case DOCT_SHIFTED_X:
280
- case DOCT_SHIFTED_Y:
281
- while (cc->token==',')
282
- Lex(cc);
283
- if (cc->token)
284
- doc_e->attr=LexExpressionI64(cc);
285
- else
286
- doc_e->attr=attr;
287
- break;
288
- #assert DOCT_ERROR==DOCT_TYPES_NUM-1
289
- case DOCT_ERROR:
290
- goto pd_err;
291
- }
292
-
293
- processed_flags=0;
294
- while (TRUE) {
295
- cc->htc.hash_table_lst=NULL;
296
- while (cc->token==',')
297
- Lex(cc);
298
- cc->htc.hash_table_lst=old_hash_table_lst;
299
- j=PrsDocFlagSingle(cc,&doc_e->de_flags,&doc_e->type,TRUE);
300
- if (!(de_flags=~processed_flags & doc_e->de_flags & DOCEG_HAS_ARG))
301
- break;
302
- if (cc->token=='=')
303
- Lex(cc);
304
- else
305
- j=Bsf(de_flags);
306
- if (j<0 || Bts(&processed_flags,j))
307
- goto pd_err;
308
- switch [j] {//TODO: Might check for expression errors
309
- case DOCEf_TAG:
310
- if (!doc_e->tag) {
311
- //If a $$MA,LM=""$$, Tag is filled when the LM is processed.
312
- //if doc_e->df_flags&DOCEF_LST,
313
- // Tag is filled when the Define is processed.
314
- //(The dft_flag1.tag calls this after.)
315
- if (cc->token==TK_STR) {
316
- st2=LexExtStr(cc);
317
- if (i==DOCT_CHECK_BOX) {
318
- st=MStrPrint("[X] %s",st2);
319
- Free(st2);
320
- doc_e->min_col=1;
321
- } else if (doc_e->de_flags & DOCEF_LST) {
322
- if (*st2!='[') {
323
- st=MStrPrint("[%s]",st2);
324
- Free(st2);
325
- } else
326
- st=st2;
327
- doc_e->min_col=1;
328
- } else if (doc_e->de_flags & DOCEF_TREE) {
329
- st=MStrPrint("+] %s",st2);
330
- Free(st2);
331
- doc_e->min_col=1;
332
- } else
333
- st=st2;
334
- doc_e->tag=StrNew(st,doc->mem_task);
335
- Free(st);
336
- } else
337
- goto pd_err;
338
- }
339
- break;
340
- case DOCEf_LEN:
341
- if (cc->token) {
342
- doc_e->len=LexExpression(cc);
343
- doc_e->de_flags&=~DOCEF_DFT_LEN;
344
- } else
345
- goto pd_err;
346
- break;
347
- case DOCEf_AUX_STR:
348
- if (cc->token==TK_STR) {
349
- st2=LexExtStr(cc);
350
- doc_e->aux_str=StrNew(st2,doc->mem_task);
351
- Free(st2);
352
- //$AN,"Anchor",A="DataTagWidth"$
353
- if (i==DOCT_DATA) { //See $LK,"DocForm",A="MN:DocForm"$()
354
- if (ptr=StrMatch(":",doc_e->aux_str))
355
- doc_e->min_col=ptr-doc_e->aux_str+1;
356
- doc_e->tag=MAlloc(doc_e->len+doc_e->min_col+2,
357
- doc->mem_task); //+2 because "_\0"
358
- }
359
- } else
360
- goto pd_err;
361
- break;
362
- case DOCEf_DEFINE:
363
- if (cc->token==TK_STR) {
364
- st2=LexExtStr(cc);
365
- doc_e->define_str=StrNew(st2,doc->mem_task);
366
- Free(st2);
367
- if (doc_e->de_flags&DOCEF_LST && !doc_e->tag)
368
- doc_e->tag=StrNew("[]",doc->mem_task);
369
- } else
370
- goto pd_err;
371
- break;
372
- case DOCEf_HTML_LINK:
373
- if (cc->token==TK_STR) {
374
- st2=LexExtStr(cc);
375
- doc_e->html_link=StrNew(st2,doc->mem_task);
376
- Free(st2);
377
- } else
378
- goto pd_err;
379
- break;
380
- case DOCEf_LEFT_EXP:
381
- if (cc->token)
382
- doc_e->left_exp=LexExpression(cc);
383
- else
384
- goto pd_err;
385
- break;
386
- case DOCEf_LEFT_MACRO:
387
- if (cc->token==TK_STR) {
388
- st2=LexExtStr(cc);
389
- doc_e->left_macro=StrNew(st2,doc->mem_task);
390
- Free(st2);
391
- if (i==DOCT_MACRO && !doc_e->tag)
392
- doc_e->tag=StrNew(doc_e->left_macro,doc->mem_task);
393
- } else
394
- goto pd_err;
395
- break;
396
- case DOCEf_RIGHT_EXP:
397
- if (cc->token)
398
- doc_e->right_exp=LexExpression(cc);
399
- else
400
- goto pd_err;
401
- break;
402
- case DOCEf_RIGHT_MACRO:
403
- if (cc->token==TK_STR) {
404
- st2=LexExtStr(cc);
405
- doc_e->right_macro=StrNew(st2,doc->mem_task);
406
- Free(st2);
407
- if (i==DOCT_MACRO && !doc_e->tag)
408
- doc_e->tag=StrNew(doc_e->right_macro,doc->mem_task);
409
- } else
410
- goto pd_err;
411
- break;
412
- case DOCEf_HAS_BIN:
413
- if (cc->token)
414
- doc_e->bin_num=LexExpressionI64(cc);
415
- else
416
- goto pd_err;
417
- break;
418
- case DOCEf_BIN_PTR_LINK:
419
- if (cc->token==TK_STR) {
420
- st2=LexExtStr(cc);
421
- doc_e->bin_ptr_link=StrNew(st2,doc->mem_task);
422
- Free(st2);
423
- if (!DocBinPtrRst(doc,doc_e))
424
- doc_e->type=DOCT_ERROR;
425
- } else
426
- goto pd_err;
427
- break;
428
- case DOCEf_RAW_TYPE:
429
- if (cc->token==TK_IDENT) {
430
- j=DefineMatch(cc->cur_str,"ST_RAW_TYPES");
431
- if (j<0)
432
- goto pd_err;
433
- doc_e->raw_type=j;
434
- doc_e->de_flags&=~DOCEF_DFT_RAW_TYPE;
435
- Lex(cc);
436
- } else
437
- goto pd_err;
438
- break;
439
- case DOCEf_SHIFTED_X:
440
- if (cc->token)
441
- doc_e->type|=(LexExpressionI64(cc) & 0x1F)<<16;
442
- else
443
- goto pd_err;
444
- break;
445
- case DOCEf_SHIFTED_Y:
446
- if (cc->token)
447
- doc_e->type|=(LexExpressionI64(cc) & 0x1F)<<21;
448
- else
449
- goto pd_err;
450
- break;
451
- case DOCEf_SCROLLING_X:
452
- if (cc->token)
453
- doc_e->scroll_len=LexExpressionI64(cc);
454
- else
455
- goto pd_err;
456
- break;
457
- case DOCEf_USER_DATA:
458
- if (cc->token)
459
- doc_e->user_data=LexExpression(cc);
460
- else
461
- goto pd_err;
462
- break;
463
- case DOCEf_FLAGS_NUM-1: //nobound switch
464
- break;
465
- }
466
- }
467
- } else {
468
- pd_err:
469
- if (!doc_e)
470
- doc_e=CAlloc(sizeof(CDocEntry),doc->mem_task);
471
- doc_e->type=DOCT_ERROR;
472
- doc_e->de_flags=0;
473
- }
474
- if (doc_e->de_flags&DOCEF_LST && (doc_e->de_flags&DOCEF_REMALLOC_DATA ||
475
- !(doc_e->de_flags&DOCEF_DEREF_DATA))) {
476
- DocDataScan(doc,doc_e);
477
- DocDataFmt(doc,doc_e);
478
- }
479
- CmpCtrlDel(cc);
480
- } catch {
481
- Fs->catch_except=TRUE;
482
- if (!doc_e)
483
- doc_e=CAlloc(sizeof(CDocEntry),doc->mem_task);
484
- doc_e->type=DOCT_ERROR;
485
- doc_e->de_flags=0;
486
- }
487
- return doc_e;
488
- }
489
-
490
- U0 DocEntryToggle(CDoc *doc)
491
- {
492
- Bool unlock=DocLock(doc),old_color_names;
493
- CDocEntry *doc_ce=doc->cur_entry,*cl1,*doc_ce2;
494
- U8 ch,*st,*st2;
495
- I64 i,j,k;
496
- if (doc_ce!=doc &&
497
- !(doc->flags&(DOCF_PLAIN_TEXT|DOCF_PLAIN_TEXT_TABS))) {
498
- if (doc_ce->type_u8==DOCT_TEXT && !(doc_ce->de_flags &
499
- ~(DOCEF_TAG|DOCG_BL_IV_UL|DOCEF_WORD_WRAP|DOCEF_HIGHLIGHT|
500
- DOCEF_SKIP|DOCEF_FILTER_SKIP)) &&
501
- !(doc_ce->type&DOCG_BL_IV_UL)) {
502
- doc_ce2=doc_ce->last;
503
- for (k=0;k<20;k++) {
504
- if (doc_ce2!=doc) {
505
- cl1=doc_ce2->last;
506
- if (doc_ce2->type_u8==DOCT_TEXT &&
507
- doc_ce->de_flags==doc_ce2->de_flags &&
508
- doc_ce->type==doc_ce2->type) {
509
- i=StrLen(doc_ce2->tag);
510
- j=StrLen(doc_ce->tag);
511
- st=MAlloc(i+j+1,doc->mem_task);
512
- MemCpy(st,doc_ce2->tag,i);
513
- MemCpy(st+i,doc_ce->tag,j+1);
514
- Free(doc_ce->tag);
515
- doc_ce->tag=st;
516
- doc_ce->max_col=i+j;
517
- doc->cur_col+=i;
518
- DocEntryDel(doc,doc_ce2);
519
- } else if (doc_ce2->type_u8==DOCT_SOFT_NEW_LINE)
520
- DocEntryDel(doc,doc_ce2);
521
- else
522
- break;
523
- doc_ce2=cl1;
524
- } else
525
- break;
526
- }
527
- doc_ce2=doc_ce->next;
528
- for (k=0;k<20;k++) {
529
- if (doc_ce2!=doc) {
530
- cl1=doc_ce2->next;
531
- if (doc_ce2->type_u8==DOCT_TEXT &&
532
- doc_ce->de_flags==doc_ce2->de_flags &&
533
- doc_ce->type==doc_ce2->type) {
534
- i=StrLen(doc_ce->tag);
535
- j=StrLen(doc_ce2->tag);
536
- st=MAlloc(i+j+1,doc->mem_task);
537
- MemCpy(st,doc_ce->tag,i);
538
- MemCpy(st+i,doc_ce2->tag,j+1);
539
- Free(doc_ce->tag);
540
- doc_ce->tag=st;
541
- doc_ce->max_col=i+j;
542
- DocEntryDel(doc,doc_ce2);
543
- } else if (doc_ce2->type_u8==DOCT_SOFT_NEW_LINE)
544
- DocEntryDel(doc,doc_ce2);
545
- else
546
- break;
547
- doc_ce2=cl1;
548
- } else
549
- break;
550
- }
551
- i=doc->cur_col;
552
- while (i>doc_ce->min_col && doc_ce->tag[i]!='$$')
553
- i--;
554
- j=doc->cur_col+1;
555
- while (j<doc_ce->max_col && doc_ce->tag[j]!='$$')
556
- j++;
557
- if (i<j-1 && doc_ce->min_col<=i<j<doc_ce->max_col &&
558
- doc_ce->tag[i]=='$$' && doc_ce->tag[j]=='$$') {
559
- ch=doc_ce->tag[j+1];
560
- doc_ce->tag[j+1]=0;
561
- st=StrNew(doc_ce->tag+i);
562
- doc_ce->tag[j+1]=ch;
563
- StrCpy(doc_ce->tag+i,doc_ce->tag+j+1);
564
- doc->cur_col=i;
565
- st2=MStrPrint("%q",st);
566
- if (doc_ce=DocPrint(doc,st2)) {
567
- doc->cur_entry=doc_ce;
568
- doc->cur_col=doc_ce->min_col;
569
- }
570
- Free(st);
571
- Free(st2);
572
- }
573
- } else {
574
- old_color_names=LBts(&doc->flags,DOCf_COLOR_NAMES);
575
- st=Doc2PlainText(doc,doc_ce);
576
- LBEqu(&doc->flags,DOCf_COLOR_NAMES,old_color_names);
577
- DocEntryDel(doc,doc_ce);
578
- DocPrint(doc,"$$$$%$$Q$$$$",st);
579
- }
580
- DocRecalc(doc);
581
- }
582
- if (unlock)
583
- DocUnlock(doc);
584
- }
585
-
586
- U0 DocFlagsToggle(CDoc *doc,I64 tog_flags)
587
- {
588
- Bool unlock=DocLock(doc);
589
- I64 size,flags=doc->flags^tog_flags;
590
- U8 *st;
591
- CDocUndo *u_next,*u_last;
592
-
593
- doc->flags=doc->flags&~DOCF_NO_CURSOR|DOCF_COLOR_NAMES;
594
- st=DocSave(doc,&size);
595
-
596
- u_next=doc->undo_head.next;
597
- u_last=doc->undo_head.last;
598
- doc->undo_head.next=doc->undo_head.last=&doc->undo_head;
599
-
600
- DocRst(doc,TRUE);
601
- doc->undo_head.next=u_next;
602
- doc->undo_head.last=u_last;
603
- DocUndoCntSet(doc);
604
- doc->flags=flags&~(DOCF_NO_CURSOR|DOCG_BL_IV_UL|DOCF_WORD_WRAP);
605
- DocLoad(doc,st,size);
606
- doc->flags|=flags&DOCF_NO_CURSOR;
607
- DocCenter(doc);
608
- if (unlock)
609
- DocUnlock(doc);
610
- Free(st);
611
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:f78b3778ebab4c87afa7811bf58ee7f53caab05e26f3abcf91292241656f6953
3
+ size 15940
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/DolDoc/DocPopUp.HC CHANGED
@@ -1,317 +1,3 @@
1
- #help_index "DolDoc/Output;StdOut/DolDoc"
2
- public CTask *PopUpViewDoc(CDoc *doc,I64 dof_flags=0)
3
- {//Pass doc to PopUp win task for viewing.
4
- U8 *buf=MStrPrint("DocEd(0x%X,0x%X);",doc,dof_flags);
5
- CTask *task=Spawn(&SrvCmdLine,NULL,"View",,Fs);
6
- TaskExe(task,NULL,buf,1<<JOBf_EXIT_ON_COMPLETE|1<<JOBf_FREE_ON_COMPLETE);
7
- Free(buf);
8
- return task;
9
- }
10
-
11
- public CTask *PopUpViewPrint(U8 *fmt,...)
12
- {//View Print stmt in PopUp win task.
13
- CTask *task=Spawn(&SrvCmdLine,NULL,"View",,Fs);
14
- U8 *buf=StrPrintJoin(NULL,fmt,argc,argv);
15
- CDoc *doc=DocNew(,task);
16
- DocPrint(doc,buf);
17
- Free(buf);
18
- buf=MStrPrint("DocEd(0x%X);",doc);
19
- TaskExe(task,NULL,buf,1<<JOBf_EXIT_ON_COMPLETE|1<<JOBf_FREE_ON_COMPLETE);
20
- Free(buf);
21
- return task;
22
- }
23
-
24
- #help_index "DolDoc/Input;File/FileNames;StdIn/DolDoc"
25
- public U8 *PopUpPickFile(U8 *dir=NULL)
26
- {//Filename chooser. Uses $LK,"FileMgr",A="MN:FileMgr"$().
27
- U8 *res,*st,*st2;
28
- if (dir)
29
- st=MStrPrint("Cd(\"%Q\");FileMgr(FM_PICK_FILE,Fs->parent_task);",dir);
30
- else {
31
- st2=DirCur;
32
- st=MStrPrint("Cd(\"%Q\");FileMgr(FM_PICK_FILE,Fs->parent_task);",st2);
33
- Free(st2);
34
- }
35
- res=PopUp(st,Fs);
36
- Free(st);
37
- return res;
38
- }
39
-
40
- public U8 *PopUpPickDir(U8 *dir=NULL)
41
- {//File dir name chooser. Uses $LK,"FileMgr",A="MN:FileMgr"$().
42
- U8 *res,*st,*st2;
43
- if (dir)
44
- st=MStrPrint("Cd(\"%Q\");FileMgr(FM_PICK_DIR,Fs->parent_task);",dir);
45
- else {
46
- st2=DirCur;
47
- st=MStrPrint("Cd(\"%Q\");FileMgr(FM_PICK_DIR,Fs->parent_task);",st2);
48
- Free(st2);
49
- }
50
- res=PopUp(st,Fs);
51
- Free(st);
52
- return res;
53
- }
54
-
55
- public U8 *FileNameForm(U8 *dft=NULL,I64 dof_flags=0,CTask *mem_task=NULL)
56
- {//Text filename form in cur win, not PopUp.
57
- CEdFileName fn;
58
- if (dft)
59
- StrCpy(fn.name,dft);
60
- else
61
- *fn.name=0;
62
- if (DocForm(&fn,,dof_flags))
63
- return StrNew(fn.name,mem_task);
64
- else
65
- return NULL;
66
- }
67
-
68
- public U8 *PopUpFileName(U8 *dft=NULL,I64 dof_flags=0)
69
- {//Filename chooser. Uses form, not $LK,"FileMgr",A="MN:FileMgr"$().
70
- U8 *st=MStrPrint("FileNameForm(\"%Q\",0x%X,Fs->parent_task);",
71
- dft,dof_flags|DOF_SIZE_MIN),*res=PopUp(st,Fs);
72
- Free(st);
73
- return res;
74
- }
75
-
76
- #help_index "DolDoc"
77
- Bool PopUpCd()
78
- {
79
- Bool res;
80
- U8 *st=PopUpPickDir;
81
- if (st) {
82
- res=Cd(st);
83
- Free(st);
84
- } else
85
- res=FALSE;
86
- return res;
87
- }
88
-
89
- #help_index "DolDoc/Input;Char/Lists;StdIn/DolDoc"
90
- public I64 PopUpPickLst(U8 *lst)
91
- {//Prompt for lst entry in PopUp win task.
92
- I64 res,i=0;
93
- CDoc *doc=DocNew;
94
- DocPrint(doc,"$$LTBLUE$$");
95
- while (*lst) {
96
- if (*lst=='@') {//Check for '@' alias lst entry
97
- i--;
98
- lst++;
99
- }
100
- DocPrint(doc,"$$MU,\"%s\",LE=%d$$\n",lst,i++);
101
- lst+=StrLen(lst)+1;
102
- }
103
- DocPrint(doc,"\n$$MU,\"CANCEL\",LE=DOCM_CANCEL$$\n");
104
- res=PopUpMenu(doc);
105
- DocDel(doc);
106
- return res;
107
- }
108
-
109
- #help_index "DolDoc/Input;Char/Lists;Char/Define;StdIn/DolDoc"
110
- public U8 *PopUpPickDefineSub(U8 *dname)
111
- {//Prompt for $LK,"Define",A="HI:Define"$ lst entry in PopUp win task.
112
- return PopUpPickLst(Define(dname));
113
- }
114
-
115
- #help_index "DolDoc/Input;StdIn/DolDoc"
116
- public I64 PopUp1(U8 *b1,I64 n1,U8 *header=NULL,U8 *footer=NULL)
117
- {//Make PopUp win task with one bttn.
118
- I64 i,l1=StrLen(b1);
119
- CDoc *doc=DocNew;
120
- if (header) DocPrint(doc,"%s",header);
121
- DocPrint(doc,"$$CM+CX,%d,4$$$$BT,\"%s\",LE=%d$$\n",-l1/2,b1,n1);
122
- if (footer) DocPrint(doc,"%s",footer);
123
- i=PopUpMenu(doc);
124
- DocDel(doc);
125
- return i;
126
- }
127
-
128
- public I64 PopUp2(U8 *b1,I64 n1,U8 *b2,I64 n2,U8 *header=NULL,U8 *footer=NULL)
129
- {//Make PopUp win task with two bttns.
130
- I64 i,l1=StrLen(b1),l2=StrLen(b2),y;
131
- CDoc *doc=DocNew;
132
- if (header) {
133
- DocPrint(doc,"%s",header);
134
- y=4;
135
- } else {
136
- DocPrint(doc,"%*s\n",l1+l2+10,"");
137
- y=3;
138
- }
139
- DocPrint(doc,"$$CM+CX,%d,%d$$$$BT,\"%s\",LE=%d$$",-(l1+l2+3)>>1,y,b1,n1);
140
- DocPrint(doc,"$$CM+CX,%d,0$$$$BT,\"%s\",LE=%d$$\n" ,-(l1+l2+3)>>1+l1+6,b2,n2);
141
- if (footer) DocPrint(doc,"%s",footer);
142
- i=PopUpMenu(doc);
143
- DocDel(doc);
144
- return i;
145
- }
146
-
147
- public Bool PopUpOk(U8 *header=NULL,U8 *footer=NULL)
148
- {//Make PopUp win task with OKAY bttn.
149
- return PopUp1("OKAY",1,header,footer)>0;
150
- }
151
-
152
- public Bool PopUpNoYes(U8 *header=NULL,U8 *footer=NULL)
153
- {//Make PopUp win task with NO/YES bttns.
154
- return $WW,0$PopUp2("YES",1,"NO",0,header,footer)>0;
155
- }
156
-
157
- public Bool PopUpCancelOk(U8 *header=NULL,U8 *footer=NULL)
158
- {//Make PopUp win task CANCEL/OKAY bttns.
159
- return PopUp2("OKAY",1,"CANCEL",0,header,footer)>0;
160
- }
161
-
162
- U8 *PopUpGetStr2(U8 *header,CTask *mem_task)
163
- {
164
- U8 *res,*st;
165
- if (header)
166
- "%s",header;
167
- st=GetStr(,,GSF_WITH_NEW_LINE);
168
- res=StrNew(st,mem_task);
169
- Free(st);
170
- return res;
171
- }
172
-
173
- public U8 *PopUpGetStr(U8 *header=NULL)
174
- {//Prompt for text str in PopUp win task.
175
- U8 *st=MStrPrint("PopUpGetStr2(0x%X,0x%X);",header,Fs),
176
- *res=PopUp(st,Fs);
177
- Free(st);
178
- return res;
179
- }
180
-
181
- public I64 PopUpGetI64(U8 *msg,I64 dft,I64 lo=I64_MIN,I64 hi=I64_MAX)
182
- {//Prompt for I64 text expression in PopUp win task.
183
- U8 *st=MStrPrint("GetI64(0x%X,0x%X,0x%X,0x%X);",msg,dft,lo,hi);
184
- I64 res=PopUp(st,Fs);
185
- Free(st);
186
- return res;
187
- }
188
-
189
- public F64 PopUpGetF64(U8 *msg,F64 dft,F64 lo=F64_MIN,F64 hi=F64_MAX)
190
- {//Prompt for F64 text expression in PopUp win task.
191
- U8 *st=MStrPrint("GetF64(0x%X,0x%X(F64),0x%X(F64),0x%X(F64));",msg,dft,lo,hi);
192
- F64 res=PopUp(st,Fs)(F64);
193
- Free(st);
194
- return res;
195
- }
196
-
197
- public I64 PopUpRangeI64(I64 lo,I64 hi,I64 step=1,
198
- U8 *header=NULL,U8 *footer=NULL)
199
- {//Evenly-spaced I64 range chooser in PopUp win task.
200
- I64 i;
201
- CDoc *doc=DocNew;
202
- if (header)
203
- DocPrint(doc,"%s",header);
204
- DocPrint(doc,"$$LTBLUE$$");
205
- for (i=lo;i<=hi;i+=step)
206
- DocPrint(doc,"$$MU,\"%d\",LE=%d$$\n",i,i);
207
- if (footer)
208
- DocPrint(doc,"%s",footer);
209
- i=PopUpMenu(doc);
210
- DocDel(doc);
211
- return i;
212
- }
213
-
214
- public F64 PopUpRangeF64(F64 lo,F64 hi,F64 step,
215
- U8 *fmt="%9.4f",U8 *header=NULL,U8 *footer=NULL)
216
- {//Evenly-spaced F64 range chooser in PopUp win task.
217
- F64 d;
218
- I64 i;
219
- U8 buf[STR_LEN];
220
- CDoc *doc=DocNew;
221
- if (header)
222
- DocPrint(doc,"%s",header);
223
- DocPrint(doc,"$$LTBLUE$$");
224
- for (d=lo;d<=hi;d+=step) {
225
- StrPrint(buf,fmt,d);
226
- DocPrint(doc,"$$MU,\"%s\",LE=0x%X$$\n",buf,d);
227
- }
228
- if (footer)
229
- DocPrint(doc,"%s",footer);
230
- i=PopUpMenu(doc);
231
- DocDel(doc);
232
- return i(F64);
233
- }
234
-
235
- public F64 PopUpRangeF64Exp(F64 lo,F64 hi,F64 factor,
236
- U8 *fmt="%9.4f",U8 *header=NULL,U8 *footer=NULL)
237
- {//Exp-spaced F64 range chooser in PopUp win task.
238
- F64 d;
239
- I64 i;
240
- U8 buf[STR_LEN];
241
- CDoc *doc=DocNew;
242
- if (header)
243
- DocPrint(doc,"%s",header);
244
- DocPrint(doc,"$$LTBLUE$$");
245
- for (d=lo;d<=hi;d*=factor) {
246
- StrPrint(buf,fmt,d);
247
- DocPrint(doc,"$$MU,\"%s\",LE=0x%X$$\n",buf,d);
248
- }
249
- if (footer)
250
- DocPrint(doc,"%s",footer);
251
- i=PopUpMenu(doc);
252
- DocDel(doc);
253
- return i(F64);
254
- }
255
-
256
- public F64 PopUpRangeF64Log(F64 lo,F64 hi,I64 steps,
257
- U8 *fmt="%9.4f",U8 *header=NULL,U8 *footer=NULL)
258
- {//Log-spaced F64 range chooser in PopUp win task.
259
- return PopUpRangeF64Exp(lo,hi,Exp(Ln(hi/lo)/(steps-1)),fmt,header,footer);
260
- }
261
-
262
- #help_index "Job/Exe;Task/Job/Exe;Compiler"
263
- public I64 AdamFile(U8 *filename,Bool warn_ext=TRUE)
264
- {//Make adam_task execute file.
265
- Bool okay=TRUE;
266
- U8 *name=FileNameAbs(filename),
267
- *name2=ExtDft(name,"HC.Z");
268
- I64 res=0;
269
- if (warn_ext &&
270
- !FilesFindMatch(name2,FILEMASK_JIT) &&
271
- !PopUpCancelOk(ST_WARN_ST "Not .HC File\n\n"))
272
- okay=FALSE;
273
- if (okay)
274
- res=Adam("#include \"%s\";",name2);
275
- Free(name2);
276
- Free(name);
277
- return res;
278
- }
279
-
280
- public I64 PopUpFile(U8 *filename,Bool warn_ext=TRUE,
281
- CTask *parent=NULL,CTask **_pu_task=NULL)
282
- {//$LK,"ExeFile2",A="MN:ExeFile2"$() in $LK,"PopUp",A="MN:PopUp"$ task. Cont as User.
283
- Bool okay=TRUE;
284
- U8 *st,*name=FileNameAbs(filename),
285
- *name2=ExtDft(name,"HC.Z");
286
- I64 res=0;
287
- if (warn_ext &&
288
- !FilesFindMatch(name2,FILEMASK_JIT) &&
289
- !PopUpCancelOk(ST_WARN_ST "Not .HC File\n\n"))
290
- okay=FALSE;
291
- if (okay) {
292
- st=MStrPrint(
293
- "\"$$$$WW+H,1$$$$\";In(\"ExeFile2(\\\"%s\\\",CCF_CMD_LINE);\\n\");"
294
- "UserTaskCont;",
295
- name2);
296
- res=PopUp(st,parent,_pu_task);
297
- Free(st);
298
- }
299
- Free(name2);
300
- Free(name);
301
- return res;
302
- }
303
-
304
- public I64 PopUpRunFile(U8 *filename,I64 ccf_flags=0,...)
305
- {//$LK,"ExeFile",A="MN:ExeFile"$() with args using $LK,"LastFun",A="MN:LastFun"$() in $LK,"PopUp",A="MN:PopUp"$ task.
306
- U8 *st,*name=FileNameAbs(filename),
307
- *name2=ExtDft(name,"HC.Z");
308
- I64 res=0;
309
- st=MStrPrint(
310
- "\"$$$$WW+H,1$$$$\";ExeFile2(\"%s\",0x%X);LastFun(0x%X,0x%X);",
311
- name2,ccf_flags,argc,argv);
312
- res=PopUp(st,Fs);
313
- Free(st);
314
- Free(name2);
315
- Free(name);
316
- return res;
317
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:9dab62345b49eb96ad07bbd7997ffa6695092aee8946984530b348aa48d2c52b
3
+ size 8370
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adam/DolDoc/DocPutKey.HC CHANGED
@@ -1,729 +1,3 @@
1
- #help_index "DolDoc/Output;StdOut/DolDoc"
2
-
3
- public U0 DocPutKey(CDoc *doc,I64 ch=0,I64 sc=0)
4
- {//$LK,"PutKey",A="MN:PutKey"$(ch,sc) at doc insert pt, cur_entry.
5
- I64 i,x,y;
6
- CDoc *m;
7
- CDocEntry *doc_ce;
8
- U8 *st,*st2;
9
- Bool unlock;
10
-
11
- if (!doc && !(doc=DocPut) || doc->doc_signature!=DOC_SIGNATURE_VAL)
12
- return;
13
- if (doc->user_put_key && (*doc->user_put_key)(doc,doc->user_put_data,ch,sc))
14
- return;
15
- unlock=DocLock(doc);
16
- if (!Bt(doldoc.clean_scan_codes,sc.u8[0]))
17
- doc->flags|=DOCF_UNDO_DIRTY;
18
- DocCaptureUndo(doc);
19
- if (Bt(char_bmp_printable,ch) && !(sc&(SCF_CTRL|SCF_ALT))) {
20
- if (sc&SCF_KEY_DESC) {
21
- st=Char2KeyName(ch,FALSE);
22
- KeyDescSet("Char /'%s'",st);
23
- Free(st);
24
- } else
25
- EdCharIns(ch,sc,doc);
26
- } else {
27
- doc_ce=doc->cur_entry;
28
- x=doc->x; y=doc->y;
29
- if (sc&SCF_ALT)
30
- switch (ch) {
31
- case CH_BACKSPACE: //<CTRL-H>
32
- if (!(sc&(SCF_SHIFT|SCF_CTRL))) {
33
- if (sc&SCF_KEY_DESC)
34
- KeyDescSet("Edit/Undo");
35
- else
36
- DocUndoRestore(doc);
37
- }
38
- break;
39
- }
40
- else
41
- switch (ch) {
42
- case 0:
43
- switch (sc.u8[0]) {
44
- case SC_CURSOR_DOWN:
45
- if (!(sc&SCF_CTRL)) {
46
- if (sc&SCF_KEY_DESC) {
47
- if (sc&SCF_SHIFT)
48
- KeyDescSet("Edit/Cursor Down, Sel");
49
- else
50
- KeyDescSet("Edit/Cursor Down");
51
- } else
52
- EdLineDown(doc,sc);
53
- break;
54
- } else
55
- sc&=~SCF_CTRL;
56
- //Fall Through to SC_END
57
- case SC_END:
58
- if (!(sc&SCF_CTRL)) {
59
- if (sc&SCF_KEY_DESC) {
60
- if (sc&SCF_SHIFT)
61
- KeyDescSet("Edit/GoTo Doc End, Sel");
62
- else
63
- KeyDescSet("Edit/GoTo Doc End");
64
- } else {
65
- while (doc_ce!=doc) {
66
- BEqu(&doc_ce->type,DOCEt_SEL,sc&SCF_SHIFT);
67
- doc_ce=doc->cur_entry=doc_ce->next;
68
- }
69
- doc->cur_col=doc_ce->min_col;
70
- DocFormBwd(doc);
71
- }
72
- }
73
- break;
74
- case SC_CURSOR_UP:
75
- if (!(sc&SCF_CTRL)) {
76
- if (sc&SCF_KEY_DESC) {
77
- if (sc&SCF_SHIFT)
78
- KeyDescSet("Edit/Cursor Up, Sel");
79
- else
80
- KeyDescSet("Edit/Cursor Up");
81
- } else
82
- EdLineUp(doc,sc);
83
- break;
84
- } else
85
- sc&=~SCF_CTRL;
86
- //Fall Through to SC_HOME
87
- case SC_HOME:
88
- if (!(sc&SCF_CTRL)) {
89
- if (sc&SCF_KEY_DESC) {
90
- if (sc&SCF_SHIFT)
91
- KeyDescSet("Edit/GoTo Top of Doc, Sel");
92
- else
93
- KeyDescSet("Edit/GoTo Top of Doc");
94
- } else {
95
- if (doc_ce==doc) doc_ce=doc_ce->last;
96
- while (doc_ce!=doc) {
97
- BEqu(&doc_ce->type,DOCEt_SEL,sc&SCF_SHIFT);
98
- doc_ce=doc->cur_entry=doc_ce->last;
99
- }
100
- doc_ce=doc->cur_entry=doc->head.next;
101
- doc->cur_col=doc_ce->min_col;
102
- DocFormFwd(doc);
103
- }
104
- }
105
- break;
106
- case SC_PAGE_DOWN:
107
- if (!(sc&SCF_CTRL)) {
108
- if (sc&SCF_KEY_DESC) {
109
- if (sc&SCF_SHIFT)
110
- KeyDescSet("Edit/Page Down, Sel");
111
- else
112
- KeyDescSet("Edit/Page Down");
113
- } else {
114
- i=doc_ce->y+doc->win_task->win_height-1;
115
- if (doc_ce->type_u8==DOCT_HEX_ED)
116
- i+=doc->cur_col/3/doc_ce->hex_ed_width;
117
- while (doc_ce!=doc &&
118
- (doc_ce->type_u8!=DOCT_HEX_ED && doc_ce->y<i ||
119
- doc_ce->type_u8==DOCT_HEX_ED &&
120
- doc_ce->y+doc->cur_col/3/doc_ce->hex_ed_width<i)) {
121
- EdLineDown(doc,sc);
122
- //paranoid check for stuck on same node
123
- if (doc->cur_entry==doc_ce && doc_ce->type_u8!=DOCT_HEX_ED)
124
- break;
125
- doc_ce=doc->cur_entry;
126
- }
127
- }
128
- }
129
- break;
130
- case SC_PAGE_UP:
131
- if (!(sc&SCF_CTRL)) {
132
- if (sc&SCF_KEY_DESC) {
133
- if (sc&SCF_SHIFT)
134
- KeyDescSet("Edit/Page Up, Sel");
135
- else
136
- KeyDescSet("Edit/Page Up");
137
- }else {
138
- i=doc_ce->y-(doc->win_task->win_height-1);
139
- if (doc_ce->type_u8==DOCT_HEX_ED)
140
- i+=doc->cur_col/3/doc_ce->hex_ed_width;
141
- while (doc_ce->last!=doc &&
142
- (doc_ce->type_u8!=DOCT_HEX_ED && doc_ce->y>i ||
143
- doc_ce->type_u8==DOCT_HEX_ED &&
144
- doc_ce->y+doc->cur_col/3/doc_ce->hex_ed_width>i) &&
145
- doc_ce->y!=doc->head.next->y) {
146
- EdLineUp(doc,sc);
147
- //paranoid check for stuck on same node
148
- if (doc->cur_entry==doc_ce && doc_ce->type_u8!=DOCT_HEX_ED)
149
- break;
150
- doc_ce=doc->cur_entry;
151
- }
152
- }
153
- }
154
- break;
155
- case SC_CURSOR_LEFT:
156
- if (sc&SCF_KEY_DESC) {
157
- if (sc&SCF_CTRL)
158
- KeyDescSet("Edit/GoTo Start of Line");
159
- else {
160
- if (sc&SCF_SHIFT)
161
- KeyDescSet("Edit/Cursor Left, Sel");
162
- else
163
- KeyDescSet("Edit/Cursor Left");
164
- }
165
- } else
166
- EdCursorLeft(doc,sc);
167
- break;
168
- case SC_CURSOR_RIGHT:
169
- if (sc&SCF_KEY_DESC) {
170
- if (sc&SCF_CTRL)
171
- KeyDescSet("Edit/GoTo End of Line");
172
- else {
173
- if (sc&SCF_SHIFT)
174
- KeyDescSet("Edit/Cursor Right, Sel");
175
- else
176
- KeyDescSet("Edit/Cursor Right");
177
- }
178
- } else
179
- EdCursorRight(doc,sc);
180
- break;
181
- case SC_DELETE:
182
- if (!(sc&SCF_CTRL)) {
183
- if (sc&SCF_KEY_DESC) {
184
- if (sc&SCF_SHIFT)
185
- KeyDescSet("Edit/Cut To Clip");
186
- else
187
- KeyDescSet("Char /Delete");
188
- } else {
189
- if (sc&SCF_SHIFT)
190
- ClipCut(doc);
191
- else
192
- EdCharDel(doc);
193
- }
194
- }
195
- break;
196
- case SC_INS:
197
- if (sc&(SCF_SHIFT|SCF_CTRL)!=(SCF_SHIFT|SCF_CTRL)) {
198
- if (sc&SCF_KEY_DESC) {
199
- if (sc&SCF_SHIFT)
200
- KeyDescSet("Edit/Paste Clip");
201
- else if (sc&SCF_CTRL)
202
- KeyDescSet("Edit/Copy to Clip");
203
- else
204
- KeyDescSet("Edit/Toggle Overstrike");
205
- } else {
206
- if (sc&SCF_SHIFT)
207
- ClipPaste(doc);
208
- else if (sc&SCF_CTRL)
209
- ClipCopy(doc);
210
- else
211
- doc->flags^=DOCF_OVERSTRIKE;
212
- }
213
- }
214
- break;
215
- case SC_F1...SC_F10:
216
- if (sc&SCF_CTRL) {
217
- if (sc&SCF_KEY_DESC) {
218
- if (sc&SCF_SHIFT)
219
- KeyDescSet("Cmd /Src Code of Sym");
220
- else
221
- KeyDescSet("Edit/Autocomplete Sym");
222
- } else {
223
- DocUnlock(doc);
224
- if (AutoComplete(ON)) {
225
- if (sc&SCF_SHIFT)
226
- ACMan(sc.u8[0]-SC_F1+1,Fs);
227
- else
228
- ACFillIn(sc.u8[0]-SC_F1+1);
229
- }
230
- DocLock(doc);
231
- }
232
- } else {
233
- switch (sc.u8[0]) {
234
- case SC_F1:
235
- if (sc&SCF_KEY_DESC) {
236
- if (sc&SCF_SHIFT)
237
- KeyDescSet("Cmd /About");
238
- else
239
- KeyDescSet("Cmd /Help");
240
- } else {
241
- if (sc&SCF_SHIFT)
242
- Ed("::/Doc/AboutTempleOS.DD.Z");
243
- else
244
- Ed("::/Doc/HelpIndex.DD.Z");
245
- }
246
- break;
247
- case SC_F2:
248
- if (sc&SCF_KEY_DESC) {
249
- if (sc&SCF_SHIFT)
250
- KeyDescSet("Edit/Play Macro");
251
- else
252
- KeyDescSet("Edit/Macro");
253
- } else {
254
- DocUnlock(doc);
255
- if (sc&SCF_SHIFT) {
256
- if (TaskValidate(sys_macro_task))
257
- PostMsgWait(sys_macro_task,
258
- MSG_KEY_DOWN_UP,CH_SHIFT_ESC,0);
259
- SysMacroStripKey(&sys_macro_head,ch,sc);
260
- PlaySysMacro;
261
- } else
262
- EdMacroUtil;
263
- DocLock(doc);
264
- }
265
- break;
266
- case SC_F3:
267
- if (sc&SCF_KEY_DESC) {
268
- if (sc&SCF_SHIFT)
269
- KeyDescSet("Edit/Find Last");
270
- else
271
- KeyDescSet("Edit/Find Next");
272
- }else {
273
- doc->find_replace->scan_fwd=!(sc&SCF_SHIFT);
274
- EdFindNext(doc);
275
- }
276
- break;
277
- case SC_F4:
278
- if (sc&SCF_KEY_DESC) {
279
- if (sc&SCF_SHIFT)
280
- KeyDescSet("Cmd /Insert Directory Name");
281
- else
282
- KeyDescSet("Cmd /Insert FileName");
283
- } else {
284
- DocUnlock(doc);
285
- if (sc&SCF_SHIFT)
286
- st=PopUpPickDir;
287
- else
288
- st=PopUpPickFile;
289
- DocLock(doc);
290
- if (st) {
291
- DocPrintPartial(doc,"%s",st);
292
- Free(st);
293
- }
294
- }
295
- break;
296
- case SC_F5:
297
- if (sc&SCF_KEY_DESC) {
298
- if (sc&SCF_SHIFT)
299
- KeyDescSet("Cmd /Adam Include");
300
- else
301
- KeyDescSet("Cmd /Run (Execute)");
302
- } else {
303
- if (st2=DocEntryLink(doc,doc_ce)) {
304
- st=DocLinkFile(st2);
305
- Free(st2);
306
- } else {
307
- DocWrite(doc);
308
- st=StrNew(doc->filename.name);
309
- }
310
- if (st2=DirFile(st,"Run","HC.Z")) {
311
- if (FileFind(st2)) {
312
- Free(st);
313
- st=st2;
314
- } else
315
- Free(st2);
316
- }
317
- if (st) {
318
- if (sc&SCF_SHIFT)
319
- AdamFile(st);
320
- else
321
- PopUpFile(st);
322
- Free(st);
323
- }
324
- }
325
- break;
326
- case SC_F6:
327
- if (sc&SCF_KEY_DESC) {
328
- if (sc&SCF_SHIFT)
329
- KeyDescSet("Cmd /God Doodle");
330
- else
331
- KeyDescSet("Cmd /God Song");
332
- } else {
333
- //$LK,"::/Adam/God/HSNotes.DD"$
334
- if (sc&SCF_SHIFT) {
335
- DocUnlock(doc);
336
- GodDoodle;
337
- DocLock(doc);
338
- } else
339
- GodSong;
340
- }
341
- break;
342
- case SC_F7:
343
- if (sc&SCF_KEY_DESC) {
344
- if (sc&SCF_SHIFT)
345
- KeyDescSet("Cmd /God Passage");
346
- else
347
- KeyDescSet("Cmd /God Word");
348
- } else {
349
- //$LK,"::/Adam/God/HSNotes.DD"$
350
- FifoU8Flush(god.fifo);
351
- GodBitsIns(GOD_GOOD_BITS,KbdMsEvtTime>>GOD_BAD_BITS);
352
- if (sc&SCF_SHIFT)
353
- GodBiblePassage;
354
- else
355
- GodWord;
356
- }
357
- break;
358
- }
359
- }
360
- break;
361
- }
362
- break;
363
- case CH_CTRLA:
364
- if (!(sc&SCF_SHIFT)) {
365
- if (sc&SCF_KEY_DESC)
366
- KeyDescSet("Edit/Save As");
367
- else if (DocWrite(doc,TRUE)&&(st=FileNameAbs(doc->filename.name))) {
368
- DirContextDel(doc->filename.dirc);
369
- doc->filename.dirc=DirContextNew(st);
370
- Free(st);
371
- }
372
- }
373
- break;
374
- case CH_CTRLB:
375
- if (!(sc&SCF_SHIFT)) {
376
- if (sc&SCF_KEY_DESC)
377
- KeyDescSet("Cmd /Toggle Border");
378
- else
379
- WinBorder(Bt(&doc->win_task->display_flags,
380
- DISPLAYf_NO_BORDER),doc->win_task);
381
- }
382
- break;
383
- case CH_CTRLC:
384
- if (!(sc&SCF_SHIFT)) {
385
- if (sc&SCF_KEY_DESC)
386
- KeyDescSet("Edit/Copy to Clip");
387
- else
388
- ClipCopy(doc);
389
- }
390
- break;
391
- case CH_CTRLD:
392
- if (!(sc&SCF_SHIFT)) {
393
- if (sc&SCF_KEY_DESC)
394
- KeyDescSet("Cmd /File Manager");
395
- else {
396
- DocUnlock(doc);
397
- FileMgr;
398
- DocLock(doc);
399
- }
400
- }
401
- break;
402
- case CH_CTRLF:
403
- if (sc&SCF_SHIFT) {
404
- if (sc&SCF_KEY_DESC)
405
- KeyDescSet("Cmd /Search Files");
406
- else
407
- FindWiz;
408
- } else {
409
- if (sc&SCF_KEY_DESC)
410
- KeyDescSet("Edit/Find & Replace");
411
- else
412
- EdFindReplace(doc);
413
- }
414
- break;
415
- case CH_CTRLG:
416
- if (!(sc&SCF_SHIFT)) {
417
- if (sc&SCF_KEY_DESC)
418
- KeyDescSet("Edit/GoTo Line Num");
419
- else
420
- EdGoToLine(doc);
421
- }
422
- break;
423
- case CH_BACKSPACE: //<CTRL-H>
424
- if (!(sc&SCF_SHIFT)) {
425
- if (sc&SCF_KEY_DESC)
426
- KeyDescSet("Char /Back Space");
427
- else {
428
- DocCaptureUndo(doc);
429
- doc_ce=doc->cur_entry;
430
- if (doc->cur_col<=doc_ce->min_col) {
431
- doc_ce=doc->cur_entry=doc_ce->last;
432
- if (doc_ce!=doc && doc_ce->type_u8==DOCT_SOFT_NEW_LINE)
433
- doc_ce=doc->cur_entry=doc_ce->last;
434
- if (doc_ce==doc || doc_ce->type_u8==DOCT_PMT) {
435
- doc_ce=doc->cur_entry=doc_ce->next;
436
- doc->cur_col=doc_ce->min_col;
437
- } else {
438
- doc->cur_col=doc_ce->max_col;
439
- if (doc->cur_col>doc_ce->min_col)
440
- doc->cur_col--;
441
- EdCharDel(doc);
442
- }
443
- } else {
444
- doc->cur_col--;
445
- EdCharDel(doc);
446
- }
447
- }
448
- }
449
- break;
450
- case CH_CTRLI:
451
- if (sc.u8[0]!=SC_TAB) {
452
- if (sc&SCF_SHIFT) {
453
- if (sc&SCF_KEY_DESC)
454
- KeyDescSet("Dol /Unindent 2");
455
- else
456
- DocPrint(doc,"$$ID,-2$$");
457
- } else {
458
- if (sc&SCF_KEY_DESC)
459
- KeyDescSet("Dol /Indent 2");
460
- else
461
- DocPrint(doc,"$$ID,2$$");
462
- }
463
- }
464
- break;
465
- case '\n':
466
- if (sc&SCF_KEY_DESC) {
467
- if (sc&SCF_SHIFT)
468
- KeyDescSet("Char /Return");
469
- else
470
- KeyDescSet("Char /Page Break");
471
- } else
472
- EdCharIns(ch,sc,doc);
473
- break;
474
- case CH_CTRLK:
475
- if (sc&SCF_SHIFT) {
476
- if (sc&SCF_KEY_DESC)
477
- KeyDescSet("Dol /Blinking Text Off");
478
- else
479
- DocPrint(doc,"$$BK,0$$");
480
- } else {
481
- if (sc&SCF_KEY_DESC)
482
- KeyDescSet("Dol /Blinking Text On");
483
- else
484
- DocPrint(doc,"$$BK,1$$");
485
- }
486
- break;
487
- case CH_CTRLL:
488
- if (sc&SCF_SHIFT) {
489
- if (sc&SCF_KEY_DESC)
490
- KeyDescSet("Cmd /Code Tools");
491
- else {
492
- DocUnlock(doc);
493
- EdCodeTools(doc);
494
- DocLock(doc);
495
- }
496
- } else {
497
- if (sc&SCF_KEY_DESC)
498
- KeyDescSet("Cmd /Insert Text Widgets Wizard");
499
- else {
500
- DocUnlock(doc);
501
- EdInsWidgetWiz;
502
- DocLock(doc);
503
- }
504
- }
505
- break;
506
- case CH_CTRLM:
507
- if (sc&SCF_SHIFT) {
508
- if (sc&SCF_KEY_DESC)
509
- KeyDescSet("Cmd /Personal Notes");
510
- else
511
- Ed("~/PersonalNotes.DD.Z");
512
- } else {
513
- if (sc&SCF_KEY_DESC)
514
- KeyDescSet("Cmd /Personal Menu");
515
- else {
516
- m=DocRead("~/PersonalMenu.DD.Z");
517
- DocMenu(m);
518
- DocDel(m);
519
- }
520
- }
521
- break;
522
- case CH_CTRLO:
523
- if (sc&SCF_SHIFT) {
524
- if (sc&SCF_KEY_DESC)
525
- KeyDescSet("Edit/Collapse");
526
- else
527
- DocCollapse(TRUE,doc);
528
- } else {
529
- if (sc&SCF_KEY_DESC)
530
- KeyDescSet("Edit/Uncolapse");
531
- else
532
- DocCollapse(FALSE,doc);
533
- }
534
- break;
535
- case CH_CTRLP:
536
- if (doc->flags & (DOCF_SUPERSCRIPT_MODE | DOCF_SUBSCRIPT_MODE)) {
537
- if (sc&SCF_KEY_DESC)
538
- KeyDescSet("Dol /Toggle Super or Sub script");
539
- else {
540
- DocPrint(doc,"$$SY,0$$");
541
- doc->flags&=~(DOCF_SUPERSCRIPT_MODE | DOCF_SUBSCRIPT_MODE);
542
- }
543
- } else if (sc&SCF_SHIFT) {
544
- if (sc&SCF_KEY_DESC)
545
- KeyDescSet("Dol /Toggle Subscript");
546
- else {
547
- DocPrint(doc,"$$SY,3$$");
548
- doc->flags|=DOCF_SUBSCRIPT_MODE;
549
- }
550
- } else {
551
- if (sc&SCF_KEY_DESC)
552
- KeyDescSet("Dol /Toggle Superscript");
553
- else {
554
- DocPrint(doc,"$$SY,-3$$");
555
- doc->flags|=DOCF_SUPERSCRIPT_MODE;
556
- }
557
- }
558
- break;
559
- case CH_CTRLQ:
560
- break;
561
- case CH_CTRLR:
562
- if (!(sc&SCF_SHIFT)) {
563
- if (sc&SCF_KEY_DESC)
564
- KeyDescSet("Cmd /Sprite Graphic Resource");
565
- else
566
- if (!(doc->flags&DOCF_FORM) &&
567
- !(doc->flags&(DOCF_PLAIN_TEXT|DOCF_PLAIN_TEXT_TABS))) {
568
- DocUnlock(doc);
569
- if (doc_ce->type_u8==DOCT_SPRITE)
570
- EdSpriteEd(doc);
571
- else
572
- EdSpriteIns(doc);
573
- DocLock(doc);
574
- }
575
- }
576
- break;
577
- case CH_CTRLS:
578
- if (sc&SCF_SHIFT) {
579
- if (sc&SCF_KEY_DESC)
580
- KeyDescSet("Edit/Toggle AutoSave");
581
- else
582
- LBtc(&doc->flags,DOCf_AUTO_SAVE);
583
- } else {
584
- if (sc&SCF_KEY_DESC)
585
- KeyDescSet("Edit/Save");
586
- else
587
- DocWrite(doc);
588
- }
589
- break;
590
- case CH_CTRLT:
591
- if (sc&SCF_SHIFT) {
592
- if (sc&SCF_KEY_DESC)
593
- KeyDescSet("Edit/Single Entry Toggle Plain Text");
594
- else if (!(doc->flags&DOCF_FORM))
595
- DocEntryToggle(doc);
596
- } else {
597
- if (sc&SCF_KEY_DESC)
598
- KeyDescSet("Edit/Toggle Plain Text Display");
599
- else if (!(doc->flags&DOCF_FORM))
600
- DocFlagsToggle(doc,DOCF_PLAIN_TEXT);
601
- }
602
- break;
603
- case CH_CTRLU:
604
- if (sc&SCF_SHIFT) {
605
- if (sc&SCF_KEY_DESC)
606
- KeyDescSet("Dol /Underline Off");
607
- else
608
- DocPrint(doc,"$$UL,0$$");
609
- } else {
610
- if (sc&SCF_KEY_DESC)
611
- KeyDescSet("Dol /Underline On");
612
- else
613
- DocPrint(doc,"$$UL,1$$");
614
- }
615
- break;
616
- case CH_CTRLV:
617
- if (!(sc&SCF_SHIFT)) {
618
- if (sc&SCF_KEY_DESC)
619
- KeyDescSet("Edit/Paste Clip");
620
- else
621
- ClipPaste(doc);
622
- }
623
- break;
624
- case CH_CTRLW:
625
- if (sc&SCF_SHIFT) {
626
- if (sc&SCF_KEY_DESC)
627
- KeyDescSet("Dol /Word Wrap Off");
628
- else
629
- DocPrint(doc,"$$WW,0$$");
630
- } else {
631
- if (sc&SCF_KEY_DESC)
632
- KeyDescSet("Dol /Word Wrap On");
633
- else
634
- DocPrint(doc,"$$WW,1$$");
635
- }
636
- break;
637
- case CH_CTRLX:
638
- if (!(sc&SCF_SHIFT)) {
639
- if (sc&SCF_KEY_DESC)
640
- KeyDescSet("Edit/Cut To Clip");
641
- else
642
- ClipCut(doc);
643
- }
644
- break;
645
- case CH_CTRLY:
646
- if (!(sc&SCF_SHIFT)) {
647
- if (sc&SCF_KEY_DESC)
648
- KeyDescSet("Edit/Delete Line");
649
- else
650
- EdLineDel(doc);
651
- }
652
- break;
653
- case CH_CTRLZ:
654
- if (sc&SCF_SHIFT) {
655
- if (sc&SCF_KEY_DESC)
656
- KeyDescSet("Dol /Inverted Text Off");
657
- else
658
- DocPrint(doc,"$$IV,0$$");
659
- } else {
660
- if (sc&SCF_KEY_DESC)
661
- KeyDescSet("Dol /Inverted Text On");
662
- else
663
- DocPrint(doc,"$$IV,1$$");
664
- }
665
- break;
666
- case '0'...'9':
667
- if (sc&SCF_CTRL) {
668
- if (sc&SCF_KEY_DESC) {
669
- if (sc&SCF_SHIFT)
670
- KeyDescSet("Cmd /Word Definition");
671
- else
672
- KeyDescSet("Edit/Autocomplete Word");
673
- } else {
674
- if (AutoComplete(ON)) {
675
- DocUnlock(doc);
676
- if (sc&SCF_SHIFT)
677
- ACDDef(ch-'0',Fs);
678
- else
679
- ACDFillin(ch-'0');
680
- DocLock(doc);
681
- }
682
- }
683
- }
684
- break;
685
- case '[':
686
- if (sc&SCF_CTRL) {
687
- if (sc&SCF_SHIFT) {
688
- if (sc&SCF_KEY_DESC)
689
- KeyDescSet("Edit/GoTo matching brace");
690
- else
691
- EdFindPaired(doc,'}','{',FALSE);
692
- } else {
693
- if (sc&SCF_KEY_DESC)
694
- KeyDescSet("Edit/GoTo matching bracket");
695
- else
696
- EdFindPaired(doc,']','[',FALSE);
697
- }
698
- }
699
- break;
700
- case ']':
701
- if (sc&SCF_CTRL) {
702
- if (sc&SCF_SHIFT) {
703
- if (sc&SCF_KEY_DESC)
704
- KeyDescSet("Edit/GoTo matching brace");
705
- else
706
- EdFindPaired(doc,'{','}',TRUE);
707
- } else {
708
- if (sc&SCF_KEY_DESC)
709
- KeyDescSet("Edit/GoTo matching bracket");
710
- else
711
- EdFindPaired(doc,'[',']',TRUE);
712
- }
713
- }
714
- break;
715
- }
716
- }
717
- if (unlock)
718
- DocUnlock(doc);
719
- if (!(doc->flags&DOCF_DONT_SWAP_OUT))
720
- Yield;
721
- }
722
-
723
- Bool KDDocPutKey(I64 ch,I64 scan_code)
724
- {
725
- CDoc *doc;
726
- if (doc=DocPut)
727
- DocPutKey(doc,ch,scan_code);
728
- return FALSE;
729
- }
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:fbaf2a7ded8c112d6faaf47c093fd03cbd20fdbb70b499ab7a5a9e20c3f39e52
3
+ size 16617