home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
17 Bit Software 1: Collection A
/
17Bit_Collection_A.iso
/
files
/
1065.dms
/
1065.adf
/
TextPlus
/
SrcE.lzh
/
SrcE
/
fs2.asm
< prev
next >
Wrap
Assembly Source File
|
1990-08-06
|
85KB
|
3,356 lines
* ------------------------------------------------------------------------- *
* FS2.ASM -- Assembly support routines for PathMaster(tm) File Selector
* Copyright © 1987-1989 by Justin V. McCormick. All Rights Reserved.
* ------------------------------------------------------------------------- *
;BENCHMARK EQU 1
include "exec/types.i"
include "exec/nodes.i"
include "exec/lists.i"
SYS MACRO *
IFGT NARG-2
FAIL !!!
ENDC
IFEQ NARG-2
MOVE.L \2,a6
ENDC
JSR _LVO\1(a6)
ENDM
XLVO MACRO *
XREF _LVO\1
ENDM
* These three equate control the size of the path, file, and pattern string limits
PATHSTRSIZE EQU 300
FILESTRSIZE EQU 32
MATCHSTRSIZE EQU 32
AUTOKNOB EQU $1
FREEVERT EQU $4
PROPBORDERLESS EQU $8
MEMF_CLEAR EQU $10000
WINDOWSIZING EQU $1
WINDOWDRAG EQU $2
WINDOWDEPTH EQU $4
WINDOWCLOSE EQU $8
WINDOWTGADS EQU WINDOWDRAG!WINDOWDEPTH!WINDOWCLOSE
FPEN EQU 1
DPEN EQU 3
fib_DirEntryType EQU $4
fib_FileName EQU $8
fib_Size EQU $7C
fib_DateStamp EQU $84
fib_SIZEOF EQU $104
gg_Flags EQU $C
id_SIZEOF EQU $24
it_FrontPen EQU $0
it_IText EQU $C
rp_AreaPtrn EQU $8
rp_AreaPtSz EQU $1D
wd_Flags EQU $18
wd_RPort EQU $32
STRUCTURE FSRequest,0
STRUCT fs_dirname,PATHSTRSIZE
STRUCT fs_filename,FILESTRSIZE
STRUCT fs_matchpattern,MATCHSTRSIZE
WORD fs_leftedge
WORD fs_topedge
WORD fs_sorttype
UWORD fs_flags
ULONG fs_windowflags
APTR fs_fullname
APTR fs_ignorepattern
APTR fs_pathgadstr
APTR fs_filegadstr
APTR fs_titlestr
APTR fs_readingstr
APTR fs_sortingstr
APTR fs_emptydirstr
APTR fs_nomatchstr
APTR fs_selectfilestr
APTR fs_selectstr
APTR fs_cancelstr
APTR fs_specgadstr
APTR fs_userscreen
APTR fs_userport
APTR fs_specgadfunc
APTR fs_dirfunc
APTR fs_filefunc
APTR fs_userfunc
APTR fs_initfunc
APTR fs_matchfunc
LABEL fs_SIZEOF
STRUCTURE node_data,0
STRUCT nd_alphadata,58
WORD nd_filetype
WORD nd_showit
WORD nd_textcolor
WORD nd_namelength
ULONG nd_filesize
ULONG nd_days
ULONG nd_minutes
ULONG nd_ticks
LABEL nd_SIZEOF
STRUCTURE file_node,0
STRUCT fn_Node,MLN_SIZE
APTR fn_info
WORD fn_idnum
LABEL fn_SIZEOF
STRUCTURE dev_node,0
STRUCT dn_Node,MLN_SIZE
STRUCT dn_name,32
LABEL dn_SIZEOF
XREF _AlphaGad
XREF _ColonStr
XREF _CurDevNames
XREF _DevGads
XREF _devList
XREF _DevTxts
XREF _DOSBase
XREF _EmptyPattern
XREF _FileUndoBuffer
XREF _FileUndoName
XREF _fnList
XREF _fsbaddatestr
XREF _FSCountDown
XREF _fscurmicros
XREF _fscursecs
XREF _fsdatefmtstr
XREF _fsdayspermonth
XREF _FSDirFmtStr
XREF _fsdirlocked
XREF _FSDone
XREF _FSDownGad
XREF _fserrmsgs
XREF _FSFib
XREF _FSFileGad
XREF _FSFileInfo
XREF _FSFileNodes
XREF _fsflags
XREF _FSIgnorePat
XREF _FSInfo
XREF _FSLock
XREF _fsneedshow
XREF _FSNextDevs
XREF _fsnumentries
XREF _fsoldmicros
XREF _fsoldsecs
XREF _FSPathBuf
XREF _FSPathGad
XREF _FSPathInfo
XREF _FSPatternGad
XREF _FSPatternInfo
XREF _FSPatternUndoBuffer
XREF _FSPrevDevs
XREF _fsprevgadid
XREF _FSReq
XREF _FSRPort
XREF _FSSizeFmtStr
XREF _FSSlideGad
XREF _FSSlideProp
XREF _fsstartedstr
XREF _fstempdate
XREF _fstitlelength
XREF _fstitstatus
XREF _FSUndoGad
XREF _FSUpGad
XREF _FSUserGad
XREF _fsvheight
XREF _fsvirgindir
XREF _fsvposition
XREF _FSWin
XREF _FSWinTitleStr
XREF _FSwstr
XREF _GfxBase
XREF _IntuitionBase
XREF _lastdev
XREF _NIL2Gad
XREF _OldFSPathBuf
XREF _RamDirNameStr
XREF _SizeGad
XREF _SlashStr
XREF _TimeGad
XREF _topfin
XREF _sprintf
XREF _FSVBDelay
IFD BENCHMARK
XREF _StartTime
XREF _StopTime
XREF _timermsg1
ENDC
XLVO ActivateGadget
XLVO AddHead
XLVO AddTail
XLVO AllocMem
XLVO ClipBlit
XLVO DisplayBeep
XLVO DoubleClick
XLVO Examine
XLVO ExNext
XLVO FreeMem
XLVO GetMsg
XLVO Insert
XLVO IoErr
XLVO Move
XLVO NewModifyProp
XLVO ParentDir
XLVO RectFill
XLVO RefreshGList
XLVO RemHead
XLVO ReplyMsg
XLVO SetAPen
XLVO SetDrMd
XLVO SetWindowTitles
XLVO Text
XLVO UnLock
SECTION CODE
* ------------------------------------------------------------------------
; LONG MyActivateGad(gadget, window)
; struct Gadget *gadget;
; struct Window *window;
;
; Activate a gadget, wait till it is ready. Try up to 3 times. Returns
; TRUE (1) if it succeeded, FALSE (0) if it failed to activate.
* ------------------------------------------------------------------------
XDEF _MyActivateGad
_MyActivateGad:
movem.l d2/a2/a6,-(sp)
moveq #2,d2 ;Try 3 times to activate gadget
1$ movem.l 16(sp),a0/a1 ;Grab gadget pointer, window pointer
suba.l a2,a2 ;No requester pointer
movea.l _IntuitionBase,a6
jsr _LVOActivateGadget(a6) ;Activate!
tst.l d0 ;Did it catch?
bne.s 2$ ;Yep, move on
pea 5
jsr _FSVBDelay
addq.w #4,sp
dbf d2,1$
2$
movem.l (sp)+,d2/a2/a6
rts
* --------------------------------------------------------------------- *
* LONG FSCheckFlagChange(VOID);
* --------------------------------------------------------------------- *
XDEF _FSCheckFlagChange
_FSCheckFlagChange:
movea.l _FSReq,a0
move.w fs_flags(a0),d0
move.w _fsflags,d1
andi.w #%00011000,d0
andi.w #%00011000,d1
cmp.w d0,d1 ;FS_SHOW_FILES_FIRST or FS_SHOW_DIRS_FIRST changed?
beq.s 1$ ;Nope
move.w #1,_fsvirgindir ;Else we need to re-read the directory
1$
move.w fs_flags(a0),d0
move.w _fsflags,d1
andi.w #%01100000,d0
andi.w #%01100000,d1
cmp.w d0,d1 ;FS_SHOW_FILES_ONLY or FS_SHOW_DIRS_ONLY changed?
beq.s 2$ ;Nope
moveq #1,d0 ;Else flag that we need to FSMatchPattern()
bra.s 3$
2$
moveq #0,d0
3$
move.w fs_flags(a0),_fsflags ;Reset flags to match FSReq now
rts
* ------------------------------------------------------------------------
; Assign device name texts to intuitexts in the 4 Device Gadgets
* ------------------------------------------------------------------------
XDEF _SetDevGads
_SetDevGads:
movem.l d3-d4/a2-a3/a5,-(sp)
;for (i = 0, tnode = lastdev; i < 4;)
moveq #0,d4 ;d4 = i = 0
movea.l _lastdev,a2 ;a2 = tnode = lastdev
move.l a2,d3 ;Copy for comparison
lea _CurDevNames,a3 ;a3 = &CurDevNames[0]
lea _DevTxts,a5 ;a5 = &DevTxts[0]
1$
lea dn_name(a2),a1
move.l a1,0(a3,d4.w) ;CurDevNames[i] = tnode->name
moveq #4,d0
move.l 0(a5,d4.w),a0
movea.l it_IText(a0),a0
jsr astrncpy ;astrncpy (DevTxts[i]->IText, tnode->name, 4)
addq.w #4,d4 ;i++
movea.l dn_Node+MLN_SUCC(a2),a2 ;tnode = tnode->dn_Node.mln_Succ
tst.l dn_Node+MLN_SUCC(a2) ;if (tnode->dn_Node.mln_Succ == 0)
bne.s 2$ ;Nope
movea.l _devList,a2
movea.l MLH_HEAD(a2),a2 ;Else start the listing over at the start
2$
cmpa.l d3,a2 ;Have we already shown this node?
beq.s 3$ ;Yep, disable the rest
cmpi.w #16,d4 ;Set all 4 Device gadgets yet?
bcs 1$ ;Nope, do next
3$
* Disable any leftover gadgets
;for (; i < 4; i++)
lea _DevGads,a0
bra.s 5$
4$ movea.l 0(a0,d4.w),a1
bset.b #0,gg_Flags(a1) ;DevGads[i]->Flags |= GADGDISABLED
addq.w #4,d4
5$ cmpi.w #16,d4
bcs 4$
movem.l (sp)+,d3-d4/a2-a3/a5
rts
* ------------------------------------------------------------------------
; FSScrollDevGads(direction)
; WORD direction;
* ------------------------------------------------------------------------
XDEF _FSScrollDevGads
_FSScrollDevGads:
movem.l a2/a6,-(sp)
movea.l _lastdev,a0
tst.w 12+2(sp) ;Grab scroll direction
beq.s 1$ ;If zero, scroll to next
* Bump list pointer one direction or the other
move.l dn_Node+MLN_SUCC(a0),a0 ;Get successor
tst.l dn_Node+MLN_SUCC(a0) ;EndoList?
bne.s 2$ ;Nope
movea.l _devList,a0
movea.l MLH_HEAD(a0),a0 ;Else lastdev = devList->lh_Head
bra.s 2$
1$
movea.l dn_Node+MLN_PRED(a0),a0 ;Else, lastdev = lastdev->next
tst.l dn_Node+MLN_PRED(a0) ;Endolist?
bne.s 2$
movea.l _devList,a0
movea.l MLH_TAILPRED(a0),a0 ;Else lastdev = devList->lh_TailPred
2$
move.l a0,_lastdev
jsr _SetDevGads ;Set the gadget text fields
* Refresh gadget texts
;RefreshGList(&NIL2Gad, FSWin, 0L, 4L);
moveq #4,d0
suba.l a2,a2
movea.l _FSWin,a1
lea _NIL2Gad,a0
SYS RefreshGList,_IntuitionBase
movem.l (sp)+,a2/a6
rts
* ------------------------------------------------------------------------
; CheckFSArrows()
; See if the Up or Down arrow gadgets are currently activated, scroll
; the file display area or device gadget list if so.
* ------------------------------------------------------------------------
XDEF _CheckFSArrows
_CheckFSArrows:
subq.w #1,_FSCountDown
bge.s 12$
btst.b #7,_FSUpGad+gg_Flags+1 ;FSUpGad.Flags & SELECTED?
beq.s 2$ ;Nope, maybe FSDownGad
pea 1 ;Otherwise scroll filegadgets up
bra.s 3$
2$ btst.b #7,_FSDownGad+gg_Flags+1 ;FSDownGad.Flags & SELECTED?
beq.s 4$ ;Nope, maybe slide gadget is selected
pea 0 ;Otherwise scroll filegadgets down
3$ jsr _FSScrollFileGads
addq.w #4,sp
move.w #0,_FSCountDown ;Set timer to wake up in .02 secs.
bra.s 12$
4$ btst.b #7,_FSSlideGad+gg_Flags+1 ;FSSlideGad.Flags & SELECTED?
beq.s 5$ ;Nope, maybe UpDev
jsr _FSDoSlideGadget ;Process slide gadget motion
move.w #0,_FSCountDown ;Set timer to wake up in .02 secs.
bra.s 12$
5$ btst.b #7,_FSPrevDevs+gg_Flags+1 ;FSPrevDevs.Flags & SELECTED?
beq.s 7$ ;Nope, maybe DownDev
pea 1 ;Otherwise FSScrollDevGads(1);
6$ jsr _FSScrollDevGads
addq.w #4,sp
move.w #1,_FSCountDown ;Set timer to wake up in .16 secs.
bra.s 12$
7$ btst.b #7,_FSNextDevs+gg_Flags+1 ;FSNextDevs.Flags & SELECTED?
beq.s 10$ ;Nope, nothing of interest, slow down
pea 0 ;Else FSScrollDevGads(0);
bra 6$
10$
move.w #4,_FSCountDown
12$
rts
* ------------------------------------------------------------------------
; BYTE *FibFileDate(fib_date)
; struct DateStamp *fib_date;
;
; Calculate date based on DateStamp structure and return a pointer
; to the formatted date text.
* ------------------------------------------------------------------------
XDEF _FibFileDate
_FibFileDate:
link a5,#0
movem.l d3-d7,-(sp)
movea.l 8(a5),a1 ;Grab datestamp pointer
moveq #78,d7 ;Initial year = 1978
move.l (a1),d5 ;days = fib_date->ds_Days
blt ffdbaddate ;Hey! you can't be negative! Invalid date...
* Determine what year it is
divu #1461,d5
move.l d5,d0 ;Stash it
ext.l d5
lsl.l #2,d5
add.l d5,d7 ;year += (days / 1461) * 4
* Count how many months into that year
ffdgetmo:
swap d0
moveq #0,d5
move.w d0,d5 ;days %= 1461
1$ tst.w d5 ;Out of days yet?
beq.s 3$ ;Yep, done here
move.w #365,d6 ;Else month_days = 365
move.w d7,d0 ;Grab year
andi.w #3,d0 ;if (year & 3) == 0 Leap year?
bne.s 2$ ;Nope
addq.w #1,d6 ;Otherwise bump month_days
2$ cmp.w d6,d5 ;is day < month_days?
bcs.s 3$ ;yep, done here
sub.w d6,d5 ;otherwise day -= month_days
addq.l #1,d7 ; year++
bra 1$
3$
* Count how many days into that month of that year
ffdgetday:
;for (i = 0, day++; i < 12; i++)
moveq #0,d4 ;current month = 0
moveq #0,d6 ;Zap hinybs
addq.w #1,d5
lea _fsdayspermonth,a0
1$ move.b 0(a0,d4.w),d6 ;month_days = _fsdayspermonth[i]
cmpi.w #1,d4 ;if (i == 1 && (year & 3) == 0)
bne.s 2$
move.w d7,d0
andi.w #3,d0
bne.s 2$
addq.w #1,d6 ;month_days++
2$ cmp.w d6,d5 ;if (day <= month_days)
ble.s 4$ ;Break out, found the right month
sub.w d6,d5 ;Else, day -= month_days
addq.w #1,d4 ;i++
3$ cmpi.w #12,d4 ;Done all months yet?
bcs 1$ ;Nope
4$
ffdprint:
1$ cmpi.l #99,d7 ;while (year >= 100)
ble.s 2$
subi.l #100,d7 ;year -= 100
bra 1$
2$
;sprintf(_fstempdate, "%02ld-%02ld-%02ld %02ld:%02ld:%02ld", year, i + 1, day, hour, min, sec)
move.l 8(a1),d0 ;sec = fib_date->ds_Tick / 50;
divu.w #50,d0
ext.l d0
move.l d0,-(sp) ;Push secs
moveq #0,d0 ;Zap reg
move.w 6(a1),d0 ;min = fib_date->ds_Minute
move.w d0,d1 ;Clone it
divu #60,d0
move.w d0,d3 ;hour = min / 60
ext.l d3
mulu #60,d0
sub.w d0,d1 ;min -= hour * 60
ext.l d1
move.l d1,-(sp) ;Push mins
move.l d3,-(sp) ;Push hours
move.l d5,-(sp) ;Push day of month
addq.w #1,d4 ;Push month (offset by 1!)
move.l d4,-(sp)
move.l d7,-(sp) ;Push year
pea _fsdatefmtstr ;Push the format pattern
pea _fstempdate ;Push destination buffer
jsr _sprintf
lea 32(sp),sp
lea _fstempdate,a0
move.l a0,d0 ;return((BYTE *)&_fstempdate[0])
ffddone:
movem.l (sp)+,d3-d7
unlk a5
rts
ffdbaddate:
lea _fsbaddatestr,a0
move.l a0,d0 ;return (" <Invalid Date> ")
bra ffddone
* --------------------------------------------------------------------- *
XDEF _FSSetKnobHeight
_FSSetKnobHeight:
;vheight = (ULONG)( 655350L / (long)fsnumentries );
move.w _fsnumentries,d1
cmpi.w #10,d1
bhi.s 1$
move.w #$ffff,_fsvheight
rts
1$
move.l #655350,d0
divu d1,d0
move.w d0,_fsvheight
3$
rts
* --------------------------------------------------------------------- *
XDEF _FSSetKnobPos
_FSSetKnobPos:
movea.l _topfin,a0
moveq #0,d0
move.w fn_idnum(a0),d0
swap d0
move.w _fsnumentries,d1
subi.w #10,d1
bhi.s 1$
moveq #0,d0
bra.s 2$
1$
divu d1,d0
bvc.s 2$
move.w #$ffff,d0
2$
move.w d0,_fsvposition
rts
* --------------------------------------------------------------------- *
XDEF _FSResetKnob
_FSResetKnob:
jsr _FSSetKnobHeight
jsr _FSSetKnob
rts
* ------------------------------------------------------------------------
; FSSetKnob()
; Call ModifyProp() to actually update slide image in window.
* ------------------------------------------------------------------------
XDEF _FSSetKnob
_FSSetKnob:
movem.l d2-d5/a2/a6,-(sp)
;NewModifyProp(&FSSlideGad, FSWin, 0L, AUTOKNOB|FREEVERT|PROPB, 0L, vposition, 0xffffL, vheight, 1L)
lea _FSSlideGad,a0
movea.l _FSWin,a1
suba.l a2,a2
moveq #AUTOKNOB!FREEVERT!PROPBORDERLESS,d0
moveq #0,d1
moveq #0,d2
move.w _fsvposition,d2
move.l #$ffff,d3
moveq #0,d4
move.w _fsvheight,d4
moveq #1,d5
SYS NewModifyProp,_IntuitionBase
movem.l (sp)+,d2-d5/a2/a6
rts
* ------------------------------------------------------------------------
; FSEnableFGad(gadg_num)
; LONG gadg_num;
;
; Given a file gadget number, refresh the text for that entry.
* ------------------------------------------------------------------------
XDEF _FSEnableFGad
_FSEnableFGad:
movem.l a2-a3/a6,-(sp)
movea.l _FSRPort,a2
move.w 4+4*3+2(sp),d0 ;Grab gadget number
move.w d0,d1 ;Copy
lsl.w #2,d0 ;Conver to long offset
lea _FSFileNodes,a0
movea.l 0(a0,d0.w),a0 ;tnode = FSFileNodes[gadg_num]
movea.l fn_info(a0),a3 ;a3 = tnode->info
* Move to the right slot text position
mulu #11,d1
addi.w #19,d1
moveq #9,d0
movea.l a2,a1
SYS Move,_GfxBase ;Move(FSRPort, 9, gadnum*11+19)
* Set the pen color according to the node
move.w nd_textcolor(a3),d0
movea.l a2,a1
SYS SetAPen ;SetAPen(FSRPort, tinfo->textcolor)
* Blast out the text
moveq #56,d0
lea nd_alphadata(a3),a0
movea.l a2,a1
SYS Text ;Text(FSRPort, tinfo->alphadata, 56)
movem.l (sp)+,a2-a3/a6
rts
* ------------------------------------------------------------------------
; FSDisableFGad(gadg_num)
; LONG gadg_num;
;
; Given a file gadget number, fill that slot with the EmptyPattern
; and clear the FileNode[] slot for that gadget.
* ------------------------------------------------------------------------
XDEF _FSDisableFGad
_FSDisableFGad:
movem.l d2-d4/a2/a6,-(sp)
move.w 4*5+4+2(sp),d4 ;Grab gadget number
movea.l _FSRPort,a2
lea _EmptyPattern,a0
move.l a0,rp_AreaPtrn(a2) ;rp->AreaPtrn = EmptyPattern
move.b #1,rp_AreaPtSz(a2) ;rp->AreaPtSz = (BYTE)1
movea.l a2,a1
moveq #2,d0
SYS SetAPen,_GfxBase ;SetAPen(rp, 2)
move.w d4,d1
mulu #11,d1
addi.w #13,d1 ;miny = 13L + (gadg_num * 11)
move.l d1,d3
addq.w #7,d3 ;maxy = miny + 7L
movea.l a2,a1 ;FSWin->RPort
moveq #9,d0 ;minx
move.l #456,d2 ;maxx
SYS RectFill ;RectFill(rp, minx, miny, maxx, maxy)
clr.l rp_AreaPtrn(a2) ;rp->AreaPtrn = 0L
clr.b rp_AreaPtSz(a2) ;rp->AreaPtSz = (BYTE)0
move.w d4,d0
lsl.w #2,d0
lea _FSFileNodes,a0
clr.l 0(a0,d0.w) ;FSFileNodes[gadg_num] = 0L
movem.l (sp)+,d2-d4/a2/a6
rts
* --------------------------------------------------------------------- *
XDEF _FSDisableAllFGads
_FSDisableAllFGads:
move.l d2,-(sp)
moveq #0,d2
move.w _fsnumentries,d2
bra.s 2$
1$ move.l d2,-(sp)
jsr _FSDisableFGad ;FSDisableFGad(i)
addq.w #4,sp
addq.w #1,d2 ;i++
2$ cmpi.w #10,d2 ;Hit 10 entries?
bcs 1$ ;Nope, disable one
move.l (sp)+,d2
rts
* ------------------------------------------------------------------------
;struct file_node *AllocFileNode()
;
; Allocate a file_node structure and it's info block, return pointer
; to the file_node or NULL if allocation failed.
* ------------------------------------------------------------------------
XDEF _AllocFileNode
_AllocFileNode:
move.l a6,-(sp)
moveq #fn_SIZEOF+nd_SIZEOF,d0 ;sizeof(struct file_node)+sizeof(struct node_data)
move.l #MEMF_CLEAR,d1 ;MEMF_CLEAR
SYS AllocMem,4 ;Allocate file node structure
move.l d0,d1
beq.s 1$
movea.l d0,a0
addi.l #fn_SIZEOF,d1
move.l d1,fn_info(a0) ;Set pointer to tnode->info area
1$
movea.l (sp)+,a6
rts
* ------------------------------------------------------------------------
; FreeFileNode(tnode)
; struct file_node *tnode;
;
; Given a pointer to a file_node, Free the memory allocated for that node.
* ------------------------------------------------------------------------
XDEF _FreeFileNode
_FreeFileNode:
move.l a6,-(sp)
move.l 4+4(sp),d0 ;Grab tnode
beq.s 2$ ;Nope, get outta here
movea.l d0,a1
moveq #fn_SIZEOF+nd_SIZEOF,d0
SYS FreeMem,4 ;FreeMem(tnode, sizeof(struct file_node)+sizeof(struct node_data))
2$ movea.l (sp)+,a6
rts
* ------------------------------------------------------------------------
; FreeAllFNodes()
;
; Call FreeFileNode for each node in the linked list of file_nodes,
;then deallocate the head of the list (fnList)
* ------------------------------------------------------------------------
XDEF _FreeAllFNodes
_FreeAllFNodes:
movem.l a2/a6,-(sp)
move.l _fnList,d0 ;Is there a list?
beq.s 2$ ;Nope, get outta here
movea.l d0,a2 ;Grab head
movea.l 4,a6 ;Set for ExecBase
1$
movea.l a2,a0
SYS RemHead ;d0 = RemHead(fnList)
tst.l d0 ;Hit end?
beq.s 2$ ;yep
move.l d0,-(sp)
jsr _FreeFileNode ;Free the node
addq.w #4,sp
bra 1$ ;Remove next node
2$
* Reset other globals
clr.w _fsvposition ;Set slider position to top of area
move.w #$ffff,_fsvheight ;Max height
clr.w _fsnumentries ;Zero entries
movem.l (sp)+,a2/a6
rts
* ------------------------------------------------------------------------
;struct dev_node *AllocDevNode()
;
; Allocate a dev_node, return pointer to same
* ------------------------------------------------------------------------
XDEF _AllocDevNode
_AllocDevNode:
move.l a6,-(sp)
moveq #dn_SIZEOF,d0
move.l #MEMF_CLEAR,d1
SYS AllocMem,4 ;AllocMem(sizeof(struct dev_node), MEMF_CLEAR)
movea.l (sp)+,a6
rts
* ------------------------------------------------------------------------
;FreeDevNode(tnode)
; struct dev_node *tnode;
;
; Given a pointer to a dev_node, free memory allocated for that node.
* ------------------------------------------------------------------------
XDEF _FreeDevNode
_FreeDevNode:
move.l a6,-(sp)
move.l 4+4(sp),d0 ;Grab dev_node to free
beq.s 1$ ;Oops, nothing here
movea.l d0,a1
moveq #dn_SIZEOF,d0
SYS FreeMem,4 ;FreeMem(tnode, (long)sizeof(struct dev_node))
1$
movea.l (sp)+,a6
rts
* ------------------------------------------------------------------------
;FreeAllDNodes()
;
; Call FreeDevNode() for each dev_node in the linked list, then free the
; head of the list, devList.
* ------------------------------------------------------------------------
XDEF _FreeAllDNodes
_FreeAllDNodes:
movem.l a2/a6,-(sp)
move.l _devList,d0 ;Is there a head node?
beq.s 3$ ;Nope, don't deallocate
movea.l d0,a2 ;Grab head of device list
movea.l 4,a6 ;Set for execbase
1$ movea.l a2,a0
SYS RemHead ;d0 = RemHead(devList)
tst.l d0 ;Got one?
beq.s 2$ ;Nope, list is empty
move.l d0,-(sp)
jsr _FreeDevNode ;Free this device node
addq.w #4,sp
bra 1$
2$ movea.l a2,a1
moveq #MLH_SIZE,d0
SYS FreeMem ;FreeMem(devList, sizeof(MinList))
clr.l _devList
3$ movem.l (sp)+,a2/a6
rts
* ------------------------------------------------------------------------
; FreeFileSelect()
; Deallocate filenames and fileinfoblocks, unlock any locks
* ------------------------------------------------------------------------
XDEF _FreeFileSelect
_FreeFileSelect:
move.l a6,-(sp)
move.w #1,_fsvirgindir ;virgindir = 1
jsr _FreeAllFNodes ;Free all allocated filenames
jsr _FSClearLock ;Unlock any locks
* Free the head node itself
move.l _fnList,d0
beq.s 1$
movea.l d0,a1
moveq #MLH_SIZE,d0
SYS FreeMem,4 ;FreeMem(fnList, sizeof(MinList))
clr.l _fnList ;And clear the pointer
1$
* Free the global FileInfoBlock and InfoData struct
move.l _FSFib,d0 ;Do we have a FileInfoBlock allocated?
beq.s 2$ ;Nope
movea.l d0,a1
move.l #fib_SIZEOF+id_SIZEOF,d0
SYS FreeMem,4 ;FreeMem(FSFib, 300L)
clr.l _FSFib ;Set to NULL so we don't re-free it
clr.l _FSInfo
2$
movea.l (sp)+,a6
rts
* --------------------------------------------------------------------- *
* Cleanup function for fileselect
* --------------------------------------------------------------------- *
XDEF _ReleaseFileSelect
_ReleaseFileSelect:
jsr _FreeFileSelect
jsr _FreeAllDNodes
rts
* ------------------------------------------------------------------------
; LONG FSGetNextFib(VOID)
;
; Call ExNext() to fill in next FileInfoBlock, set titlebar to reflect
; status of the request.
* ------------------------------------------------------------------------
XDEF _FSGetNextFib
_FSGetNextFib:
movem.l d2/a6,-(sp)
* Try to get next fileinfoblock from dos
move.l _FSLock,d1
move.l _FSFib,d2
SYS ExNext,_DOSBase
tst.l d0 ;Did we get an entry?
bne.s gnfgot1 ;Yep, got it
* Didn't get one, find out why
;if ( (error = IoErr()) != ERROR_NO_MORE_ENTRIES)
SYS IoErr ;Get error number
cmpi.l #232,d0 ;No more entries?
beq.s gnfnme ;Yep
move.l d0,-(sp)
jsr _ioerrnum ;Otherwise set window title to error number
addq.w #4,sp
move.w d0,_fstitstatus
moveq #-1,d2 ;Return bad get status
bra.s gnfsetwintit
gnfnme:
moveq #0,d2 ;Return DONE!
tst.w _fsnumentries ;Got any valid pattern matches?
bne.s gnfselect ;Yep, select a file time
movea.l _fnList,a6
movea.l MLH_HEAD(a6),a6
tst.l fn_Node+MLN_SUCC(a6) ;Do we have any files?
beq.s gnfnoentry ;Nope, no entries
move.w #24,_fstitstatus ;Otherwise no match
bra.s gnfsetwintit
gnfnoentry:
move.w #22,_fstitstatus ;No Entries...
bra.s gnfsetwintit
gnfselect:
move.w #29,_fstitstatus ;Select a file...
gnfsetwintit:
bra.s gnfdone
gnfgot1:
moveq #1,d2
gnfdone:
move.l d2,d0
movem.l (sp)+,d2/a6
rts
* ------------------------------------------------------------------------
;AllocFSFib()
;Allocate a fileinfoblock, return status
* ------------------------------------------------------------------------
XDEF _AllocFSFib
_AllocFSFib:
move.l a6,-(sp)
tst.l _FSFib ;Do we already have a fib?
bne.s 1$ ;Yep, get out of here
;FSFib = AllocMem(sizeof(*FSFib) + sizeof(*FSInfo), MEMF_CLEAR);
move.l #fib_SIZEOF+id_SIZEOF,d0
move.l #MEMF_CLEAR,d1
SYS AllocMem,4
move.l d0,_FSFib
beq.s 2$ ;Oops, allocation failed, return 0
addi.l #fib_SIZEOF,d0
move.l d0,_FSInfo ;Set pointer to InfoData struct too
1$ moveq #1,d0 ;Return good status
2$ movea.l (sp)+,a6
rts
* ------------------------------------------------------------------------
;LONG ioerrnum(num)
; LONG num;
;
; Given an IoErr number, convert to error text table offset, return
; converted index number.
* ------------------------------------------------------------------------
XDEF _ioerrnum
_ioerrnum:
move.l 4(sp),d0
cmpi.w #202,d0 ;if (num < 202L || num > 231L)
bcs.s ioetl
cmpi.w #231,d0
bls.s ioe3l
ioetl:
moveq #27,d0 ;return(27)
rts
ioe3l:
cmpi.w #209,d0 ;if (num < 209L)
bcc.s ioe4l
subi.w #202,d0 ;num -= 202L
rts
ioe4l:
subi.w #205,d0 ;else num -= 205L
rts
* ------------------------------------------------------------------------
; BYTE *ioerrmsg(num)
; long num;
;
; Given a IoErr number, return pointer to error message text that
; describes that error.
* ------------------------------------------------------------------------
XDEF _ioerrmsg
_ioerrmsg:
move.l 4(sp),-(sp) ;Push error number
jsr _ioerrnum
addq.w #4,sp
lsl.w #2,d0 ;Convert return to text table offset
lea _fserrmsgs,a0
move.l 0(a0,d0.w),d0 ;Return pointer to fserrmsgs[num]
rts
* ------------------------------------------------------------------------
; VOID FSPutPath(VOID)
; Refresh the FSPathGadget imagery.
* ------------------------------------------------------------------------
XDEF _FSPutPath
_FSPutPath:
movem.l a2/a6,-(sp)
;RefreshGList(&FSPathGad, FSWin, 0L, 1L);
lea _FSPathGad,a0
movea.l _FSWin,a1
suba.l a2,a2
moveq #1,d0
SYS RefreshGList,_IntuitionBase
movem.l (sp)+,a2/a6
rts
* ------------------------------------------------------------------------
; VOID FSClearLock(VOID)
;
; If we have a Lock on the current directory, unlock it.
* ------------------------------------------------------------------------
XDEF _FSClearLock
_FSClearLock:
move.l a6,-(sp)
tst.w _fsdirlocked ;Is it locked?
beq.s 2$ ;Nope, don't dare unlock
move.l _FSLock,d1
beq.s 1$
SYS UnLock,_DOSBase ;UnLock(FSLock)
clr.l _FSLock ;FSLock = 0L;
1$ clr.w _fsdirlocked ;dirlocked = 0
2$ movea.l (sp)+,a6
rts
* ------------------------------------------------------------------------
; FSWinTitle()
; Refresh current window title using contents of windowtitle[].
* ------------------------------------------------------------------------
XDEF _FSWinTitle
_FSWinTitle:
movem.l a2/a6,-(sp)
move.w _fstitlelength,d0
lea _FSWinTitleStr,a0
clr.b 0(a0,d0.w) ;windowtitle[fstitlelength] = '\x0'
move.w _fstitstatus,d1
lsl.w #2,d1
lea _fserrmsgs,a1
movea.l 0(a1,d1.w),a1
adda.w d0,a0
jsr astrcpy ;astrcpy(&windowtitle[fstitlelength], fserrmsgs[fstitstatus])
movea.l _FSWin,a1
move.l wd_Flags(a1),d0 ;d0 = FSWin->Flags
andi.l #WINDOWTGADS,d0 ;Do we have titlebar gadgets?
bne.s 3$ ;Yep, refresh is automatic
lea _FSWinTitleStr+79,a1
clr.b (a1) ;FSWinTitleStr[79] = 0
move.b #' ',d0 ;for (;ptr != &FSWinTitle[79];ptr++)
2$ cmpa.l a0,a1
beq.s 4$
move.b d0,(a0)+ ;*ptr = ' '
bra 2$
3$
move.b #' ',(a0)+ ;Concat a space and a null onto the end
clr.b (a0)
4$
;SetWindowTitles(FSWin, windowtitle, -1L)
movea.l _FSWin,a0
lea _FSWinTitleStr,a1
movea.l #-1,a2
SYS SetWindowTitles,_IntuitionBase
movem.l (sp)+,a2/a6
rts
* ------------------------------------------------------------------------
; VOID FSEndString(VOID)
;
; If user started a string gadget entry then clicked in another gadget,
;ignore any changes to the string and restore the previous string.
* ------------------------------------------------------------------------
XDEF _FSEndString
_FSEndString:
movem.l a2/a6,-(sp)
move.w _fsstartedstr,d0 ;Grab starttext flag
cmpi.w #1,d0 ;Did user start at file entry?
bne.s fstnotfile ;Nope
movea.l _FSFileInfo,a0 ;Grab filename buffer
lea _FileUndoName,a1
lea _FSFileGad,a2 ;Grab filetext gadget
bra.s fstrefresh ;Refresh it
fstnotfile:
cmpi.w #2,d0 ;Did user start a path entry?
bne.s fstnotpath ;Nope, maybe pattern
movea.l _FSPathInfo,a0 ;Grab pathtext buffer
lea _FileUndoBuffer,a1
lea _FSPathGad,a2 ;Pointer to path gadget
bra.s fstrefresh ;Refresh text
fstnotpath:
cmpi.w #3,d0 ;Started a pattern entry?
bne.s fstdone ;Nope, don't have to do anything
movea.l _FSPatternInfo,a0 ;Else grab the pattern buffer
lea _FSPatternUndoBuffer,a1
lea _FSPatternGad,a2 ;Pointer to pattern gadget
fstrefresh:
jsr astrcpy ;astrcpy(tstr, FSwstr)
movea.l a2,a0
movea.l _FSWin,a1
suba.l a2,a2
moveq #1,d0
SYS RefreshGList,_IntuitionBase ;RefreshGList(tgad, FSWin, 0L, 1L)
clr.w _fsstartedstr ;fsstartedstr = 0
fstdone:
movem.l (sp)+,a2/a6
rts
* ------------------------------------------------------------------------
; FSDoGadget(gadgid)
; ULONG gadgid;
;
; Given a gadget id number, perform action associated with that gadget.
* ------------------------------------------------------------------------
XDEF _FSDoGadget
_FSDoGadget:
movem.l d4/a2,-(sp)
move.w 14(sp),d4 ;Grab gadget id number
bne.s dgnotusergad ;Not zero, not Undo gadget
* FSUserGad
jsr _ConcatPathString ;Concat final output text, return
clr.w _FSDone
movea.l _FSReq,a1
movea.l fs_specgadfunc(a1),a0
pea _FSUserGad
move.l _FSWin,-(sp)
move.l a1,-(sp)
jsr (a0)
lea 12(sp),sp
tst.l d0
bne dgnewdir
bra dogaddone
dgnotusergad:
* FSSelectGad
cmpi.w #1,d4 ;Is the the FSSelect gadget?
bne.s dgnotselect ;Nope
jsr _ConcatPathString ;Concat final output text, return
bra dogaddone
dgnotselect:
* FSCancelGad
cmpi.w #2,d4 ;Is it the FSCancel Gadget?
bne.s dgnotcancel ;Nope
move.w #1,_FSDone ;Global signal that we're done
movea.l _FSReq,a0 ;a0 = fsreq
movea.l fs_fullname(a0),a0 ;a0 = fsreq->fullname
clr.b (a0) ;Return filename == ""
bra dogaddone
dgnotcancel:
* UndoGad
cmpi.w #3,d4 ;Undo?
bne.s dgnotundo
movea.l _FSPathInfo,a0 ;Copy OldFSPathBuf to FSPathInfo.Buffer
movea.l _OldFSPathBuf,a1
jsr astrcpy ;astrcpy(FSPathInfo.Buffer, OldFSPathBuf)
bra dgnewdir ;Process new directory
dgnotundo:
* Dev1Gad
cmpi.w #20,d4 ;Is it the first Device Gadget?
bne.s dgnotram ;Nope
movea.l _CurDevNames+12,a1 ;Push the name text
dgdevs:
movea.l _FSPathInfo,a0 ;Destination text
jsr astrcpy ;Copy new path
bra dgnewdir ;Now set new directory
dgnotram:
cmpi.w #21,d4 ;Is it the second Device Gadget?
bne.s dgnotdf0 ;Nope
movea.l _CurDevNames+8,a1 ;Push the name text
bra dgdevs ;Change path
dgnotdf0:
cmpi.w #22,d4 ;Is it the third Device Gadget?
bne.s dgnotnil1 ;Nope
movea.l _CurDevNames+4,a1 ;Push the name text
bra dgdevs ;Set the path
dgnotnil1:
cmpi.w #23,d4 ;Is it the fourth Device Gadget?
bne.s dgnotnil2 ;Nope
movea.l _CurDevNames,a1 ;Push the name text
bra dgdevs ;And set the new path
dgnotnil2:
* RootGad
cmpi.w #24,d4 ;Is it the ROOT gadget?
bne.s dgnotroot ;Nope
jsr _SetRootDir ;Set root directory!
bra dogaddone ;Done
dgnotroot:
* ParentGad
cmpi.w #25,d4 ;Is it the Parent gadget?
bne.s dgnotpar ;Nope
jsr _SetParentDir ;Change to parent directory
bra dogaddone ;Done!
dgnotpar:
* FSPatternGad
cmpi.w #30,d4 ;Maybe its the pattern text gadget?
bne.s dgnotpattern
jsr _FSMatchPattern ;Otherwise attempt to match new pattern
bra dogaddone ;We're done!
dgnotpattern:
* FSFileGad
cmpi.w #31,d4 ;Is it the file text gadget?
bne.s dgnotfileg ;Nope
jsr _FSFileFunc
jsr _ConcatPathString ;Form final path text
btst.b #1,_fsflags+1 ;FS_NO_STRING_EXIT?
beq dogaddone
clr.w _FSDone
bra dogaddone
1$
movea.l _FSFileInfo,a0
tst.b (a0) ;Really a filename here?
bne.s 2$ ;yep
btst.b #2,_fsflags+1 ;FS_NO_STRING_OKAY?
beq.s 2$ ;Nope
bra dogaddone ;let user exit with no filename
2$
clr.w _FSDone ;Else we ain't done yet!
bra dogaddone
dgnotfileg:
* FSPathGad
cmpi.w #32,d4 ;Is it the path text gadget?
bne.s dgnotpath ;Nope
movea.l _FSPathInfo,a2 ;Grab pointer to path text
movea.l a2,a0
jsr astrlen ;Determine length
subq.w #1,d0 ;Move back to last BYTE
blt.s dgnotdamnsla ;Oops, null text!
cmpi.b #'/',0(a2,d0.w) ;Is the last char a slash?
bne.s dgnotdamnsla ;Nope, don't have to tromp it
1$ cmpi.b #'/',0(a2,d0.w) ;Check for a trailing slash
bne.s 2$ ;Didn't find another
clr.b 0(a2,d0.w) ;Clobber this slash
subq.w #1,d0 ;Dec character pointer
bne.s 1$ ;till we run out of slashes or chars
2$ jsr _FSPutPath ;Refresh path text
dgnotdamnsla:
jsr _FSDirFunc ;Do fsreq->dirfunc, if there is one
tst.w d0 ;Ignore new dir?
beq.s 1$ ;Nope
jsr _SetParentDir ;Else chop off the new path
jsr _FSPutPath ;Update string gad
clr.w _fsvirgindir ;Virgin again
bra.s dogaddone ;All done
1$
move.l _FSWin,-(sp)
pea _FSFileGad
jsr _MyActivateGad ;Activate file text gadget
addq.w #8,sp
bra.s dgnewdir ;Set new path, read new dir
dgnotpath:
* Slide Gadget
cmpi.w #33,d4 ;Is it the SlideGadget?
bne.s dgnotslide ;nope
jsr _FSDoSlideGadget ;Else it's been released, update position
bra.s dgresetarrows ;Done here, reset timer
dgnotslide:
* Arrow gadgets
cmpi.w #40,d4 ;Is it one of the four arrows gadgets?
blt.s dogaddone
cmpi.w #43,d4
bgt.s dogaddone
dgresetarrows:
clr.w _FSCountDown ;Kill any timer requests in progress
bra.s dogaddone
dgnewdir:
move.w #1,_fsvirgindir ;Set flag to read new directory!
dogaddone:
movem.l (sp)+,d4/a2
rts
* --------------------------------------------------------------------- *
* VOID FillFileNode(tnode)
* struct file_node *tnode;
* --------------------------------------------------------------------- *
ffnnode EQU 4+4*4
XDEF _FillFileNode
_FillFileNode:
movem.l d2/a2-a3/a6,-(sp)
movea.l ffnnode(sp),a0 ;a0 = tnode passed
movea.l fn_info(a0),a2 ;a2 = tinfo = tnode->info
movea.l _FSFib,a3 ;a3 = FSFib
move.l fib_Size(a3),nd_filesize(a2) ;tinfo->filesize = FSFib->fib_Size
move.l fib_DateStamp+0(a3),nd_days(a2) ;tinfo->day = FSFib->fib_DateStamp.ds_Days
move.l fib_DateStamp+4(a3),nd_minutes(a2)
move.l fib_DateStamp+8(a3),nd_ticks(a2)
pea fib_DateStamp(a3)
jsr _FibFileDate
addq.w #4,sp
movea.l d0,a1
lea nd_alphadata(a2),a0 ;a0 = tinfo->alphadata
jsr astrcpy ;a0 = astrcpy(&tinfo->alphadata[0], FibFileDate(&FSFib->DateStamp))
tst.l fib_DirEntryType(a3) ;If < 0 it is a file
bge.s ffnisdir ;>= 0, it is a dir
ffnisfile:
move.w #1,nd_filetype(a2) ;tinfo->filetype = 1
move.w #FPEN,nd_textcolor(a2) ;tinfo->textcolor = FPEN
move.l a0,-(sp)
move.l fib_Size(a3),-(sp)
pea _FSSizeFmtStr
move.l a0,-(sp)
jsr _sprintf ;sprintf(a0, "%8ld ", FSFib->fib_Size)
lea 12(sp),sp
movea.l (sp)+,a0
adda.w #9,a0 ;Skip filesize part of message
bra.s ffnsetname
ffnisdir:
move.w #2,nd_filetype(a2) ;tinfo->filetype = 2
move.w #DPEN,nd_textcolor(a2) ;tinfo->textcolor = DPEN
lea _FSDirFmtStr,a1
jsr astrcpy ;astrcpy(dest, FSDirFmtStr)
ffnsetname:
moveq #0,d0
lea fib_FileName(a3),a1 ;a1 = FSFib->fib_FileName
1$ move.b (a1)+,d1
beq.s 2$ ;Hit null, see if we need to pad
move.b d1,(a0)+ ;copy a char, till null
addq.w #1,d0 ;i++
cmpi.w #30,d0 ;Max chars yet?
bcs 1$
2$ move.w d0,nd_namelength(a2) ;tinfo->namelength = i
move.b #' ',d1
bra.s 4$ ;Append spaces till 30 chars
3$ move.b d1,(a0)+
addq.w #1,d0
4$ cmpi.w #30,d0
bcs 3$
clr.b (a0) ;Null terminate at 31st char
ffnsetshow:
movea.l ffnnode(sp),a2
moveq #1,d0
movea.l a2,a0 ;a0 = tnode
jsr _FSValidateEntry ;FSValidateEntry(tnode, 1)
* Now insert the node into list according to sort type
ffninsert:
movea.l _fnList,a3
movea.l MLH_HEAD(a3),a3 ;a3 = fnList->lh_Head
movea.l _FSReq,a0
move.w fs_sorttype(a0),d2 ;d0 = FSReq->sorttype
1$
tst.l fn_Node+MLN_SUCC(a3) ;Is this the end of the list?
beq.s 2$ ;Nope, insert it here
move.l fn_info(a3),a1 ;Push existing node->info
move.l fn_info(a2),a0 ;Push tnode->info
move.w d2,d0 ;Push sort type
jsr _CompareNodes ;Compare info's according to sort type
tst.w d0 ;Is a0 > a1?
beq.s 2$ ;nope, found insertion point
movea.l fn_Node+MLN_SUCC(a3),a3 ;oldnode = oldnode->next
bra 1$ ;Nope, keep looking
2$
movea.l _fnList,a0
movea.l a2,a1
move.l fn_Node+MLN_PRED(a3),a2
SYS Insert,4
ffndone:
movem.l (sp)+,d2/a2-a3/a6
rts
* --------------------------------------------------------------------- *
* VOID FSValidateEntry(tnode, mode)
* a0 d0
* --------------------------------------------------------------------- *
XDEF _FSValidateEntry
_FSValidateEntry:
movem.l d2-d3/a2,-(sp)
* See if the Acceptor likes this node name
move.l d0,d3 ;d3 = mode
movea.l a0,a2 ;a2 = tnode
move.l a2,-(sp)
jsr _FSAcceptEntry ;if (FSAcceptEntry(tnode) == 0)
addq.w #4,sp
tst.w d0
bne.s 1$
* Don't display this node
movea.l fn_info(a2),a0
clr.w nd_showit(a0) ;tnode->info->showit = 0;
move.w #-1,fn_idnum(a2) ;tnode->idnum = -1
bra.s 4$ ;And return
* Accept this node for display
1$ movea.l fn_info(a2),a0
move.w #1,nd_showit(a0) ;else tnode->info->showit = 1;
moveq #0,d2
move.w _fsnumentries,d2 ;Grab entry number for this node
bne.s 2$ ;Not first entry
move.l a2,_topfin ;topnode = tnode, first visible node
2$
move.w d2,fn_idnum(a2) ;tnode->idnum = fsnumentries
addq.w #1,_fsnumentries ;fsnumentries++, one more visible entry
clr.w _fsneedshow ;fsneedshow = 0, needs sorting
* If we haven't filled display area, show this entry
cmpi.w #10,d2 ;> 10 entries already?
bcc.s 3$ ;Yep, just set the knob
lea _FSFileNodes,a0
move.w d2,d0 ;Grab entry number
lsl.w #2,d0 ;Convert to long table offset
move.l a2,0(a0,d0.w) ;FSFileNodes[fsnumentries] = tnode
move.l d2,-(sp)
jsr _FSEnableFGad ;FSEnableFGad(fsnumentries)
addq.w #4,sp
bra.s 4$ ;Skip setting knob, it is still full size
3$
tst.w d3 ;Want slide update?
beq.s 4$ ;Nope
; btst.b #7,_FSSlideGad+gg_Flags+1 ;User has slide gadget in use?
; bne.s 4$ ;Yes, don't refresh it while in use
* Calc new knob size and refresh
btst.l #0,d2 ;(idnum % 2) == 0?
beq.s 4$ ;Yep, don't reset on even values
jsr _FSResetKnob
4$
movem.l (sp)+,d2-d3/a2
rts
* --------------------------------------------------------------------- *
* Update FileTexts list, redisplay
* Renumber list, find new topfin
* --------------------------------------------------------------------- *
XDEF _FSUpdateSort
_FSUpdateSort:
move.w _fsneedshow,d0
blt.s 3$
move.w _fsnumentries,d1
beq.s 2$
subi.w #10,d1 ;Less max number of visible files
move.w _FSSlideProp+4,d0 ;Grab current vpot
mulu d1,d0 ;Times position percentage
addi.l #32768,d0
clr.w d0
swap d0
jsr _FSResetNumEntries
jsr _FSSetFileGads
2$
move.w #-1,_fsneedshow
moveq #0,d0
3$ tst.w d0
rts
* --------------------------------------------------------------------- *
* VOID FSResetNumEntrys(idnum)
* d0:16
* --------------------------------------------------------------------- *
XDEF _FSResetNumEntries
_FSResetNumEntries:
move.l a2,-(sp)
movea.l _fnList,a2 ;Grab List
movea.l MLH_HEAD(a2),a2 ;Head of list
moveq #0,d1 ;i = 0
1$ tst.l fn_Node+MLN_SUCC(a2) ;End of list?
beq.s 5$
movea.l fn_info(a2),a0 ;a0 = tnode->info
tst.w nd_showit(a0) ;Visible?
bne.s 2$ ;Yep
move.w #-1,fn_idnum(a2) ;Else tnode->idnum = -1
bra.s 4$ ;Next node
2$ move.w d1,fn_idnum(a2) ;tnode->idnum = i
cmp.w d1,d0 ;if (idnum == oldidnum)
bne.s 3$
move.l a2,_topfin ; topfin = tnode;
3$
addq.w #1,d1 ;i++
4$
movea.l fn_Node+MLN_SUCC(a2),a2 ;tnode = tnode->fn_Node.mln_Succ
bra 1$ ; Check next node
5$
move.w d1,_fsnumentries ;Update number of entries
movea.l (sp)+,a2
rts
* --------------------------------------------------------------------- *
* LONG FSAcceptEntry(struct file_node *tnode);
* Decide whether given tnode is displayable.
* Return 0L for ignore this node, 1L for valid node.
* --------------------------------------------------------------------- *
aftnode EQU 8
aftname EQU -48
XDEF _FSAcceptEntry
_FSAcceptEntry:
link a5,#aftname
movem.l a2-a3,-(sp)
movea.l aftnode(a5),a2 ;Grab tnode
movea.l fn_info(a2),a3 ;Grab tnode->info
* Copy tnode->info->alphadata name section to stack, null terminate
move.w nd_namelength(a3),d0 ;Push tinfo->namelength
lea nd_alphadata+26(a3),a1 ;Push tinfo->alphadata + 26
lea aftname(a5),a0 ;Push destination
jsr astrncpy ;Copy and null terminate
* If there is a special match function defined, use that...
movea.l _FSReq,a0
tst.l fs_matchfunc(a0) ;If FSReq->matchfunc != 0
beq.s 1$
move.l aftnode(a5),-(sp)
pea aftname(a5)
move.l _FSReq,-(sp)
move.l fs_matchfunc(a0),a0
jsr (a0) ;return((FSReq->matchfunc)(FSReq, name, tnode)
lea 12(sp),sp
bra.s aftdone
* Otherwise use built-in acceptor routine
1$ cmpi.w #2,nd_filetype(a3) ;Is tinfo->filetype == 2? (a directory)
beq.s aftisdir ;Yep, we need it in list
* Check file name against patterns
btst.b #6,_fsflags+1 ;Want dirs only?
bne.s aftwrongpat ;Yep, ignore all files
pea _FSIgnorePat ;See if it matches the ignore text
pea aftname(a5)
jsr _wildmatch
addq.w #8,sp
tst.w d0 ;Did it match the ignore text?
bne.s aftwrongpat ;Yep, ignore this file
move.l _FSPatternInfo,-(sp) ;See if it matches desired pattern
pea aftname(a5)
jsr _wildmatch
addq.w #8,sp
tst.w d0 ;Did it match?
beq.s aftwrongpat ;Nope, skip it
bra.s aftgoodpat ;Else accept this file
aftisdir:
btst.b #5,_fsflags+1 ;This is a dir, want files only?
bne.s aftwrongpat ;Yep, ignore this dir
aftgoodpat:
moveq #1,d0 ;Accept this entry
bra.s aftdone
aftwrongpat:
moveq #0,d0 ;Ignore this entry
aftdone:
movem.l (sp)+,a2-a3
unlk a5
rts
* --------------------------------------------------------------------- *
* VOID FSMatchPattern(VOID);
* Called when path or pattern has changed - rematch all entries
* against the new pattern, display entries that match.
* --------------------------------------------------------------------- *
XDEF _FSMatchPattern
_FSMatchPattern:
movem.l d4/a2-a3/a6,-(sp)
* Pattern match list against new pattern, flag unwanted names
movea.l _FSPatternInfo,a0 ;Grab pattern
tst.b (a0) ;Null pattern text?
bne.s mnpnotnop ;Nope, process it
move.b #'*',(a0)+ ;Otherwise put back wildstar
clr.b (a0) ;Null terminate
lea _FSPatternInfo,a0 ;Grab stringinfo
move.w #1,8(a0) ;FSPatternInfo.BufferPos = 1;
lea _FSPatternGad,a0
movea.l _FSWin,a1
suba.l a2,a2
moveq #1,d0
SYS RefreshGList,_IntuitionBase ;Refresh pattern text gadget
move.l _FSWin,-(sp)
pea _FSPatternGad
jsr _MyActivateGad ;MyActivateGad(&FSPatternGad, FSWin)
addq.w #8,sp
bra.s mnpdone ;Make the user type something else in
mnpnotnop:
movea.l _fnList,a0
move.l MLH_HEAD(a0),a0
tst.l fn_Node+MLN_SUCC(a0) ;Do we have any files to match?
beq.s mnpdone ;Nope, nothing to do
* Reset knob to full height, zero position
clr.w _fsnumentries ;Clear fsnumentries count
clr.w _fsvposition
move.w #$ffff,_fsvheight
jsr _FSSetKnob ;Show new knob
* Disable all file "gadgets"
jsr _FSDisableAllFGads
* Scan list, enable/flag entries that match new pattern
movea.l _fnList,a2 ;tnode = fnList
movea.l MLH_HEAD(a2),a2 ;tnode = head node
clr.l _topfin ;Clear out top/bot display pointers
1$
tst.l fn_Node+MLN_SUCC(a2) ;End of list?
beq.s 2$
moveq #0,d0
movea.l a2,a0
jsr _FSValidateEntry ;FSValidateEntry(tnode, 0)
movea.l fn_Node+MLN_SUCC(a2),a2 ;tnode = tnode->fn_Node.mln_Succ
bra 1$ ;Nope, process this one too
2$
move.w #-1,_fsneedshow ;Clear reshow/sort flag, list valid
cmpi.w #10,_fsnumentries ;Found some entries?
bls.s mnpsettitle ;Yep, skip setting knob again
jsr _FSResetKnob ;Show new knob size
mnpsettitle:
tst.w _fsnumentries ;Got any matches to pattern?
bne.s mnpmatchedsome ;Yep
move.w #24,_fstitstatus ;"Nothing matched PATTERN"
bra.s mnpnewtit
mnpmatchedsome:
move.w #29,_fstitstatus ;"Select a file..."
mnpnewtit:
jsr _FSWinTitle ;Show final title status
mnpdone:
movem.l (sp)+,d4/a2-a3/a6
rts
* ----------------------------------------------------------------------
; VOID ConcatPathString(VOID)
;
; If the file text is non-NULL, concat path text and file text,
; set global exit flag to show user selected a filename.
* ----------------------------------------------------------------------
XDEF _ConcatPathString
_ConcatPathString:
* Try to add path prefix
move.l _FSFileInfo,-(sp)
move.l _FSPathInfo,-(sp)
movea.l _FSReq,a0 ;Grab final pathtext
movea.l fs_fullname(a0),a0
move.l a0,-(sp)
jsr _ConcatDirFile ;ConcatDirFile(FSReq->fullname, FSPathInfo->Buffer, FSFileInfo->Buffer)
lea 12(sp),sp
* Did the user select a filename yet?
movea.l _FSFileInfo,a0
tst.b (a0) ;First byte of name null?
bne.s 1$ ;Nope, must be okay
btst.b #2,_fsflags+1 ;(FSFlags & FS_NO_STRING_OKAY) == 0?
beq.s 2$ ;Yep, user can't exit till something is entered
1$
* Flag main loop to exit
move.w #1,_FSDone
2$
rts
* --------------------------------------------------------------------- *
* VOID __stdargs ConcatDirFile(BYTE *, BYTE *, BYTE *)
* --------------------------------------------------------------------- *
XDEF _ConcatDirFile
_ConcatDirFile:
movem.l 4(sp),a0-a1 ;grab dest, dirname
tst.b (a1) ;Is there a dirname here?
beq.s 1$ ;Nope
jsr astrcpy ;astrcpy(dest, dirname)
movea.l 12(sp),a1 ;grab filename
tst.b (a1) ;Is there a filename?
beq.s 2$ ;Nope, don't concat a slash
move.b -1(a0),d0 ;d0 = dest[strlen(dest - 1)]
cmpi.b #':',d0 ;Already has a colon?
beq.s 1$ ;Yep
cmpi.b #'/',d0 ;Already has a slash?
beq.s 1$ ;Yep
move.b #'/',(a0)+ ;Append a slash
clr.b (a0) ;Terminate
1$
movea.l 12(sp),a1
jsr astrcpy ;astrcpy(dest, name)
2$
rts
* ------------------------------------------------------------------------
* VOID FSDoSlideGadget(VOID)
*
* Process the current slide gadget position, scroll file entries
* to match current position.
* ------------------------------------------------------------------------
XDEF _FSDoSlideGadget
_FSDoSlideGadget:
movem.l d4-d5,-(sp)
jsr _FSUpdateSort
beq dsgdone
cmpi.w #10,_fsnumentries ;Do we have less than 10 entries?
blt dsgdone ;Yep, can't move anyhow
moveq #0,d0
move.w _FSSlideProp+4,d0 ;Grab new vpot
cmp.w _fsvposition,d0 ;Has it moved?
beq dsgdone ;Nope
move.w d0,_fsvposition ;Otherwise update position
move.w _fsnumentries,d4 ;Grab number of entries
subi.w #10,d4 ;Less max number of visible files
mulu d0,d4 ;Times position percentage
addi.l #32768,d4
clr.w d4
swap d4
movea.l _topfin,a0 ;Grab top node
cmp.w fn_idnum(a0),d4 ;Is node->idnum the same as newpos?
beq.s dsgdone ;Yep, don't have to move it
bcc.s dsgscrup ;newpos is lower, scroll up
**************
* Scroll Down
**************
move.w fn_idnum(a0),d0 ;Grab topfin->idnum
sub.w d4,d0 ;i = idnum - newpos
cmpi.w #8,d0 ;Need to scroll more than 8?
ble.s dsgssdwn ;Nope, use slow scroll
dsgdwn1:
cmp.w fn_idnum(a0),d4 ;Is topfin->idnum == newpos yet?
beq.s dsgredo ;Yep, we are done
dsgpretop:
movea.l fn_Node+MLN_PRED(a0),a0 ;topfin = topfin->fn_Node.mln_Pred
tst.w fn_idnum(a0) ;Is this idnum >= 0?
blt.s dsgpretop ;Nope, keep looking
bra.s dsgdwn1 ;Check this new position
dsgssdwn:
move.l d0,-(sp)
jsr _FSScrollDownGads ;Scroll entries down d5 times
addq.w #4,sp
bra.s dsgdone
************
* Scroll Up
************
dsgscrup:
move.w d4,d5 ;Grab newpos
sub.w fn_idnum(a0),d5 ;i = newpos - node->idnum
cmpi.w #8,d5 ;i > 8?
ble.s dsgssup ;Nope, use slow scroll
dsgmvup1:
cmp.w fn_idnum(a0),d4 ;Is topfin->idnum == newpos yet?
beq.s dsgredo ;Yep, we are done
dsgnxttop:
movea.l fn_Node+MLN_SUCC(a0),a0 ;topfin = topfin->fn_Node.mln_Succ
tst.w fn_idnum(a0) ;Is this a valid entry?
blt.s dsgnxttop ;Nope, move on
bra.s dsgmvup1
dsgredo:
move.l a0,_topfin ;Set new top and bottom
jsr _FSSetFileGads ;Redraw all the file entries
bra.s dsgdone ;We're done
dsgssup:
move.l d5,-(sp)
jsr _FSScrollUpGads ;Scroll the entries up d5 times
addq.w #4,sp
dsgdone:
movem.l (sp)+,d4-d5
rts
* --------------------------------------------------------------------
* VOID FSStartScrollGad(gadcode)
* ULONG gadcode;
* Given Gadget ID code, respond to first user click on a arrow gadget.
* Reset the timer.device so that .25 seconds delay occurs before
* the autorepeat kicks in.
* --------------------------------------------------------------------
XDEF _FSStartScrollGad
_FSStartScrollGad:
move.w 6(sp),d0 ;Grab gadget code
subi.w #33,d0 ;Slide gad
bne.s 1$
jsr _FSDoSlideGadget
clr.w _FSCountDown
rts
1$
subi.w #7,d0 ;33+7=40, UpGad
bne.s 2$
pea 1
11$ jsr _FSScrollFileGads
addq.w #4,sp
bra.s ssgdone
2$
subq.w #1,d0 ;33+7+1=41, DownGad
bne.s 3$
pea 0
bra 11$
3$
subq.w #1,d0 ;33+7+2=42, UpDev
bne.s 4$
pea 1
33$ jsr _FSScrollDevGads
addq.w #4,sp
bra.s ssgdone
4$
subq.w #1,d0 ;33+7+3=43, DownDev
bne.s ssgrts
pea 0
bra 33$
ssgdone:
move.w #4,_FSCountDown
ssgrts:
rts
* -----------------------------------------------------------------------
* FSScrollFileGads(direction)
* BOOL direction;
*
* Scroll the file entries up or down by 1
* if (direction == 0)
* scrollup;
* else
* scrolldown;
* -----------------------------------------------------------------------
XDEF _FSScrollFileGads
_FSScrollFileGads:
;if (fsnumentries > 10)
cmpi.w #10,_fsnumentries ;Less than 10 entries?
ble.s sfgdone ;Yep, can't scroll anyhow
;if (direction)
; FSScrollDownGads(1);
tst.w 6(sp) ;ScrollDown?
beq.s sfgup ;Nope, scroll up
pea 1
jsr _FSScrollDownGads
addq.w #4,sp
bra.s sfgpos
sfgup:
;FSScrollUpGads(1)
pea 1
jsr _FSScrollUpGads
addq.w #4,sp
sfgpos:
* Reset the slide knob position the display movement
jsr _FSSetKnobPos
jsr _FSSetKnob ;Set new knob position
sfgdone:
rts
* -------------------------------------------------------------------------
; FSScrollUpGads(count)
; LONG count;
;
; Single-step scroll the file entries up count times.
* -------------------------------------------------------------------------
XDEF _FSScrollUpGads
_FSScrollUpGads:
link a5,#0
movem.l d2-d7/a2/a6,-(sp)
jsr _FSUpdateSort
beq.s sugdone
movea.l _FSRPort,a2
;for (i = 0; i < count; i++)
moveq #0,d7
bra.s sugchk1
sugloop1:
* If the bottom entry is not the last entry, scroll it up
movea.l _topfin,a0 ;Grab top visible node
move.w fn_idnum(a0),d0 ;Grab id number
addi.w #11,d0 ;Plus 11
cmp.w _fsnumentries,d0 ;Compare to last known entry
bgt.s sugdone ;Yep, can't scroll up any more
* Bump the top pointer down the list to the next visible entry
movea.l _topfin,a0
1$ move.l fn_Node+MLN_SUCC(a0),a0 ;topfin = topfin->fn_Node.mln_Succ
tst.w fn_idnum(a0) ;while (topfin->idnum < 0)
blt 1$ ;Not a valid entry
move.l a0,_topfin ;Here's our new top entry node
* Now reassign the visible file gadget array to the new node list
jsr _FSAssignNodes
* Display new file entries and redraw borders
;ClipBlit(rp, 9L, 24L, rp, 9L, 13L, 447L, 96L, 0xc0L);
movea.l a2,a0
moveq #9,d0
moveq #24,d1
movea.l a2,a1
moveq #9,d2
moveq #13,d3
move.l #447,d4
moveq #96,d5
move.l #$0c0,d6
SYS ClipBlit,_GfxBase
;FSEnableFGad(9);
move.l #9,-(sp)
jsr _FSEnableFGad ;Now draw the new gadget at bottom
addq.w #4,sp
addq.w #1,d7 ;Bump scroll count
sugchk1:
cmp.w 10(a5),d7 ;Have we scrolled enough?
blt sugloop1 ;Nope, do again
sugdone:
movem.l (sp)+,d2-d7/a2/a6
unlk a5
rts
* -------------------------------------------------------------------------
; FSScrollDownGads(count)
; LONG count;
;
; Single-step scroll the file entries down count times.
* -------------------------------------------------------------------------
XDEF _FSScrollDownGads
_FSScrollDownGads:
link a5,#0
movem.l d2-d7/a2/a6,-(sp)
jsr _FSUpdateSort
beq.s sdgdone
movea.l _FSRPort,a2
;for (i = 0; i < count; i++)
moveq #0,d7
bra.s sdgchk1
sdgloop1:
;If the top entry is not the first entry, scroll it down
movea.l _topfin,a0 ;Grab top node
tst.w fn_idnum(a0) ;idnum == 0?
beq.s sdgdone ;Yep, can't scroll down any more
* Bump the top and bottom entry pointers down the list
1$ movea.l fn_Node+MLN_PRED(a0),a0 ;topfin = topfin->fn_Node.mln_Pred
tst.w fn_idnum(a0) ;while (topfin->idnum < 0)
blt 1$
move.l a0,_topfin ;New topfin
* Now reassign the visible file gadget array to the new node list
jsr _FSAssignNodes
* Display new file entries and redraw borders
;ClipBlit(rp, 9L, 13L, rp, 9L, 24L, 447L, 96L, 0xc0L)
movea.l a2,a0
moveq #9,d0
moveq #13,d1
movea.l a2,a1
moveq #9,d2
moveq #24,d3
move.l #447,d4
moveq #96,d5
move.l #$0c0,d6
SYS ClipBlit,_GfxBase
;FSEnableFGad(0);
pea 0
jsr _FSEnableFGad ;Display the only new "gadget"
addq.w #4,sp
addq.w #1,d7 ;Bump scroll count
sdgchk1:
cmp.w 10(a5),d7 ;Have we scrolled enough?
blt sdgloop1 ;Nope, do again
sdgdone:
movem.l (sp)+,d2-d7/a2/a6
unlk a5
rts
* -------------------------------------------------------------------
* VOID FSAssignNodes(VOID)
* -------------------------------------------------------------------
XDEF _FSAssignNodes
_FSAssignNodes:
movem.l a2-a3,-(sp)
;for (tnode = topfin, i = 0; ;tnode = tnode->next)
lea _FSFileNodes,a3 ;Grab base address of array of filegadgets
movea.l _topfin,a2 ;Grab our top visible filenode
moveq #10,d0 ;Fill 10 gadgets max
ran1:
tst.l fn_Node+MLN_SUCC(a2) ;Succ == 0?
beq.s ragdone ;Ran out of list entries
;if (tnode->idnum >= 0)
tst.w fn_idnum(a2) ;Is this name "visible"?
blt.s ragchkbot ;Nope, skip it
move.l a2,(a3)+ ;FSFileNodes[i] = tnode
subq.w #1,d0 ;One less slot available
beq.s ragdone ;Filled all the slots, exit loop
ragchkbot:
movea.l fn_Node+MLN_SUCC(a2),a2
bra ran1 ;check next node
ragdone:
movem.l (sp)+,a2-a3
rts
* -----------------------------------------------------------------------
; VOID __stdargs FSDoFileGad(Ypos)
; LONG Ypos;
;
; Based on the mouse's Ypos passed, select file entry that user clicked.
* -----------------------------------------------------------------------
XDEF _FSDoFileGad
_FSDoFileGad:
link a5,#0
movem.l d2-d4/a2-a3/a6,-(sp)
moveq #0,d4
move.w 10(a5),d4 ;Grab gadget y position
subi.w #12,d4 ;Less 12 (top edge of first entry)
divu #11,d4 ; divided by 11 (height of each entry)
ext.l d4 ;Blow remainder, this is our entry number
move.w d4,d0
lsl.w #2,d0 ;Convert to long offset
lea _FSFileNodes,a2 ;Grab base address of visible node_datas
movea.l 0(a2,d0.w),a3 ;Grab FSFileNodes[gadg_num]
cmpa.l #0,a3
beq dfgdone ;If zero, not a active "gadget" slot
;strncpy(FSwstr, tinfo->alphadata + 26L, tinfo->namelength)
movea.l fn_info(a3),a3 ;tinfo = tnode->info
lea _FSwstr,a2 ;Grab address of worktext
move.w nd_namelength(a3),d0 ;Push tinfo->namelength
lea nd_alphadata+26(a3),a1 ;Push tinfo->alphadata + 26
movea.l a2,a0 ;Push dest text
jsr astrncpy ;strncpy(FSwstr, filename, namelength)
;if (tinfo->filetype == 1)
cmpi.w #1,nd_filetype(a3) ;Did user click on a filename?
bne.s dfgnotfile ;Nope, must be a dir
;if ( strcmp(FSFileInfo.Buffer, FSwstr) )
movea.l a2,a1 ;Push FSwstr
movea.l _FSFileInfo,a0 ;Push address of filebuffer
jsr astrcmp
tst.w d0 ;Is this the same as what we already have?
beq.s dfgnsname ;Yep, see if it was double-clicked
;strcpy(FSFileInfo.Buffer, FSwstr)
movea.l a2,a1
movea.l _FSFileInfo,a0
jsr astrcpy ;Otherwise copy new filename to filebuffer
lea _FSFileGad,a0 ;And refresh filename text gadget
movea.l _FSWin,a1
suba.l a2,a2
moveq #1,d0
SYS RefreshGList,_IntuitionBase
bra dfgfiledone
dfgnsname:
;if ( DoubleClick(fsoldsecs, fsoldmicros, fscursecs, fscurmicros &&
; (gadg_num == fsprevgadid) )
; ConcatPathString();
btst.b #0,_fsflags+1 ;FS_NO_DCLICK_EXIT?
bne dfgfiledone ;Yep, programmer doesn't allow that
cmp.w _fsprevgadid,d4 ;Is it the same gadget?
bne dfgfiledone ;Nope, can't be a double click
move.l _fsoldsecs,d0
move.l _fsoldmicros,d1
move.l _fscursecs,d2
move.l _fscurmicros,d3
SYS DoubleClick,_IntuitionBase
tst.w d0 ;Is it within click speed parameters?
beq.s dfgfiledone ;Nope
jsr _ConcatPathString ;Construct full path text
bra.s dfgdone
;Clicked on a DIR
dfgnotfile:
cmpi.w #1,_fsvirgindir ;if (virgindir != 1)
beq.s dfgdone ;Don't concat if we haven't locked dir yet
;i = strlen(FSPathInfo.Buffer);
move.l _FSPathInfo,a0
jsr astrlen
move.w d0,d2 ;Length of stuff already in path text
;if ( (strlen(FSwstr) + i) < PATHSTRSIZE)
movea.l a2,a0
jsr astrlen
add.w d2,d0
cmpi.w #PATHSTRSIZE-1,d0
bge.s dfgtoodeep ;Don't append path if no room!
move.l a2,-(sp)
move.l _FSPathInfo,-(sp)
move.l _FSPathInfo,-(sp)
jsr _ConcatDirFile ;ConcatDirFile(FSPathInfo->Buffer, FSPathInfo->Buffer, FSwstr)
lea 12(sp),sp
jsr _FSDirFunc ;Do FSReq->dirfunc, if there is one
tst.w d0 ;Avoid reading this dir?
beq.s 1$ ;Nope, process it
move.l _FSPathInfo,a0
clr.b 0(a0,d2.w) ;Else FSPathInfo->Buffer[oldstrlen] = 0
bra.s dfgdone
1$
move.w #1,_fsvirgindir ;virgindir = 1, read the new directory
bra.s dfgdone
dfgtoodeep:
move.w #12,_fstitstatus ;fstitstatus = 12
jsr _FSWinTitle
suba.l a0,a0
SYS DisplayBeep,_IntuitionBase
bra.s dfgdone
dfgfiledone:
jsr _FSFileFunc ;Call FSReq->filefunc, if there is one
dfgdone:
move.w d4,_fsprevgadid ;fsprevgadid = gadg_num
movem.l (sp)+,d2-d4/a2-a3/a6
unlk a5
rts
* --------------------------------------------------------------------- *
* LONG FSDirFunc(VOID);
* If there is a fsrequest->dirfunc, this routine handles the interface.
* --------------------------------------------------------------------- *
XDEF _FSDirFunc
_FSDirFunc:
move.l d2,-(sp)
moveq #0,d0
movea.l _FSReq,a0 ;Grab our FSRequest struct
move.l fs_dirfunc(a0),d2 ;Is there a user dir function to call?
beq.s 1$ ;Nope, that's all we have to do this click!
jsr _ConcatPathString ;Combine dir/file as fullname for return
clr.w _FSDone ;Not done though, undo return status
move.l _FSWin,-(sp)
move.l _FSReq,-(sp)
movea.l d2,a0
jsr (a0) ;d0 = (FSReq->dirfunc)(FSReq, FSWin)
addq.w #8,sp
1$
move.l (sp)+,d2
rts
* --------------------------------------------------------------------- *
* VOID FSFileFunc(VOID);
* If there is a fsrequest->filefunc, this routine handles the interface.
* --------------------------------------------------------------------- *
XDEF _FSFileFunc
_FSFileFunc:
move.l d2,-(sp)
movea.l _FSReq,a0 ;Grab our FSRequest struct
move.l fs_filefunc(a0),d2 ;Is there a user file function to call?
beq.s 1$ ;Nope, that's all we have to do this click!
jsr _ConcatPathString ;Combine dir/file as fullname for return
clr.w _FSDone ;Not done though, undo return status
move.l _FSWin,-(sp)
move.l _FSReq,-(sp)
movea.l d2,a0
jsr (a0) ;d0 = (FSReq->filefunc)(FSReq, FSWin)
addq.w #8,sp
tst.l d0 ;Return 0?
beq.s 1$ ;Yep
move.w #1,_fsvirgindir ;Else re-read directory
1$
move.l (sp)+,d2
rts
* -----------------------------------------------------------------------
* VOID FSSetFileGads(VOID)
* Assign and render currently active file texts, disable remainder
* -----------------------------------------------------------------------
XDEF _FSSetFileGads
_FSSetFileGads:
movem.l d4-d5,-(sp)
move.w _fsnumentries,d5 ;Grab number of entries
beq.s 3$ ;No entries, nothing to set!
* Update visible list based on topfin point in linked list
jsr _FSAssignNodes
* Show all used gadgets
moveq #0,d4 ;i = 0
bra.s 2$
1$
move.l d4,-(sp)
jsr _FSEnableFGad
addq.w #4,sp
addq.w #1,d4 ;Bump gadget count
2$
cmpi.w #10,d4 ;Hit highest gadget?
bcc.s 3$ ;Yep, done
cmp.w d5,d4 ;Else, Hit last gadget?
bcs 1$ ;Nope enable another
3$
movem.l (sp)+,d4-d5
rts
* ------------------------------------------------------------------------
* SetRootDir()
* Chop off all subdirectory names contained in FSPathInfo, moving up to
* root name if possible. Flag to read new directory in any case.
* ------------------------------------------------------------------------
XDEF _SetRootDir
_SetRootDir:
;if ( (tstr = strchr(FSPathInfo.Buffer, ':')) != 0L)
moveq #':',d0
movea.l _FSPathInfo,a0
jsr aindex
tst.l d0
beq.s 1$ ;Nope
clr.b 1(a0) ;Otherwise clobber the char after ':'
move.w #1,_fsvirgindir ;virgindir = 1, read directory
1$ rts
* ------------------------------------------------------------------------
; SetParentDir()
; Chop off last directory name contained in FSPathInfo, moving up one level
; if possible.
* ------------------------------------------------------------------------
XDEF _SetParentDir
_SetParentDir:
movem.l a2-a3,-(sp)
;if (FSPathInfo.Buffer[0])
movea.l _FSPathInfo,a3 ;Grab pointer to path text
tst.b (a3) ;Is it of zero length?
beq.s spddone ;Yep, at root already
;tstr = rindex(FSPathInfo.Buffer, '/')
moveq #'/',d0
movea.l a3,a0
jsr arindex
tst.l d0 ;Grab index to last occurance of slash
bne.s spdnotsub ;If we got one that is
; if ( tstr = rindex(FSPathInfo.Buffer, ':') )
; tstr++;
moveq #':',d0
movea.l a3,a0
jsr arindex ;Grab index to last occurance of colon
tst.l d0
beq.s spdnotroot ;Oops, no colon either, at top of path?
addq.w #1,a0 ;Move past the ':'
bra.s spdnotsub ;Terminate the text
;else
spdnotroot:
movea.l a3,a0 ;tstr = (BYTE *)FSPathInfo.Buffer
spdnotsub:
clr.b (a0) ;*tstr = '\x0'
move.w #1,_fsvirgindir ;virgindir = 1, read the new directory
spddone:
movem.l (sp)+,a2-a3
rts
* -----------------------------------------------------------------
;HCompGad(rp, g2)
; struct RastPort *rp;
; struct Gadget *g2;
;
; Given a rastport and a gadget pointer, highlight or de-highlight
; a gadget using RectFill in COMPLEMENT mode.
* -----------------------------------------------------------------
hrp EQU 16
hgad EQU 20
XDEF _HCompGad
_HCompGad:
movem.l d2-d3/a6,-(sp)
movea.l hrp(sp),a1
moveq #2,d0
SYS SetDrMd,_GfxBase ;SetDrMd(rp, COMPLEMENT)
movea.l hgad(sp),a0 ;Grab gadget pointer
moveq #0,d0
move.w 4(a0),d0 ;x0 = (ULONG)g2->LeftEdge
move.l d0,d2
add.w 8(a0),d2
subq.w #1,d2 ;x1 = x0 + g2->Width - 1L
moveq #0,d1
move.w 6(a0),d1 ;y0 = (ULONG)g2->TopEdge
move.l d1,d3
add.w 10(a0),d3
subq.w #1,d3 ;y1 = y0 + g2->Height - 1L
movea.l hrp(sp),a1
SYS RectFill ;RectFill(rp, x0, y0, x1, y1)
movea.l hrp(sp),a1
moveq #1,d0
SYS SetDrMd ;SetDrMd(rp, JAM2)
movem.l (sp)+,d2-d3/a6
rts
* -----------------------------------------------------------------
;HCompEntry(num)
; LONG num;
;
; Highlight or de-highlight a slot in the filename area, given its
; entry number
* -----------------------------------------------------------------
XDEF _HCompEntry
_HCompEntry:
movem.l d2-d3/a2/a6,-(sp)
movea.l _FSRPort,a2 ;Grab window
movea.l a2,a1
moveq #2,d0
SYS SetDrMd,_GfxBase ;SetDrMd(rp, COMPLEMENT)
moveq #5,d0 ;x0 = (ULONG)g2->LeftEdge
move.l #460,d2 ;x1 = x0 + g2->Width - 1L
move.w 16+4+2(sp),d1
mulu #11,d1
add.w #12,d1 ;y0 = (ULONG)g2->TopEdge
move.l d1,d3
add.w #9,d3 ;y1 = y0 + g2->Height - 1L
movea.l a2,a1
SYS RectFill ;RectFill(rp, x0, y0, x1, y1)
movea.l a2,a1
moveq #1,d0
SYS SetDrMd ;SetDrMd(rp, JAM2)
movem.l (sp)+,d2-d3/a2/a6
rts
* --------------------------------------------------------------------- *
* VOID FSDoSortGadget(type)
* LONG type;
* --------------------------------------------------------------------- *
dosgtype EQU 4+4*3
XDEF _FSDoSortGadget
_FSDoSortGadget:
movem.l d2/a2/a6,-(sp)
movea.l _FSReq,a0
moveq #0,d0
move.w fs_sorttype(a0),d0
cmp.w dosgtype+2(sp),d0
beq dosgsame
* Unhighlight previous setting
tst.w d0 ;Alphabetize?
bne.s 1$
lea _AlphaGad,a0
bra.s 3$
1$
subq.w #1,d0 ;FileSize?
bne.s 2$
lea _SizeGad,a0
bra.s 3$
2$
subq.w #1,d0 ;Time?
bne.s 4$ ;Nope, nosort previously
lea _TimeGad,a0
3$
bclr.b #7,gg_Flags+1(a0) ;gad->Flags &= ~SELECTED
movea.l _FSWin,a1
suba.l a2,a2
moveq #1,d0
SYS RefreshGList,_IntuitionBase ;RefreshGList(gad, FSWin, 0L, 1)
4$
* Set new sort type
movea.l _FSReq,a0
move.l dosgtype(sp),d1
move.w d1,fs_sorttype(a0)
movea.l _fnList,a0
movea.l MLH_HEAD(a0),a0
tst.l fn_Node+MLN_SUCC(a0)
beq.s dosgdone ;No list, don't bother sorting
tst.l _topfin ;Grab current topfin
beq.s 5$ ;No currently visible files
clr.w _fsneedshow ;fsneedshow = 0, needs sorting
bra.s 6$
5$
move.w #-1,_fsneedshow ;No topfin, fsneedshow = -1
6$
dossort:
* Sort the list using the new sort type
move.l d1,-(sp)
jsr _SortNodes ;SortNodes(type)
addq.w #4,sp
jsr _FSUpdateSort
jsr _FSWinTitle ;Reset title to previous
bra.s dosgdone
dosgsame:
move.w #-1,fs_sorttype(a0)
dosgdone:
movem.l (sp)+,d2/a2/a6
rts
* -----------------------------------------------------------------------
; SortNodes(key)
; LONG key;
; Selection sort list of filenames using one of three key types
* -----------------------------------------------------------------------
XDEF _SortNodes
_SortNodes:
movem.l d4/a2-a3/a6,-(sp)
IFD BENCHMARK
jsr _StartTime
ENDC
move.l 4+4*4(sp),d4 ;Grab our key type
blt snsortdone ;No sort wanted
cmpi.w #1,_fsnumentries ;More than one entry?
ble snsortdone ;Nope, don't bother sorting
move.w _fstitstatus,-(sp) ;Save old titstatus
move.w #28,_fstitstatus
jsr _FSWinTitle ;FSWinTitle("Sorting...")
move.w (sp)+,_fstitstatus ;Restore previous titlemsg
* Convert Exec list to a simple head->next->NULL type
movea.l _fnList,a3 ;Grab old list
movea.l MLH_TAILPRED(a3),a1 ;a0 = last entry in list
movea.l MLH_HEAD(a3),a0
clr.l fn_Node+MLN_SUCC(a1) ;Zap last nodes next field
NEWLIST a3 ;New the old list
move.l d4,d0 ;d0 = sorttype, a0 = headnode
jsr _FSListSort ;list_sort(headnode, key) (a0/d0)
movea.l d0,a1 ;Grab new head of sorted list
* Now add the new nodes back into the list
movea.l 4,a6 ;Execbase calls
1$ cmpa.l #0,a1 ;Grab next node in new list
beq.s 2$ ;End of list
movea.l fn_Node+MLN_SUCC(a1),a2 ;node = node->fn_Node.mln_Succ
movea.l a3,a0
SYS AddTail ;AddTail(fnList, newnode)
movea.l a2,a1 ;a2 = next node
bra 1$ ;Add the next node
2$
snsortdone:
IFD BENCHMARK
pea _timermsg1
jsr _StopTime
addq.w #4,sp
ENDC
movem.l (sp)+,d4/a2-a3/a6
rts
* --------------------------------------------------------------------
* struct file_node *FSListSort (list, type)
* struct file_node *list;
* long type;
*
* Assumes a list of structures, with a pointer to "next" as the first
* field. It reorders the list into ascending order, and returns the
* new first node's address. It is order N log(N).
*
* The compare routine should return 0 if the items are in order, and 1
* if they are not. If the compare routine returns 0 in case of
* equality, the sort will be stable.
*
* This routine depends upon compiler-dependant struct layout, but this
* assumption is likely to be fairly commonly valid.
*
* The basic notion of this sort is to make sorted sublists longer and
* longer by merging. On the Nth pass through the list, sorted
* sublists of length 2^(N-1) are produced. Eventually, the entire
* list is sorted, in log2(N)+1 passes through the list. There is
* extra bookkeeping overhead, but minimal extra storage space needed.
* Counts and clever pointer management substitute for extra "glue"
* nodes.
*
* while more than one list
* while not at end of composite lists
* for each merge_length(m) block
* merge first items in lists onto current output list
* toggle current output list
*
* Register parameters:
* struct file_node *FSListSort __ARGS((struct file_node *, LONG));
* d0 a0 d0
* --------------------------------------------------------------------- *
flsold1 equ -4
flsold0 equ -8
flsnew1 equ -12
flsnew0 equ -16
flscnt1 equ -20
flscnt0 equ -24
flsffn1 equ flscnt0-16
flsffn0 equ flsffn1-16
flssend equ flsffn0-4
* --------------------------------------------------------------------- *
XDEF _FSListSort
_FSListSort:
link a5,#flssend
movem.l d2-d7/a2-a3,-(sp)
move.l d0,d3 ;d3 = sorttype
clr.l flsffn0+LN_SUCC(a5) ;front[0].next = 0
move.l a0,flsffn1+LN_SUCC(a5) ;front[0].next = list
moveq #1,d7 ;m = 1
moveq #0,d6 ;hm = 0
flsLoop1:
tst.l flsffn1+LN_SUCC(a5) ;while (front[1].next)
beq flsdone
lea flsffn0(a5),a0
move.l a0,flsnew0(a5) ;new[0] = &front[0]
lea flsffn1(a5),a0
move.l a0,flsnew1(a5) ;new[1] = &front[1]
move.l flsffn0+LN_SUCC(a5),flsold0(a5) ;old[0] = front[0].next
move.l flsffn1+LN_SUCC(a5),flsold1(a5) ;old[1] = front[1].next
clr.l flscnt0(a5) ;count[0] = 0
clr.l flscnt1(a5) ;count[1] = 0
moveq #0,d4 ;n = 0
moveq #0,d5 ;items_merged = 0
flsLoop2:
tst.l flsold0(a5) ;old[0]?
bne.s 1$ ;Yep, get an item from this list
tst.l flsold1(a5) ;old[1]?
beq flsNext2 ;Nope, both lists exhausted
1$ cmp.l d7,d5 ;if (items_merged >= m)
bcs.s 2$ ;Nope, m > items_merged
moveq #0,d5 ;items_merged = 0
bchg.l #0,d4 ;n = 1 - n
clr.l flscnt0(a5) ;count[0] = 0
clr.l flscnt1(a5) ;count[1] = 0
2$ tst.l flsold0(a5) ;old[0]?
beq.s 3$
tst.l flsold1(a5) ;old[1]?
beq.s 3$
cmp.l flscnt0(a5),d6 ;count[0] < hm?
bls.s 3$ ;Nope, hm >= count[0]
cmp.l flscnt1(a5),d6 ;count[1] < hm?
bls.s 3$ ;Nope
movea.l flsold1(a5),a1
movea.l fn_info(a1),a1
movea.l flsold0(a5),a0
movea.l fn_info(a0),a0
move.l d3,d0
jsr _CompareNodes ;CompareNodes(type, old[0]->info, old[1]->info)
lsl.w #2,d0 ;d0 = result of compare (0 or 1)
move.w d4,d1
lsl.w #2,d1 ;d1 = n<<2
movea.l flsnew0(a5,d1.w),a1 ;a1 = new[n]
movea.l flsold0(a5,d0.w),a0 ;a0 = old[o]
move.l a0,LN_SUCC(a1) ;new[n]->next = old[o]
move.l LN_SUCC(a0),flsold0(a5,d0.w) ;old[o] = old[o]->next
addq.l #1,flscnt0(a5,d0.w) ;count[o]++
bra.s flsNext1
3$
flselse1:
tst.l flsold0(a5) ;old[0]?
beq.s 2$ ;Nope, use old[1]
cmp.l flscnt0(a5),d6 ;count[0] < hm?
bls.s 2$ ;Nope, count[0] >= hm, use old[1]
1$ lea flsold0(a5),a0 ;else a0 = &old[0]
bra.s 3$
2$ lea flsold1(a5),a0 ;a0 = &old[1]
3$
move.w d4,d1
lsl.w #2,d1
movea.l flsnew0(a5,d1.w),a1 ;a1 = new[n]
move.l (a0),LN_SUCC(a1) ;new[n]->next = old[o]
movea.l (a0),a1
move.l LN_SUCC(a1),(a0) ;old[o] = old[o]->next
flsNext1:
move.w d4,d0
lsl.w #2,d0
movea.l flsnew0(a5,d0.w),a0 ;a0 = new[n]
move.l LN_SUCC(a0),flsnew0(a5,d0.w) ;new[n] = new[n]->next
addq.l #1,d5 ;items_merged++
bra flsLoop2
flsNext2:
movea.l flsnew0(a5),a0
clr.l LN_SUCC(a0) ;new[0]->next = 0
movea.l flsnew1(a5),a0
clr.l LN_SUCC(a0) ;new[1]->next = 0
move.l d7,d6 ;hm = m
lsl.l #1,d7 ;m *= 2
bra flsLoop1
flsdone:
move.l flsffn0+LN_SUCC(a5),d0 ;return(front[0].next)
movem.l (sp)+,d2-d7/a2-a3
unlk a5
rts
* -------------------------------------------------------------------------
; d0 = WORD CompareNodes(d0, a0, a1)
; WORD key = d0;
; struct node_data *a = a0, *b = a1;
;
; Compare data in two nodes, based upon key type. Return boolean result
; of the comparison in d0. Note that this is a register based function.
* -------------------------------------------------------------------------
XDEF _CompareNodes
_CompareNodes:
move.w nd_filetype(a0),d1
cmp.w nd_filetype(a1),d1 ;Comparing same type of entries?
beq.s 3$ ;Yep, use sort for compare
btst.b #3,_fsflags+1 ;Want files first?
bne.s 2$ ;Yep
btst.b #4,_fsflags+1 ;Want dirs first?
beq.s 3$ ;Don't care, see if there is a sort
cmp.w nd_filetype(a1),d1 ;Recompare
bcs.s cnmatch ;a0->filetype = 2, a1->filetype = 1
bra.s cnnomatch ;a0->filetype = 1, a1->filetype = 2
2$
cmp.w nd_filetype(a1),d1 ;Recompare
bhi.s cnmatch ;a0->filetype = 2, a1->filetype = 1
bra.s cnnomatch ;a0->filetype = 1, a1->filetype = 2
3$
tst.w d0
blt.s cnmatch ;No sort, append to end
bne.s cnnotalpha ;Not zero, not alphabetize
cnnalpha:
pea nd_alphadata+26(a1)
pea nd_alphadata+26(a0)
jsr _lstrcmp ;return(lstrcmp(a->alphadata + 26L, b->alphadata + 26L) > 0)
addq.w #8,sp
tst.w d0
ble.s cnnomatch
bra.s cnmatch
cnnotalpha:
cmpi.w #1,d0 ;Sort by size?
bne.s cnnotsize ;Nope, must be by date
move.l nd_filesize(a0),d0
cmp.l nd_filesize(a1),d0 ;return(a->filesize > b->filesize)
beq cnnalpha ;Same size, sort alpha
bcs.s cnnomatch ;a1 > a0
bra.s cnmatch
cnnotsize:
move.l nd_days(a0),d0
cmp.l nd_days(a1),d0 ;if (a->days > b->days)
beq.s cntstmins ;Nope, a->days == b->days, check minutes
bls.s cnnomatch ;Nope, a->days < b->days
bra.s cnmatch
cntstmins:
;t1 = (a->minutes - b->minutes) * 3000L + (a->ticks - b->ticks)
move.l nd_minutes(a0),d0
sub.l nd_minutes(a1),d0
muls #3000,d0
move.l nd_ticks(a0),d1
sub.l nd_ticks(a1),d1
add.l d1,d0
tst.l d0 ;return(t1 > 0L);
beq cnnalpha ;Same date, sort alpha
bgt.s cnmatch
cnnomatch:
moveq #0,d0
bra.s cndone
cnmatch:
moveq #1,d0
cndone:
rts
* ---------------------------- lstrcmp -------------------------------
* LONG lstrcmp(astr, bstr)
* BYTE *astr, *bstr;
*
* Compare two texts for lexigraphic order, ignoring case differences
*---------------------------------------------------------------------
XDEF _lstrcmp
_lstrcmp:
movem.l 4(sp),a0/a1 ;Grab astr, bstr
;for(;*a && tolower(*a) == tolower(*b); a++, b++)
lccstart:
move.b (a0)+,d0 ;Grab a char from astr
cmpi.b #$40,d0 ;less than @ character?
bls.s 1$ ;Yep
cmpi.b #$5a,d0 ;Greater than Z?
bhi.s 1$ ;Yep
addi.b #$20,d0
1$
move.b (a1)+,d1 ;Grab a char from bstr
cmpi.b #$40,d1 ;less than @ character?
bls.s 2$ ;Yep
cmpi.b #$5a,d1 ;Greater than Z?
bhi.s 2$ ;Yep
addi.b #$20,d1
2$
tst.b d0 ;End of astr?
beq.s 3$
cmp.b d1,d0 ;Are they the same character?
beq lccstart ;Yep, compare next pair of chars
3$
sub.b d1,d0 ;return(tolower(*astr) - tolower(*bstr))
ext.w d0
ext.l d0
rts
*----------------------------------------------------------------------
* Search a text for wild characters, return 1 if found
*----------------------------------------------------------------------
XDEF _iswild
_iswild:
movea.l 4(sp),a0 ;Grab text pointer
moveq #0,d0 ;Clear out our character register
ischk1:
move.b (a0)+,d0 ;Grab a char
beq.s iswdone ;Might be end of text?
cmpi.b #'*',d0 ;Is it *?
beq.s iswdone ;yep, is wild
cmpi.b #'?',d0 ;Is it a qmark
bne ischk1 ;Nope, check next character
rts ;Otherwise it is wild
iswdone:
rts
* ------------------------------------------------------------------------
; Compare a wild card name with a normal name
; WORD wildmatch (name, wild)
; BYTE *name, *wild;
* ------------------------------------------------------------------------
XDEF _wildmatch
_wildmatch:
link a5,#-64
movem.l d3/a2-a3,-(sp)
movem.l 8(a5),a2-a3 ;Grab name/pattern
lea -64(a5),a0 ;back[0][0]
lea -60(a5),a1 ;back[0][1]
moveq #0,d3 ;bi = 0
wmloop1:
tst.b (a2) ;End of name?
bne.s wmnoteon
tst.b (a3) ;End of pattern?
beq wmmatched ;Yep, we matched
wmnoteon:
cmpi.b #'*',(a3) ;Is it a splat?
bne.s wmnotstar ;Nope, maybe '?'
cmpi.w #64,d3 ;Have we hit max expression depth?
beq wmnomatch ;Yep, ran out of room in recursion table
;back[bi][0] = w
move.l a3,0(a0,d3.w) ;Stash pointer to this '*' in table
;back[bi][1] = n
move.l a2,0(a1,d3.w)
addq.w #8,d3 ;++bi
addq.w #1,a3 ;++w
bra wmloop1 ;Check next
wmgoback:
subq.w #8,d3 ;--bi
move.l a0,d0
wmback1:
tst.w d3 ;while (bi >= 0 && *back[bi][1] == '\x0')
blt.s wmbacked
movea.l 0(a1,d3.l),a0
tst.b (a0)
bne.s wmbacked
subq.w #8,d3 ;--bi
bra wmback1
wmbacked:
tst.w d3 ;if (bi < 0)
blt.s wmnomatch ;return (0)
movea.l d0,a0
movea.l 0(a0,d3.w),a3 ;w = back[bi][0] + 1
addq.w #1,a3
addq.l #1,0(a1,d3.w)
movea.l 0(a1,d3.l),a2 ;n = ++back[bi][1]
addq.w #8,d3 ;++bi
bra wmloop1
wmnotstar:
cmpi.b #'?',(a3) ;Is it '?'
bne.s wmnotqmark
tst.b (a2) ;Reached end of text?
bne.s wmincpoint ;Nope, move on to next char
tst.w d3 ;Are we at top level of expression?
beq.s wmnomatch ;Yep, expression didn't match
bra wmgoback ;Otherwise pop a level and try to match
wmnotqmark:
move.b (a2),d0 ;Grab a char from bstr
cmpi.b #$40,d0 ;less than @ character?
bls.s 1$ ;Yep
cmpi.b #$5a,d0 ;Greater than Z?
bhi.s 1$ ;Yep
addi.b #$20,d0
1$
move.b (a3),d1 ;Grab a char from bstr
cmpi.b #$40,d1 ;less than @ character?
bls.s 2$ ;Yep
cmpi.b #$5a,d1 ;Greater than Z?
bhi.s 2$ ;Yep
addi.b #$20,d1
2$
cmp.b d0,d1 ;*n = *w?
beq.s wmincpoint ;Yep, move on past
tst.w d3 ;Are we at top expression level?
beq.s wmnomatch ;Yep, they didn't match
bra wmgoback ;Nope, process next part
wmincpoint:
tst.b (a2) ;Done with name?
beq.s wmnamend ;Yep
addq.w #1,a2 ;Otherwise increment name pointer
wmnamend:
tst.b (a3) ;End of pattern?
beq.s wmmatched ;Yep, we matched
addq.w #1,a3 ;Otherwise inc wild pointer, match next char
bra wmloop1
wmmatched:
moveq #1,d0
bra.s wmdone
wmnomatch:
moveq #0,d0
wmdone:
movem.l (sp)+,d3/a2-a3
unlk a5
rts
* --------------------------------------------------------------------- *
* LONG MakePathString(lock, dest)
* a0 a1
* struct FileLock *lock;
* BYTE *dest;
*
* DESCRIPTION:
* Given text and a filelock, construct entire pathname and
* return in dest.
* --------------------------------------------------------------------- *
XDEF _MakePathString
_MakePathString:
link a5,#0
movem.l d2-d5/d7/a2-a3/a6,-(sp)
* Grab pointer to lock and dest text to fill
move.l 8(a5),d3 ;d3 = lock
movea.l 12(a5),a2 ;a2 = dest
clr.b (a2) ;NULL terminate dest
moveq #0,d5 ;LockFlag = 0
* Allocate a FileInfoBlock for local use
moveq #0,d1
move.l #fib_SIZEOF,d0
SYS AllocMem,4 ;AllocMem(sizeof(fib), 0L)
move.l d0,d7 ;d7 = *fib
beq mpsfailed ;Whoops no mem? return!
movea.l _DOSBase(a4),a6 ;DOSBase calls from here on
* while (lock != 0)
1$
tst.l d3 ;Got a lock?
beq.s mpsokay ;Nope, must be at root
* Examine the current lock
move.l d3,d1
move.l d7,d2
SYS Examine ;Examine(lock, fib)
tst.l d0 ;Okay?
beq.s mpsfailed ;Nope, some sort of dos failure?
movea.l d7,a1
cmpi.b #' ',fib_FileName(a1) ;if (fib->fib_FileName[0] >= ' ')
bcs.s 3$ ;Nope, don't bother inserting?
tst.b (a2) ;if (dest[0] != 0)
beq.s 2$
lea _SlashStr(a4),a1
movea.l a2,a0
jsr _InsertPathString ;InsertPathString(dest, "/");
2$
movea.l d7,a1
lea fib_FileName(a1),a1
movea.l a2,a0
jsr _InsertPathString ;InsertPathString(dest, fib->fib_FileName)
3$
* Okay, move up one directory
move.l d3,d4 ;oldlock = lock
move.l d3,d1
SYS ParentDir
move.l d0,d3 ;lock = ParentDir(lock)
tst.w d5 ;LockFlag set?
bne.s 4$ ;Yep, unlock
moveq #1,d5 ;Else LockFlag = 1, unlock next time
bra 1$ ;Next directory up
4$
move.l d4,d1
SYS UnLock ;UnLock(oldlock)
bra 1$ ;Examine
mpsokay:
* See if root was RAM:, special case
movea.l d7,a1 ;a1 = fib
cmpi.b #' ',fib_FileName(a1) ;if (fib->fib_FileName[0] >= ' ')
bcc.s 1$ ;Yep, not 1.1/1.2 RAM:
lea _RamDirNameStr(a4),a1 ;Else...
movea.l a2,a0
jsr _InsertPathString ;InsertPathString(dest, "RAM:")
bra.s mpsdone
1$
* Find last slash we tacked on, change to a colon, or, add a colon
moveq #'/',d0
movea.l a2,a0
jsr aindex ;d0 = strchr(dest, '/')
tst.l d0 ;Do we have a slash?
beq.s 2$ ;Nope, at root....
movea.l d0,a0
move.b #':',(a0) ;Else change first '/' to a ':'
bra.s mpsdone
* No slash, must be locked at the root. Append a colon to the dest.
2$
lea _ColonStr(a4),a1
movea.l a2,a0
jsr astrcat ;strcat (dest, ":")
bra.s mpsdone
* Come here if an error occured, return empty text to caller
mpsfailed:
clr.b (a2) ;dest[0] = (BYTE)0
moveq #0,d3 ;return (0L)
bra.s mpsdeall
* Come here if everything is okay, deallocate FileInfoBlock
mpsdone:
moveq #1,d3 ;return (1L)
mpsdeall:
tst.l d7 ;Did we allocate a fib?
beq.s mpsfinis ;nope
movea.l d7,a1 ;Else free the memory
move.l #fib_SIZEOF,d0
SYS FreeMem ;FreeMem(fib, sizeof(fib))
mpsfinis:
move.l d3,d0 ;Put return value in d0
movem.l (sp)+,d2-d5/d7/a2-a3/a6
unlk a5
rts
* --------------------------------------------------------------------- *
* VOID InsertPathString(dest, source)
* a0 a1
* BYTE *dest, *source;
*
* DESCRIPTION:
* Insert source text into dest text.
* Special case for source length == 0, source must be RAM.
* --------------------------------------------------------------------- *
XDEF _InsertPathString
_InsertPathString:
movem.l d7/a2-a3,-(sp)
movea.l a1,a3 ;a3 = source
move.l a0,a2 ;a2 = dest
movea.l a3,a0
jsr astrlen
move.l d0,d7 ;d7 = strlen(source)
1$ movea.l a2,a0
jsr astrlen ;d0 = strlen(dest)
addq.w #1,d0 ;Bump the length to include zero byte at end
movea.l a2,a1
adda.w d7,a1 ;Push dest + slen
movea.l a2,a0 ;Push dest
jsr amovmem ;amovmem(dest, dest + slen, strlen(dest) + 1)
move.w d7,d0
movea.l a2,a1
movea.l a3,a0
jsr amovmem ;amovmem(source, dest, slen)
movem.l (sp)+,d7/a2-a3
rts
* --------------------------------------------------------------------- *
* BYTE *myrindex(text, searchchar)
* BYTE *text;
* LONG searchchar;
*
* C stack version of arindex.
* --------------------------------------------------------------------- *
XDEF _myrindex
_myrindex:
movea.l 4(sp),a0
move.l 8(sp),d0
* --------------------------------------------------------------------- *
* BYTE *aindex(BYTE *, BYTE);
* --------------------------------------------------------------------- *
XDEF aindex
aindex:
1$ cmp.b (a0),d0
beq.s aifound
tst.b (a0)+
beq.s ainomatch
bra 1$
ainomatch:
moveq #0,d0
rts
aifound:
move.l a0,d0
rts
* --------------------------------------------------------------------- *
* BYTE *arindex(BYTE *, BYTE);
* --------------------------------------------------------------------- *
XDEF arindex
arindex:
move.l a0,d1 ;Copy start of string for compares
1$ tst.b (a0)+ ;Find end of text
bne 1$
2$ cmp.b -(a0),d0 ;Now work backward comparing along the way
beq.s rifound ;..Until we find a match
cmpa.l d1,a0 ;...or hit the beginning of the text
bgt 2$
rinomatch:
moveq #0,d0
rts
rifound:
move.l a0,d0
rts
* ------------------------------------------------------------------------- *
* d0 a0
* LONG astrlen(text)
* BYTE *text;
*
* Synopsis: Calculate length of null-byte terminated text.
* a0 returns pointing to null char at end of text
* d0 returns number of bytes in the text
* ------------------------------------------------------------------------- *
XDEF astrlen
astrlen:
move.l a0,d0 ;Save initial address
1$ tst.b (a0)+ ;Test a byte for zero-ness
bne 1$
suba.l d0,a0 ;Minus initial address
subq.w #1,a0 ;Less one for overshoot
exg d0,a0 ;swap em
rts
* ------------------------------------------------------------------------- *
* astrcat()
* Takes text in a0, appends text in a1
* a0 returns pointing to null at end of final text
* ------------------------------------------------------------------------- *
XDEF astrcat
astrcat:
* Find end of first text
1$ tst.b (a0)+
bne 1$
subq.w #1,a0 ;Back up to null char
* Append second text
2$ move.b (a1)+,(a0)+
bne 2$
subq.w #1,a0 ;a0 = the null at end of final text
rts
* ------------------------------------------------------------------------- *
* astrcpy()
* Takes text in a0, copies text in a1
* a0 returns pointing to null at end of final text
* ------------------------------------------------------------------------- *
XDEF astrcpy
astrcpy:
* Copy second text
1$ move.b (a1)+,(a0)+
bne 1$
subq.w #1,a0 ;Back up to null
rts
* ------------------------------------------------------------------------- *
* astrcmp()
* Takes text in a0, compares to text in a1
* a0 returns pointing to first difference, d0 contains the difference
* or zero if the two texts are identical
* ------------------------------------------------------------------------- *
XDEF astrcmp
astrcmp:
1$ move.b (a0)+,d0 ;Grab a char from A
move.b (a1)+,d1 ;Grab a char from B
tst.b d0 ;Hit end of A?
beq.s 2$ ;Yep, diff em
cmp.b d1,d0 ;Else the same char?
beq 1$ ;Compare next pair
2$ sub.b d1,d0 ;A - B
ext.w d0
ext.l d0
rts
* -----------------------------------------------------------------------
* safestrcpy(dest, source, length)
* Copies at most length chars of source to dest, if source < length
* don't pad with nulls like strncpy. Always null terminates dest.
* -----------------------------------------------------------------------
XDEF _safestrcpy
_safestrcpy:
movem.l 4(sp),a0/a1 ;Grab dest and source pointers
move.w 14(sp),d0 ;Grab count
* ------------------------------------------------------------------------- *
* astrncpy()
* Takes text in a1, copies d0 bytes to text in a0.
* a0 returns pointing to null at end of final text.
* Dest text is always null terminated.
* ------------------------------------------------------------------------- *
XDEF astrncpy
astrncpy:
1$ move.b (a1)+,(a0)+
2$ dbeq d0,1$
subq.w #1,a0
clr.b (a0) ;Null terminate dest
move.l a0,d0
rts
* ------------------------------------------------------------------------- *
* amovmem()
* Takes text in a0, copies d0 bytes to text in a1. Correctly handles
* overlapping memory.
* ------------------------------------------------------------------------- *
XDEF amovmem
amovmem:
cmpa.l a0,a1 ;Low to high or high to low?
bcs.s 2$ ;High to low, copy forward
adda.w d0,a0 ;Else start at end, copy backward
adda.w d0,a1
1$ move.b -(a0),-(a1)
subq.w #1,d0
bgt 1$
bra.s amdone
2$ move.b (a0)+,(a1)+
subq.w #1,d0
bgt 2$
amdone:
rts
* --------------------------------------------------------------------- *
* END OF SOURCE
* --------------------------------------------------------------------- *
END