.title	KRTDIA	Dial command and related items
	.ident	"V03.62"

; /62/	27-Jul-93  Billy Youdelman
;
;	add support for call back modems, SET DIAL/PHONE [NO]ANSWER
;
;	add a one-tick pacing delay in DODIAL's loop at 21$ (when the modem
;	doesn't echo commands) to match what was done for echoing modems
;
;	fix SHO MODEM for changes to SET DIAL [NO]ECHO and [NO]INIT_ONCE
;	add initiate_prompt, dial_ack, confirm_ack, [no]binary_response
;
;	added x.result (default "Hayes" xmode) and time.settle defaults,
;	and in "Hayes" and Telebit modem definitions
;
;	if DCD is high when exiting program, hang up modem
;	add support for 38.4kb
;	add Telebit T3000 modem def, needs KM handler and SET FLOW_CONTROL RTS
;
;	double the settle_time value for the wait after dropping DTR,
;	as some modems (like the T3000) need more time to recover

; /BBS/	 1-Dec-91  Billy Youdelman  V03.61
;
;	set$mo now won't write bad modem name into modem:
;	if DIAL/REDIAL succeeds jump to CONNECT automatically
;	set linksts when dialing so ^C abort will catch correct ttname
;	findmodem now does not try to process an empty string in modem:
;	added c$idle, call to reset modem to idle (answer) mode
;	findmodem/findnumber will match on partial input string
;	added %X format effector for setting Hayes extended response mode
;	added Telebit T2500 modem definitions
;
;	redial loop moved to c$dial, runs faster without initializing
;	the modem's lun every pass thru the loop, reduces cpu usage too
;
;	load buffer with defmsg after displaying RING, to not overwrite
;	the default message with call status stuff
;
;	if DIAL can't translate an alias, say so then die (instead of
;	prompting to continue with an empty number buffer)
;
;	added xredial flag word, for keeping return path straight when
;	connecting after a successful REDIAL. speed up redial process for
;	modems which define init.once by not initting before every retry.
;	init.once and mready (status flag) were added to support all this..
;
;	while waiting for a response after dialing modem, check for
;	input from keyboard, allowing an easy abort
;
;	.default patched to get/set handler speed from modem response,
;	old speed is saved and restored, unless set different after..
;	Hayes definition completed and moved to it.  this also renders
;	Hayes responses displayable via SHO MODEM.
;
;	diatmo from SET DIAL TIME_OUT gets written into dial.time(r4)
;	when either c$dial or sho$dial is called.  it's now usable with
;	any modem type (not just user-defined) by setting the modem's
;	internal timer to the max (ATS7=255 etc) then letting Kermit's
;	timer take action first.
;
;	modified waitfor to test for keyboard input, allowing a "strike
;	any char" abort during dialing, now including the init string.
;	DTR is dropped to ensure the modem will actually abort the call.
;
;	SHO MODEM expanded to display everything
;	result message must match from 1st byte to avoid embedded strings
;	save modem init status to drop unnecessary inits
;	SET MODEM now inits same, if a line (and speed) have been set
;	echo everything from modem (if it echoes) during DIAL
;	add CONNECT/nnnn for Hayes to alter DTE speed w/TSX and CL
;	add Concord Data Systems 224 Auto-dial modem
;
;	moved SET DTR code here, and reinit modem after DTR drop if one
;	was on-line before it

;	Copyright 1985,1986 Change Software, Inc.
;
;	18-Oct-85  20:06:09 Brian Nelson
;
;	04-Dec-85  11:22:32 BDN	 Add optional linked list structure to
;				 define modem responses, will be useful
;				 when adding a SET DIAL command
;	09-Jan-86  17:48:17 RTM  Added support for the RIXON Intelligent
;		(RTM01)		 auto-dial modem (R212A)
;	13-Feb-86  10:10:08 BDN	 Put the DF112 and DF224 responses into
;				 linked lists
;	23-Sep-86  14:10:30 BDN	 Vadic 4224 modems
;	23-Sep-86  14:10:42 BDN	 Added format effector %M for pulse/tone
;				 if a SET PHONE PULSE/TONE was done
;				 Added %B for "blind" dialing, enabled if
;				 SET PHONE BLIND
;	30-Sep-86  13:05:53 BDN	 Added CTS2424, Also SHO DIAL
;	09-Feb-89  00:00:00 JCH  Complete definition of DF224 modem


	.include "IN:KRTMAC.MAC"
	.iif ndf  KRTINC  .error	<; .include for IN:KRTMAC.MAC failed>


	.sbttl	Modem data base structure

;	Loosely based on CKUDIAL.C
;
;	Anything new that is needed in the modem database should be added at
;	the end of the list just before mod.size which should be incremented
;	to include the new element.  You must also conform the define macro.

	mod.next	==:	 0	; link to next modem in list
	mod.string	==:	 2	; address of name of modem
	dial.time	==:	 4	; dial time_out value in secs
	wake.string	==:	 6	; address of wakeup string
	wake.rate	==:	10	; ticks delay between sending chars
	wake.prompt	==:	12	; address of wakeup prompt string
	dmod.string	==:	14	; address of dial initiate string and
	dmod.prompt	==:	16	; address of prompt returned for it
	dial.string	==:	20	; address of dial format string
	dial.rate	==:	22	; ticks delay between sending chars
	dial.ack	==:	24	; modem response to confirm number
	dial.blind	==:	26	; if <> dial w/o wait for dial tone
	dial.wait	==:	30	; string for pause format effector
	dial.confirm	==:	32	; string to confirm number for dialing
	dial.go		==:	34	; ie, va212 returns "DIALING\n"
	res.bin		==:	36	; if <> it's binary responses (DF03)
	dial.echo	==:	40	; if <> modem echoes its input
	mod.comment	==:	42	; addr of brief description of modem
	res.head	==:	44	; head of the list of result messages
	dial.xabort	==:	46	; /45/ string to kill call in progress
	dial.idle	==:	50	; /45/ string puts modem in idle state
	dial.pulse	==:	52	; /45/ pulse dialing command string
	dial.nopulse	==:	54	; /45/ tone dialing command string
	init.once	==:	56	; /BBS/ if <> modem stays initialized
	time.settle	==:	60	; /62/ reset settle_time in secs
	x.result	==:	62	; /62/ "Hayes" style extended mode
	ph.answer	==:	64	; /62/ enable answer mode string
	ph.noanswer	==:	66	; /62/ disable answer mode string
	mod.size	==:	70	; /62/ length of data defined above


	.sbttl	Macros for individual fields of a modem's data structure

	; these two are inserted by the define macro
	;	mod.next		   0  link to next modem in list
	;	mod.string		   2  address of name of modem

	.macro	dial$time	v
	modval	v ,dial.time		;  4  dial time_out value in secs
	.endm	dial$time

	.macro	wake$string	s
	modstr	<s> ,wake.string	;  6  address of wakeup string
	.endm	wake$string

	.macro	wake$rate	v
	modval	v ,wake.rate		; 10  ticks delay between chars
	.endm	wake$rate

	.macro	wake$prompt	s
	modstr	^~s~ ,wake.prompt	; 12  address of wakeup prompt string
	.endm	wake$prompt

	.macro	dmod$string	s
	modstr	<s> ,dmod.string	; 14  address of dial initiate string
	.endm	dmod$string

	.macro	dmod$prompt	s
	modstr	<s> ,dmod.prompt	; 16  address of prompt returned by it
	.endm	dmod$prompt

	.macro	dial$string	s
	modstr	<s> ,dial.string	; 20  address of dial format string
	.endm	dial$string

	.macro	dial$rate	v
	modval	v ,dial.rate		; 22  ticks delay between chars
	.endm	dial$rate

	.macro	dial$ack	s
	modstr	<s> ,dial.ack		; 24  modem response to confirm number
	.endm	dial$ack

	.macro	dial$blind	s
	modstr	<s> ,dial.blind		; 26  if <> dial w/o waiting dial tone
	.endm	dial$blind

	.macro	dial$wait	s
	modstr	<s> ,dial.wait		; 30  string for pause format effector
	.endm	dial$wait

	.macro	dial$confirm	s
	modstr	<s> ,dial.confirm	; 32  string to confirm dialed number
	.endm	dial$confirm

	.macro	dial$go		s
	modstr	<s> ,dial.go		; 34  ie, va212 returns "DIALING\n"
	.endm	dial$go

	.macro	res$bin		v
	modval	v ,res.bin		; 36  if <> it's binary responses
	.endm	res$bin

	.macro	dial$echo	v
	modval	v ,dial.echo		; 40  if <> modem echoes its input
	.endm	dial$echo

	.macro	mod$comment	s
	modstr	^~s~ ,mod.com		; 42  addr of brief modem description
	.endm	mod$comment

	.macro	mod$res	s ,class	; 44  listhead of result messages
;
;	res.head(current_modem) --> first entry of linked list
;
;	.word	link_to_next		or zero for the last entry
;	.word	response_class		<0 fail, 0 info, 1 ring, >1 success
;	.asciz	"response_string"
;
	.list me
	.save
	.psect	resdat	,ro,d,lcl,rel,con ; /62/
	.nlist me
	$res1 = .			; save current pc in "resdat"
	.word	0			; link to next is zero for now..
	.if  b	<class>			; if class not specified, then
	.word	0			; make it zero (info only message)
	.iff				; else insert specified
	.word	class			; response class
	.endc
	.asciz	"s"			; the actual text /BBS/ allow "/"
	.list me
	.even				; must do
	.restore
	.nlist me
	.if eq	$res			; is this first time for new type?
	modval	$res1	,res.head	; yes, stuff the link header
	.iff				; not the first time
	.list me
	.save
	.psect	resdat	,ro,d,lcl,rel,con
	$respc = .			; save the current pc
	. = $reslast			; back to link word of previous entry
	.word	$res1			; insert address of new entry
	. = $respc			; restore current pc
	.restore
	.nlist me
	.endc
	$reslast = $res1		; lastlink = current_entry
	$res = 1			; not the first time anymore
	.endm	mod$res

	.macro	dial$xabort	s
	modstr	<s> ,dial.xabort	; 46  string to kill call in progress
	.endm	dial$xabort

	.macro	dial$idle	s
	modstr	<s> ,dial.idle		; 50  string puts modem in idle state
	.endm	dial$idle

	.macro	dial$pulse	s
	modstr	<s> ,dial.pulse		; 52  pulse dialing command string
	.endm	dial$pulse

	.macro	dial$nopulse	s
	modstr	<s> ,dial.nopulse	; 54  tone dialing command string
	.endm	dial$nopulse

	.macro	init$once	v
	modval	v ,init.once		; 56  if <> modem stays initialized
	.endm	init$once

	.macro	time$settle	v
	modval	v ,time.settle		; 60  reset settle_time in secs
	.endm	time$settle

	.macro	x$result	v
	modval	v ,x.result		; 62  "Hayes" style extended mode
	.endm	x$result

	.macro	ph$answer	s
	modstr	<s> ,ph.answer		; 64  enable answer mode string
	.endm	ph$answer

	.macro	ph$noanswer	s
	modstr	<s> ,ph.noanswer	; 66  disable answer mode string
	.endm	ph$noanswer


	.sbttl	Macros to place data in the individual fields

	.macro	modstr	s ,offset	; insert a string in modem's data
	.list me
	.save
	.psect	string	,ro,d,lcl,rel,con
	.nlist me
	$$addr	= .
	$$ = 0
	  .irpc	ch ,^~s~		; translate "^M" syntax to ".byte 15"
	  ch1 = ''ch			; get copy of char as a literal
	    .if eq ch1-'^
	    $$ = 100			; char is a ^, set flag for next char
	    .iff
	      .if ne $$			; if not a ^ but last char flag is set
		.if  ge  <ch1!40>-<'a!40> ; ensure alpha chars are upper case
		.iif le <<ch1!40>-<'z!40>> ch1 = ch1&137 ; so char-100 works!
		.endc
	      .endc
	    .byte ch1-$$		; char-100 = control char of same name
	    $$ = 0			; reset the ^ flag
	    .endc
	  .endr
	.byte	0			; null terminate
	.list me
	.psect	modinf	,ro,d,lcl,rel,con
	. = $$current+offset
	.word	$$addr			; where to find it..
	.restore
	.nlist me
	.endm	modstr

	.macro	modval	val ,offset	; insert value (word) in modem's data
	.list me
	.save
	.psect	modinf	,ro,d,lcl,rel,con
	. = $$current+offset		; it goes here..
	.word	val
	.restore
	.nlist me
	.endm	modval


	.sbttl	The actual modem definition macro

;	The following creates a modem's data structure, inserting the default
;	values as shown.  These defaults may be modified using the individual
;	data field macros.  The individual modem definition entries following
;	(two pages below) are good examples of how this is accomplished.

	.macro	define	lab ,s ,user
	.if eq	$$trip			; /62/ this has to be done this way
	$$prev	= modinf		; /62/ because "ndf" blows up the
	$$trip	= 1			; /62/ .LST output..	
	.endc				; /62/
	$res	  = 0			; init the result message
	$reslast  = 0			; macro counters

	.if nb	<user>			; if we are doing the "user_defined"
	.list me			; modem we need to be in a
	.save				; psect that is never swapped out
	.globl	lab			; user_defined listhead must be global
	.psect	usermd	,rw,d,gbl,rel,con ; this psect is forced into the root
	.nlist me			; by inclusion in KRTSJ and KRTXM
	.iff
	$modtail = .			; use this to link to "usermd" as it
	.endc				; avoids error from differing psects
	$$current = .			; save listhead for auxiliary macros

	.list me
	.save
	.psect	string	,ro,d,lcl,rel,con ; switch to string psect
	$$ = .				; save location of
	.asciz	"s"			; the modem type string
	.even
	.restore
	.nlist me

lab:	.word	0		;  0 mod.next	   link to next please
	.word	$$		;  2 mod.string	   modem type string address
	.word	30.		;  4 dial.time	   dial time_out in secs
	.word	null		;  6 wake.string   init to dial out string
	.word	0		; 10 wake.rate	   ticks between init chars
	.word	null		; 12 wake.prompt   command mode prompt string
	.word	null		; 14 dmod.string   optional dial cmd string
	.word	null		; 16 dmod.prompt   optional dial prompt string
	.word	null		; 20 dial.string   actual dial command string
	.word	0		; 22 dial.rate	   ticks between dial chars
	.word	null		; 24 dial.ack	   dialing acknowledged string
	.word	null		; 26 dial.blind	   blind dial command string
	.word	null		; 30 dial.wait	   pause character string
	.word	null		; 32 dial.confirm  optional "ok" string
	.word	null		; 34 dial.go	   optional "dialing" string
	.word	0		; 36 res.bin	   if <> single char response
	.word	0		; 40 dial.echo	   if <> modem echos commands
	.word	null		; 42 mod.comment   modem comment string
	.word	0		; 44 res.head	   result messages listhead
	.word	null		; 46 dial.xabort   abort dialing string
	.word	null		; 50 dial.idle	   reset modem to idle string
	.word	null		; 52 dial.pulse	   PULSE dialing string
	.word	null		; 54 dial.nopulse  TONE dialing string
	.word	0		; 56 init.once	   if <> modem stays initted
	.word	20.		; 60 time.settle   ticks to wait after a reset
	.word	-1		; 62 x.result	   Hayes Xmode, default is off
	.word	null		; 64 ph.answer	   enable auto-answer string
	.word	null		; 66 ph.noanswer   disable auto-answer string
	$$end	= .
	.iif ne	 <<$$end-$$current>-mod.size> .error <; 's define size error>

	.if  b	<user>			; if not the user_defined modem
	. = $$prev			; insert link address of modem data
	.word	lab			; just defined in the previous modem
	. = $$end			; then go back where we were
	$$prev = lab			; and save new address for next link
	.iff				; if this is the user_defined modem..
	.list me
	.restore			; exit root, come back to this overlay
	$$$ = .
	. = $modtail			; /BBS/ back to top of last definition
	.word	lab			; /62/ insert link to user_defined
	. = $$$
	.nlist me
	.endc	; b <user>
	.endm	define


	.sbttl	Modem response classes	; /BBS/

	CON38400  =	38400.	; /62/ connect at designated speeds
	CON19200  =	19200.	; that is, when the modem's result message
	CON9600	  =	9600.	; matches the string associated with one of
	CON7200	  =	7200.	; these speed specific classes, then force
	CON4800	  =	4800.	; the DTE speed to it (if possible)..
	CON2400	  =	2400.	; see the Hayes definition below for an
	CON1200	  =	1200.	; example of exactly how this is done
	CON300	  =	300.
	CONNECT	  =	2	; don't check or change speed
	RING	  =	1	; a ring was detected
	INFO	  =	0	; info only   /62/ *** SEE NOTE BELOW ***
	FAILED	  =	-1	; call failed, modem has already stopped
	ABORTED	  =	-2	; aborted by program, need to kill modem

; /62/	NOTE:  Since an INFO message is anything undefined, INFO messages
;	       have been dumped here to save space - this module is full!

; /BBS/	This is used by SHOW MODEM to format the display of response messages
; and actions to them.  It's the column at which the actions begin and may be
; increased if longer response strings must accommodated.

	COL.ACT	  =	18.


	.psect	modinf	,ro,d,lcl,rel,con
	.sbttl	Finally, we can define the modems

; /BBS/ NOTE:  When a response string is a  substring  of  another  response
; string the response being the substring _MUST FOLLOW_ the other containing
; it as otherwise an unwanted match will occur on the first one encountered.

; /62/	Control chars may be included in strings using the "^X" notation per
; the modstr macro, above.

; /BBS/ Keep these in modem name alphabetical order for SET MODEM ? display.

modinf::				; /62/ this is the top of the list
	$$trip = 0			; /62/ init for the define macro	

define		concord	,<CONCORD_224>		; /BBS/ added
mod$comment	<Concord Data 224>
wake$string	<^M^M>				; keyboard interactive mode
wake$prompt	^~CDS >~
dial$string	<D %M %S ^M>
dial$wait	<W>
dial$echo	1
dial$pulse	<P>
dial$nopulse	<M>
dial$xabort	<^K>
dial$idle	<E>
dial$time	45.
mod$res		<BUSY>		,FAILED
mod$res		<CALL FAILED>	,FAILED
mod$res		<INITIATING>	,CONNECT
mod$res		<NO ANSWER>	,FAILED
mod$res		<NO DIAL TONE>	,FAILED
mod$res		<NO RINGING>	,FAILED
mod$res		<RINGING>	,RING
mod$res		<VOICE>		,FAILED

define		cts24	,<CTS2424>
mod$comment	<CTS/Fabri-Tek 2424AD>
wake$string	<^T^WAT^M>
wake$rate	10
wake$prompt	<Modem Ready>
dial$string	<D%M%B%S^M>
dial$rate	10
dial$wait	<+>
dial$echo	1
dial$blind	<&>
dial$pulse	<P>
dial$nopulse	<T>
dial$xabort	<^T^W>
dial$idle	<^T^W>
dial$time	35.
mod$res		<Busy>		,FAILED
mod$res		<Dead Line>	,FAILED
mod$res		<Disconnect>	,FAILED
mod$res		<No Answer>	,FAILED
mod$res		<No Dialtone>	,FAILED
mod$res		<No Tone>	,FAILED
mod$res		<On Line>	,CONNECT	; /BBS/ <On Line Originate>
mod$res		<Ring>		,RING

define		df03	,<DF03>
mod$comment	<DEC DF03AC>
wake$string	<^A^B>				; this inits to dial
dial$string	<%S^M>				; /62/ needs a return here
dial$echo	1
dial$time	30.
res$bin		1				; single char responses
mod$res		<A>		,CONNECT
mod$res		<B>		,FAILED

define		df100	,<DF100>
mod$comment	<DEC DF112>
wake$string	<^B>
wake$prompt	<Ready>
dial$string	<%S#>				; /45/
dial$rate	10
dial$echo	1
dial$xabort	<^M>
dial$time	30.
mod$res		<Attached>	,CONNECT
mod$res		<Busy>		,FAILED
mod$res		<Disconnected>	,FAILED
mod$res		<Error>		,FAILED
mod$res		<No answer>	,FAILED
mod$res		<No dial tone>	,FAILED
mod$res		<Speed:>	,FAILED

define		df200	,<DF200>
mod$comment	<DEC DF224>
wake$string	<^B>
wake$prompt	<Ready>
dial$string	<%B%M%S!>			; /60/
dial$echo	1
dial$blind	<^A>				; /60/
dial$pulse	<P>				; /60/
dial$xabort	<^B>				; /60/
dial$nopulse	<T>				; /60/
dial$time	30.
mod$res		<Attached>	,CONNECT
mod$res		<Busy>		,FAILED
mod$res		<Disconnected>	,FAILED
mod$res		<Error>		,FAILED
mod$res		<No answer>	,FAILED
mod$res		<No dial tone>	,FAILED
mod$res		<Speed:>	,FAILED

define		hayes	,<HAYES>		; /BBS/ updated..
mod$comment	^~Hayes Generic Command Set - DTE>>DCE speed~
wake$string	<AT E1 Q0 S0=0 S7=255 V1 %X ^M>	; note time_out set to
wake$prompt	<OK>				; 255 so dial$time (which
dial$string	<AT %X %A D%M %S ^M>		; is settable) will prevail..
dial$echo	1
init$once	1
dial$pulse	<P>
dial$nopulse	<T>
dial$xabort	<^M>
dial$idle	<AT Z ^M>
dial$time	45.
time$settle	<25.>				; /62/ add a few ticks..
x$result	<4>				; /62/ extended mode, "ATX4"
ph$answer	<S0=1>				; /62/
ph$noanswer	<S0=0>				; /62/
mod$res		<BUSY>		,FAILED
mod$res		<CONNECT 19200>	,CON19200 	; /62/ added
mod$res		<CONNECT 9600>	,CON9600	; set DTE to indicated speed..
mod$res		<CONNECT 4800>	,CON4800
mod$res		<CONNECT 2400>	,CON2400
mod$res		<CONNECT 1200>	,CON1200
mod$res		<CONNECT>	,CON300		; 300 is implied here
mod$res		<ERROR>		,FAILED
mod$res		<NO ANSWER>	,FAILED
mod$res		<NO CARRIER>	,FAILED
mod$res		<NO DIALTONE>	,FAILED 	; true Hayes
mod$res		<NO DIAL TONE>	,FAILED		; many clones
mod$res		<RING>		,RING		; includes RINGING
mod$res		<RRING>		,RING		; Telebit-style rringing
mod$res		<VOICE>		,FAILED

define		hayes.mnp ,<HAYES_MNP>		; /BBS/ added from above..
mod$comment	<Hayes Generic MNP - Lock DCE speed before using!>
wake$string	<AT E1 Q0 S0=0 S7=255 V1 %X ^M>
wake$prompt	<OK>
dial$string	<AT %X %A D%M %S ^M>
dial$echo	1
init$once	1
dial$pulse	<P>
dial$nopulse	<T>
dial$xabort	<^M>
dial$idle	<AT Z ^M>
dial$time	60.
time$settle	<25.>
x$result	<4>
ph$answer	<S0=1>				; /62/
ph$noanswer	<S0=0>				; /62/
mod$res		<BUSY>		,FAILED
mod$res		<CONNECT>	,CONNECT
mod$res		<ERROR>		,FAILED
mod$res		<NO ANSWER>	,FAILED
mod$res		<NO CARRIER>	,FAILED
mod$res		<NO DIALTONE>	,FAILED
mod$res		<NO DIAL TONE>	,FAILED
mod$res		<RING>		,RING
mod$res		<RRING>		,RING
mod$res		<VOICE>		,FAILED

define		microcom ,<MICROCOM>
mod$comment	<MicroCom SX1200>
wake$string	<4445^MSE2^MS1C0^MSCE ON^M>
wake$rate	10
wake$prompt	<!>
dial$string	<D%S^M>
dial$rate	10
dial$echo	1
dial$time	35.
mod$res		<!>		,FAILED
mod$res		<CONNECT>	,CONNECT
mod$res		<NO CONNECT>	,FAILED

define		r212a	,<R212A>		; added by edit RTM01
mod$comment	<Rixon R212A>
wake$string	<^M^M>
wake$rate	10				; wait 8. ticks
wake$prompt	<$>
dmod$string	<K>
dmod$prompt	<NUMBER:>
dial$string	<%S^M>
dial$rate	10
dial$go		<DIALING:>
dial$echo	1
dial$time	60.				; long time_out for overseas
mod$res		<BUSY>		,FAILED
mod$res		<DEAD LINE>	,FAILED
mod$res		<ON LINE>	,CONNECT
mod$res		<ON-LINE>	,CONNECT
mod$res		<NO ANSWER>	,FAILED
mod$res		<RINGING>	,RING

define		T2500	,<T2500>		; /BBS/ added..
mod$comment	^~Telebit w/o MNP/V.42 - DTE>>DCE speed~
wake$string	<AT E1 Q0 S0=0 S7=255 S66=0 S95=0 S97=0 S106=0 V1 %X ^M>
wake$prompt	<OK>
dial$string	<AT %X %A D%M %S ^M>
dial$echo	1
init$once	1
dial$pulse	<P>
dial$nopulse	<T>
dial$xabort	<^M>
dial$idle	<AT Z ^M>
dial$time	45.
x$result	<3>
ph$answer	<S0=1>				; /62/
ph$noanswer	<S0=0>				; /62/
mod$res		<BUSY>		,FAILED
mod$res		<CONNECT 19200>	,CON19200
mod$res		<CONNECT 9600>	,CON9600
mod$res		<CONNECT 4800>	,CON4800
mod$res		<CONNECT 2400>	,CON2400
mod$res		<CONNECT 1200>	,CON1200
mod$res		<CONNECT FAST>	,CON9600
mod$res		<CONNECT>	,CON300
mod$res		<ERROR>		,FAILED
mod$res		<NO ANSWER>	,FAILED
mod$res		<NO CARRIER>	,FAILED
mod$res		<NO DIAL TONE>	,FAILED
mod$res		<RRING>		,RING

define		T2500MNP ,<T2500MNP>		; /BBS/ added..
mod$comment	<Telebit MNP only - Locks DTE speed>
wake$string	<AT E1 Q0 S0=0 S7=255 S66=1 S95=2 S97=0 S106=0 V1 %X ^M>
wake$prompt	<OK>
dial$string	<AT %X %A D%M %S ^M>
dial$echo	1
init$once	1
dial$pulse	<P>
dial$nopulse	<T>
dial$xabort	<^M>
dial$idle	<AT Z ^M>
dial$time	60.
x$result	<3>
ph$answer	<S0=1>				; /62/
ph$noanswer	<S0=0>				; /62/
mod$res		<BUSY>		,FAILED
mod$res		<CONNECT>	,CONNECT	; includes all CONNECT msgs
mod$res		<ERROR>		,FAILED
mod$res		<NO ANSWER>	,FAILED
mod$res		<NO CARRIER>	,FAILED
mod$res		<NO DIAL TONE>	,FAILED
mod$res		<RRING>		,RING

define		T2500V.42 ,<T2500V.42>		; /BBS/ added..
mod$comment	<Telebit V.42/MNP - Locks DTE speed>
wake$string	<AT E1 Q0 S0=0 S7=255 S66=1 S95=2 S97=0 S106=1 V1 %X ^M>
wake$prompt	<OK>
dial$string	<AT %X %A D%M %S ^M>
dial$echo	1
init$once	1
dial$pulse	<P>
dial$nopulse	<T>
dial$xabort	<^M>
dial$idle	<AT Z ^M>
dial$time	60.
x$result	<3>
ph$answer	<S0=1>				; /62/
ph$noanswer	<S0=0>				; /62/
mod$res		<BUSY>		,FAILED
mod$res		<CONNECT>	,CONNECT
mod$res		<ERROR>		,FAILED
mod$res		<NO ANSWER>	,FAILED
mod$res		<NO CARRIER>	,FAILED
mod$res		<NO DIAL TONE>	,FAILED
mod$res		<RRING>		,RING

define		T3000	,<T3000>		; /62/ added..
mod$comment	^~Telebit w/o MNP/V.42 - DTE>>DCE - RTS/CTS restraint~
wake$string	<AT E1 Q S0=0 S7=255 S58=2 S180=0 S181=0 V1 %X ^M>
wake$prompt	<OK>
dial$string	<AT %X %A D%M %S ^M>
dial$echo	1
init$once	1
dial$pulse	<P>
dial$nopulse	<T>
dial$xabort	<^M>
dial$idle	<AT Z ^M>
dial$time	45.
time$settle	<35.>				; the T3000 is SLOW to recover
x$result	<12.>
ph$answer	<S0=1>				; /62/
ph$noanswer	<S0=0>				; /62/
mod$res		<BUSY>		,FAILED
mod$res		<CONNECT 38400>	,CON38400
mod$res		<CONNECT 19200>	,CON19200
mod$res		<CONNECT 9600>	,CON9600
mod$res		<CONNECT 7200>	,CON7200
mod$res		<CONNECT 4800>	,CON4800
mod$res		<CONNECT 2400>	,CON2400
mod$res		<CONNECT 1200>	,CON1200
mod$res		<CONNECT>	,CON300
mod$res		<ERROR>		,FAILED
mod$res		<NO CARRIER>	,FAILED
mod$res		<NO DIALTONE>	,FAILED
mod$res		<RRING>		,RING

define		T3000V.42 ,<T3000V.42>		; /62/ added..
mod$comment	<Telebit V.42/MNP - DTE locked - RTS/CTS restraint>
wake$string	<AT E1 Q S0=0 S7=255 S58=2 S180=2 S181=1 V1 %X ^M>
wake$prompt	<OK>
dial$string	<AT %X %A D%M %S ^M>
dial$echo	1
init$once	1
dial$pulse	<P>
dial$nopulse	<T>
dial$xabort	<^M>
dial$idle	<AT Z ^M>
dial$time	60.
time$settle	<35.>				; the T3000 is SLOW to recover
x$result	<12.>
ph$answer	<S0=1>				; /62/
ph$noanswer	<S0=0>				; /62/
mod$res		<BUSY>		,FAILED
mod$res		<CONNECT>	,CONNECT
mod$res		<ERROR>		,FAILED
mod$res		<NO CARRIER>	,FAILED
mod$res		<NO DIALTONE>	,FAILED
mod$res		<RRING>		,RING

define		vadic	,<VADIC>
mod$comment	<Vadic Generic VA212>
wake$string	<^E^M>
wake$rate	10
wake$prompt	<*>
dial$string	<%S^M>
dial$rate	10
dial$wait	<K>
dial$ack	<^M>
dmod$string	<D^M>
dmod$prompt	<?>
dial$confirm	<^M>
dial$go		<DIALING>
dial$echo	1
dial$xabort	<^M>
dial$idle	<I^M>
dial$time	35.
mod$res		<BUSY>		,FAILED
mod$res		<FAILED CALL>	,FAILED
mod$res		<NO DIAL>	,FAILED
mod$res		<ON LINE>	,CONNECT
mod$res		<ONLINE>	,CONNECT
mod$res		<RINGING>	,RING
mod$res		<TIME OUT>	,FAILED
mod$res		<VOICE>		,FAILED

define		va42	,<VA4224>
mod$comment	<Vadic 4224>
wake$string	<^E^M>
wake$rate	10
wake$prompt	<*>
dial$string	<D%M%S%B^M>
dial$rate	10
dial$wait	<K>
dial$go		<DIALING>
dial$echo	1
dial$blind	<B>
dial$pulse	<P>
dial$nopulse	<T>
dial$xabort	<^M>
dial$idle	<I^M>
dial$time	35.
mod$res		<BUSY>		,FAILED
mod$res		<FAILED CALL>	,FAILED
mod$res		<NO DIAL>	,FAILED
mod$res		<ON LINE 2400>	,CONNECT	; /BBS/ CON2400 ?
mod$res		<ON LINE 1200>	,CONNECT	; /BBS/ CON1200 ?
mod$res		<ON LINE 300>	,CONNECT	; /BBS/ CON300 ?
mod$res		<ON LINE>	,CONNECT
mod$res		<ONLINE>	,CONNECT
mod$res		<RINGING>	,RING
mod$res		<TIME OUT>	,FAILED
mod$res		<VOICE>		,FAILED


	.sbttl	User_defined modem

;	This one MUST be the last in the list.  The USER_DEFINED modem can
;	only be loaded AFTER Kermit is running by using SET DIAL commands,
;	perhaps from KRT.INI.  It lives in a buffer created by Kermit when
;	it's started, thus the individual field data macros above will not
;	work here where these data are stored in this overlay.

define	usermd	,<USER_DEFINED>	,GLOBAL

;	No more modem definitions allowed past here!


	.sbttl	Local macros

	.macro	ttgetc	wait		; get one char from the link device
	.if  b	<wait>			; wait value is in seconds
	calls	xbinread,<#1>		; /62/ this waits up to one second
	.iff
	calls	xbinread,<wait>
	.endc
	.endm	ttgetc

	.macro	ttputc	c		; send one char to the link device
	clr	-(sp)			; create a one word buffer
	bisb	c	,(sp)		; stuff in byte sans sign extension
	mov	sp	,r0		; point to buffer
	calls	binwri	,<r0,#1>	; send it
	tst	(sp)+			; pop buffer
	.endm	ttputc

	.macro	ttputs	s		; send a string to the link device
	mov	r1	,-(sp)		; a one word buffer
	mov	s	,r1		; pass string location to doput
	call	doput			; send it
	mov	(sp)+	,r1		; pop buffer
	.endm	ttputstr

	.macro	waitfor  s ,time ,fail	; wait for a response from modem
	.if  b	<time>			; time value is in seconds
	clr	-(sp)			; time buffer
	inc	@sp			; /BBS/ default wait is one second
	.iff
	mov	time	,-(sp)		; pass time to wait
	.endc
	mov	s	,-(sp)		; and address of expected string
	call	waitfor			; go look for it
	.if nb	<fail>			; if given a failure routine address 
	tst	r0			; check to see if it worked..
	beq	fail			; it did not
	.endc
	.endm	waitfor


	.sbttl	Local data

	.psect	$pdata			; /62/
bells:	.byte	bell ,bell ,0		; two bells when CONNECTing
	.even

	.psect	$rwdata	,rw,d,lcl,rel,con
buffer:	.blkb	84.			; /BBS/ general purpose buffer
mute:	.word	0			; /BBS/ use to mute output to TT
retries:.word	0			; /BBS/ redial this many times..


	.psect	$code
	.sbttl	The real work of SET DTR
	.enabl	lsb

set.dtr::message <Toggling DTR..>	; /BBS/ added this..
	call	l$nolf			; just a return, unless TT is NOSCOPE
	call	ttyhang			; drop DTR for 0.5sec
	tst	r0			; did it work?
	bne	400$			; no
	tst	modtype			; was a modem on-line?
	beq	400$			; no
	mov	settle	,r0		; /62/ double the wait here because
	asl	r0			; /62/ some modems are just too slow!
	calls	suspend	,<#0,r0>	; /62/ let modem recover from DTR drop
reinit::message	<Re-initting modem..>
	call	l$nolf			; just a return
	mov	infomsg	,-(sp)		; save state of SET TT [NO]QUIET
	clr	infomsg			; temporarily off display
	call	set.mo			; go re-init the modem
	mov	(sp)+	,infomsg	; restore SET TT [NO]QUIET
400$:	return

	.dsabl	lsb


	.sbttl	The real work of SET MODEM
	.enabl	lsb

set.mo::mov	linksts	,r2		; save link open/closed status
	bne	20$			; it's open now
	calls	ttyini	,<#0>		; open link
	tst	r0			; successful open on line?
	bne	50$			; no, give up
	mov	sp	,linksts	; flag for ccast

20$:	call	fixspeed		; restore set speed if need be
	mov	sp	,mute		; turn off echo
	call	getatn			; try to get modems attention
	clr	mute			; turn echo back on
	tst	r0			; success?
	bne	50$			; no
	tst	sy.ini			; come here while executing KRT.INI?
	bne	50$			; ya, don't echo modem I/O
	tst	infomsg			; SET TT QUIET?
	beq	50$			; ya..
	wrtall	#modem			; no, display name of modem
	message	< modem is on-line>,cr	; note r0 still =0 here, from above..

50$:	mov	r0	,-(sp)		; save error
	mov	r2	,linksts	; restore link status
	bne	55$			; it was open, leave it that way
	call	ttyfin			; close the link
55$:	mov	(sp)+	,r0		; restore error
	return

	.dsabl	lsb


	.sbttl	The REDIAL command	; /BBS/ slightly modified..

c$redi::mov	argbuf	,r3		; argbuf address
	mov	phnum	,r2		; address of phone number
	mov	#-1	,r4		; default repeat count = 65535.
	tstb	@r3			; any repeat count passed?
	beq	5$			; no
	calls	l$val	,<r3>		; convert ascii to integer
	tst	r0			; success?
	bne	3$			; no
	mov	r1	,r4		; save repeat count
	bne	5$			; disallow 0, it would really = 65536.
3$:	mov	#er$inr	,r0		; invalid number of retires
	br	90$			; go handle error
5$:	tstb	@r2			; anything to dial?
	bne	10$			; yes
	mov	#er$npn	,r0		; no previous number dialed
	br	90$			; bail out
10$:	strcpy	r3	,r2		; copy old phone num to argbuf
	mov	sp	,xredial	; flag c$dial was called by c$redial
	clr	retries			; init number of tries counter
	call	c$dial			; redial loop moved to c$dial
	br	100$			; c$dial handles its own errors

90$:	direrr	r0			; for local errors
	call	incsts			; set global flag also
100$:	clr	r0			; error was just handled
	return


	.sbttl	The DIAL command	; /BBS/ substantially changed..
	.enabl	lsb

c$dial::tst	signon			; if coming here from init file
	bne	1$			; dump sign-on stuff before dial
	call	sho$line

1$:	tstb	ttname			; check for a real terminal name
	bne	10$			; ok
	mov	#er$pls	,r0		; please SET LINE first
	br	80$			; goto error handler

10$:	call	inqcd			; /62/ check to see if already talking
	tst	r0			; /62/ or prior session not dead yet
	ble	11$			; /62/ no data carrier is now present
	mov	#er$dcd	,r0		; /62/ can't DIAL whilst DCD asserted
	br	80$			; goto error handler

11$:	call	findnumber		; perhaps a SET PHONE NUMBER?
	bcs	90$			; findnu handles its own error
	copyz	argbuf	,phnum,#60	; don't overwrite next buffer
	mov	modtype	,r0		; recover the address of descriptor
	bne	20$			; ok
	mov	#er$mdm	,r0		; please SET MODEM first
	br	80$			; goto error handler

20$:	clr	mute			; turn echo back on just in case
	mov	dial.string(r0),r0	; get dial format string address
	tstb	@r0			; anything there?
	bne	40$			; yes
	mov	#er$ndf	,r0		; no dial format string defined
	br	80$			; goto error handler

40$:	calls	ttyini	,<#0>		; open the link device
	tst	r0			; successful?
	bne	90$			; no, ttyini does the error message
	mov	sp	,linksts	; flag for ccast
	call	fixspeed		; restore set speed if need be
	mov	modtype	,r0		; recover top of list
	tst	init.once(r0)		; need to re-init modem?
	beq	43$			; evidently..
	tst	mready			; is the modem now on-line?
	bne	44$			; ya
43$:	call	getatn			; try to get modems attention
	tst	r0			; did getting modems attn succeed?
	beq	44$			; ya
80$:	direrr	r0			; no, emit error msg
	br	90$			; /62/ and exit

44$:	tst	cccnt			; abort?
	bne	90$			; ya..
	tst	xredial			; redialing?
	beq	45$			; no
	inc	retries			; ya, bump retries count
	message	<Try #>
	mov	retries	,r0		; copy for integer to ascii conv
	call	L10266			; print integer as decimal numb
	message	<:>,cr

45$:	call	dodial			; actually try to dial the number now
	tst	r0			; returns 1 for success, 0 if failed
	bne	130$			; success, go CONNECT
	tst	xredial			; redialing this?
	beq	90$			; no, die..
	sob	r4	,44$		; ya, try again?

90$:	call	incsts			; set global error flag

110$:	call	ttyfin			; close the handler
	clr	linksts			; flag for ccast
129$:	clr	r0			; /62/ error already handled
	return

130$:	tst	xredial			; come here from c$redial?
	beq	199$			; nope
	tst	(sp)+			; ya, pop its return address
199$:	jmp	c$conn			; and CONNECT automatically..


	.sbttl	Reset the modem		; /BBS/ all new

c$idle::mov	modtype	,r4		; get modem type
	beq	129$			; no modem is on-line
	tst	r50dev			; is there a line set?
	beq	129$			; no, thus can't talk to modem
	call	inqcd			; /62/ ya, is the modem active?
	tst	r0			; /62/ well..
	ble	9$			; /62/ probably not, do the init
	call	ttyhang			; /62/ ya, try to hang it up!
	calls	suspend	,<#0,settle>	; /62/ let modem recover from DTR drop
9$:	clr	mready			; no longer ready no matter what
	calls	ttyini	,<#0>		; init handler, etc..
	tst	r0			; get a successful open on line?
	beq	237$			; ya
	mov	#er$idl	,r0		; can't release modem
	br	80$			; and off to common code..

237$:	mov	sp	,linksts	; flag for ccast
	call	fixspeed		; restore set speed if need be
	ttputs	dial.idle(r4)		; send idle command string to modem
	br	110$			; and off to common code..

	.dsabl	lsb


	.sbttl	Restore last set speed	; /BBS/ added..

fixspeed:tst	b4speed			; did last call alter speed?
	beq	9$			; nope
	calls	setspd	,<b4speed>	; restore speed before that happened
	clr	b4speed			; once iz enuff..
9$:	return


	.sbttl	Find location of a modem's data structure
	.enabl	lsb

;	F I N D M O D E M		; /BBS/ substantially revised..
;
;	assumes:  modem	= name of the desired modem
;	returns:    r0	= address of modem data structure or 0 if not found

findmo::save	<r3>
	tstb	modem			; did caller supply a modem name?
	beq	90$			; nope..
	mov	#modinf	,r3		; get address of head of list
	cmpb	#'?	,modem		; come here for help?
	beq	15$			; ya, format display accordingly

10$:	mov	mod.string(r3),r0	; allow match if ok up to end of
	mov	#modem	,r1		; argbuf so partial string works
11$:	cmpb	(r0)+	,(r1)+		; are they the same
	bne	13$			; no
	tstb	(r1)			; end of argbuf?
	bne	11$			; no, continue
	mov	r3	,modtype	; save address of the structure
	copyz	mod.string(r3),#modem	; be sure whole name is there
	br	80$			; done

13$:	mov	mod.next(r3),r3		; no, try the next one please
	bne	10$			; keep going
	direrr	#er$unm			; modem type is unknown
	tst	infomsg			; SET TT QUIET?
	beq	90$			; ya, skip list of possibilities

15$:	message	<The known modem types are:>,cr
	mov	#modinf	,r3		; now print the list of modems
20$:	wrtall	mod.string(r3)		; first one
	strlen	mod.string(r3)		; length of modem type
	sub	#20	,r0		; cut to 16. for tighter display
	neg	r0			; make it a positive number
	mov	r0	,r1		; stash a copy for the loop
	mov	#space	,r0		; load up a space
30$:	call	writ1ch			; write it to TT
	sob	r1	,30$		; loop until properly padded
	wrtall	mod.com(r3)		; dump comment string
	.newline
	mov	mod.next(r3),r3		; next one in list
	bne	20$			; ok
	br	90$			; exit with failure

80$:	mov	r3	,r0		; return address of structure
	br	100$
90$:	clr	r0			; failure
100$:	unsave	<r3>
	return

	.dsabl	lsb


	.sbttl	Find a defined phone number

findnu:	save	<r3,r2>			; /45/ Added 20-Feb-86 13:00:50 BDN
	cmpb	@argbuf	,#'0		; only if not number in first position
	blo	5$			; ok
	cmpb	@argbuf	,#'9		; well?
	blos	95$			; /BBS/ it's a number
5$:	mov	#pnhead	,r2		; get listhead

10$:	mov	(r2)	,r2		; loop a little, get next entry
	beq	90$			; nothing there
	mov	r2	,r3		; get address of text
	add	#2	,r3		; +2 is offset for the data
	mov	#buffer	,r0		; store temp copy here
20$:	cmpb	(r3)	,#space		; all done looking?
	beq	30$			; yes
	movb	(r3)+	,(r0)+		; no, copy more of the name
	bne	20$			; all done
30$:	clrb	(r0)			; ensure .asciz please

	; /BBS/ checking for end of argbuf matches on any partial string
	upcase	argbuf			; also leaves r0 -> argbuf
	mov	r0	,r1		; save pointer
	upcase	#buffer			; /62/ temp buff allows upcasing name
33$:	cmpb	(r0)+	,(r1)+		; are they the same?
	bne	10$			; no
	tstb	(r1)			; ya, hit end of argbuf yet?
	bne	33$			; no, continue
	inc	r3			; point to number field
	tstb	(r3)			; anything really there?
	beq	90$			; /BBS/ no, go print error message
	strcpy	argbuf	,r3		; copy into the real argument buffer
	br	95$			; /BBS/ go clear carry and exit

90$:	direrr	#er$nnf			; /BBS/ say why it's gonna die
	sec				; /51/ failure
	br	100$
95$:	clc				; /51/ success
100$:	unsave	<r2,r3>
	return


	.sbttl	Wake up (init) modem	; /BBS/ almost 100% new..

;	G E T A T N
;
;	In case the modem is already awake (at command prompt mode)
;	we will dump the string,  wait for the  acknowledgment  and
;	loop until we are sure there are no more data.  For example
;	the VA212 will send back an  INVALID  COMMAND\n* string for
;	for the ^E and one also for the <CR>.  We could, of course,
;	first send the modem its idle command,  but there are times
;	when that may be undesirable,  like when the modem is being
;	accessed via some sort of LAN or PABX.
;
;	input:	modtyp	= address of modem descriptor
;	return:	  r0	= if <>, the error code

getatn:	save	<r1,r2,r3,r4>
	clr	-(sp)			; init "msg rec'd" flag
	mov	#buffer	,r2		; write init string here
	mov	modtype	,r4		; get address of structure
	clr	mready			; modem is no longer ready
	mov	wake.string(r4),r3	; point to the init string
	tstb	(r3)			; is there one to send?
	bne	1$			; ya
	mov	#er$wks	,r0		; nope..
	jmp	95$			; handle the error

1$:	tstb	(r3)			; done?
	beq	6$			; yes
	cmpb	(r3)	,#'%		; look for a format effector
	bne	4$			; ya, not no..
	cmpb	1(r3)	,#'x!40		; "%X" to set Hayes extended mode?
	beq	2$			; yes
	cmpb	1(r3)	,#'X&137	; check both cases
	bne	4$			; not formatting, copy char over
2$:	tstb	xresult			; is there an extended mode set?
	beq	1250$			; no, kill leading space here
	movb	#'X&137	,(r2)+		; ya, insert an "X"
	mov	#xresult,r1		; make copy to auto-increment
201$:	movb	(r1)+	,(r2)+		; then insert the mode, ala "X4"
	bne	201$			; stop on the first null
1250$:	dec	r2			; then back up over it
	inc	r3			; skip over the "%" please
	br	5$			; next please
4$:	movb	(r3)	,(r2)+		; not formatting, copy character
5$:	inc	r3			; skip over current char now
	br	1$			; next
6$:	clrb	(r2)			; .asciz

	mov	#3	,r3		; loop a little to get modem going
7$:	call	eatjunk			; trash stuff that may be waiting
	mov	#buffer	,r2		; get address of wakeup string
	br	13$			; for display format on abort

10$:	tstb	(r2)+			; /62/ next byte..
	beq	15$			; /62/ that's all there is
	tst	mute			; allow strike any key abort?
	bne	13$			; no, not this time
	call	chkabo			; strike any key to abort
	tst	r0			; get anything?
	beq	13$			; nope
	inc	cccnt			; fake abort so modem is stopped
	call	clrcns			; eat LF after a CR, etc..
	tst	(sp)			; /62/ anything typed out yet?
	beq	80$			; /62/ no
	.newline			; ya, ensure abort message is on \n
	br	80$			; and bail out..

13$:	ttputc	(r2)			; /62/ put a char to the modem
	tst	dial.echo(r4)		; /62/ does it echo?
	beq	21$			; /62/ no
	ttgetc	#-1			; then look for its echo
	tst	r0			; anything there?
	bne	14$			; no
	bicb	#^c177	,r1		; remove parity always
	cmpb	r1	,#cr		; is it a return?
	beq	14$			; ya, don't echo it
	cmpb	r1	,#lf		; is it a line feed?
	beq	14$			; ya, don't echo it
	movb	r1	,r0		; get a copy of it
	br	23$			; /62/ and go dump same to the screen
21$:	calls	suspend	,<#0,#1>	; /62/ match above ttgetc 1 tick lag
	movb	(r3)	,r0		; cop char just sent
23$:	tst	mute			; echo this to TT?
	bne	14$			; no, don't echo modem I/O
	mov	r0	,@sp		; set "msg rec'd" flag
	call	writ1char		; and echo to TT
14$:	calls	suspend	,<#0,wake.rate(r4)> ; no, pause if need be
	br	10$			; and do some more

15$:	tst	(sp)			; was anything echo'd to TT?
	beq	17$			; no, skip the newline
	.newline			; ya, tag it
17$:	waitfor	wake.prompt(r4),#2,20$	; now wait 2 secs for a response
	br	25$			; success
20$:	tst	cccnt			; abort?
	bne	80$			; ya..
	dec	r3			; decrement loop counter
	beq	90$			; a complete failure, exit
	jmp	7$			; next please

25$:	mov	r4	,mready		; flag that modem is initialized
	clr	r0			; return(success)
	br	100$

80$:	mov	#er$abk	,r0		; say it's a keyboard abort
	br	95$
90$:	mov	#er$wke	,r0		; can't get wake$pmpt from modem
95$:	clr	mready			; modem is not now ready
100$:	call	eatjunk			; just to be sure..
	tst	(sp)+			; pop "msg rec'd" flag buffer
	unsave	<r4,r3,r2,r1>
	return


	.sbttl	Dial the number		; /BBS/ moderately modified..

;	Note that the waitfor routine,  called by macro of same name, will
;	exit immediately if the string to compare against is NULL, thus it
;	won't hurt anything to call it for modems that may not respond, as
;	long dmod.* aren't defined for such a modem, that is..

dodial:	save	<r2,r3,r4>
	clr	-(sp)			; /62/ init "msg rec'd" flag
	mov	#buffer	,r3		; pointer to a handy buffer
	mov	modtype	,r4		; get address of modem descriptor
	call	fmtstr			; format the dialing string

	ttputs	dmod.string(r4)		; dump the prompt for dialing out
	waitfor	dmod.prompt(r4),#4,28$	; wait for a response
	call	eatjunk			; let things settle a bit
	br	15$			; display format on abort kludge

10$:	tstb	(r3)+			; next byte..
	beq	40$			; that's all there is

	call	chkabo			; strike any key to abort
	tst	r0			; get anything?
	beq	15$			; nope
	inc	cccnt			; fake abort so modem is stopped
	call	clrcns			; eat LF after a CR, etc..
	tst	(sp)			; /62/ was anything echo'd to TT?
	beq	11$			; /62/ no, skip the newline
	.newline			; /62/ ya, tag it
11$:	jmp	891$			; /62/ go clean up

15$:	ttputc	(r3)			; send a char to the modem
	tst	dial.echo(r4)		; does it echo?
	beq	20$			; no
	ttgetc	#-1			; ya, wait one tick for echo
	tst	r0			; get anything?
	bne	23$			; no
	bicb	#^c177	,r1		; remove parity always
	movb	r1	,r0		; copy the char
	br	21$			; and go dump same to the screen
20$:	calls	suspend	,<#0,#1>	; /62/ match above ttgetc 1 tick lag
	movb	(r3)	,r0		; cop char just sent
21$:	mov	r0	,@sp		; /62/ set "msg rec'd" flag
	call	writ1char		; and echo it to TT
23$:	calls	suspend	,<#0,dial.rate(r4)> ; pace chars if dial.rate is not 0
	br	10$			; loop

28$:	mov	#nodprompt,r0		; no dial prompt
	br	105$

40$:	tst	(sp)			; /62/ ever type anything to TT?
	beq	401$			; /62/ no, thus a newline isn't needed
	.newline			; for dial string above
401$:	mov	#buffer	,r3		; restore buffer pointer
	waitfor	dial.ack(r4),#4,85$	; wait for numb to echo perhaps
	ttputs	dial.conf(r4)		; stuff a confirm (ok if null)
	waitfor	dial.go(r4),#5,100$	; maybe wait for any confirming string
	call	getsts			; get final result of the call please
	tst	cccnt			; did this die from a keyboard abort?
	bne	89$			; ya
	inc	r0			; success?
	bgt	110$			; yes
	beq	44$			; no, but modem stopped itself
	ttputs	dial.xabort(r4)		; get the modem to stop
	calls	suspend	,<#0,settle>	; let modem recover from abort!
44$:	tstb	buffer			; anything in the buffer?
	bne	107$			; ya, message already displayed..
	mov	#defmsg	,r0		; no, must have timed out, say so
	br	105$			; go dump failure message

85$:	mov	#nod.ack,r0		; no dial ack
	br	105$
100$:	mov	#nod.go	,r0		; no dial.go confirmation
105$:	tst	cccnt			; was ^C typed?
	beq	106$			; no

89$:	tstb	buffer			; anything in the buffer?
	beq	891$			; no, don't need a newline
	.newline			; ya, goto a clean line
891$:	ttputs	dial.xabort(r4)		; get the modem to stop
	calls	suspend	,<#0,settle>	; let modem recover from abort!
	mov	cccnt	,-(sp)		; save number of times ^C typed
	clr	cccnt			; do this so set.dtr can call getatn
	call	set.dtr			; drop DTR and re-init modem
	direrr	r0			; /62/ if set.dtr failed, say why
	mov	(sp)+	,cccnt		; restore ^C count
	mov	#abort	,r0		; user interrupt message

106$:	wrtall	r0			; say why we are here..
	.newline
107$:	clr	r0			; failure
	br	120$

110$:	wrtall	#bells			; beep just before CONNECTing
	mov	#1	,r0		; success
120$:	tst	(sp)+			; /62/ pop "msg rec'd" flag buffer
	unsave	<r4,r3,r2>
	return

	.save
	.psect	string	,ro,d,lcl,rel,con
abort:	.asciz	"% Aborted from keyboard"
defmsg:	.asciz	"% Timed out"
nodpro:	.asciz	"% No dial$prompt"
nod.go:	.asciz	"% No dial$go"
nod.ack:.asciz	"% No dial$ack"
	.even
	.restore


	.sbttl	Get final result of dialing	; /BBS/ somewhat modified

	NOREPLY	=	7		; /62/ fail call after this many rings

	; offsets to local data on stack
	STATUS	=	0		; current status
	NRINGS	=	2		; number of rings
	LOCSIZ	=	4		; size of the above

;	passed:	  r4	= pointer to modem's data structure
;	return:	  r0	= if <>, the error code

getsts:	save	<r5>
	mov	diatmo	,r3		; /62/ # secs to wait for response
	mul	clkflg	,r3		; convert to ticks per second
	mov	r3	,r2		; save 16-bit product here
	sub	#locsiz	,sp		; allocate a local data buffer
	mov	sp	,r5		; and a pointer to it
	clr	-(sp)			; init "msg rec'd" flag
	mov	#noreply,nrings(r5)	; after this many rings, give up..
	clr	(r5)			; status = 0

10$:	tst	(r5)			; while (status == 0)
	bne	90$			; exit with result
	mov	#buffer	,r3		; a buffer pointer
	clrb	(r3)			; init buffer

15$:	call	chkabo			; strike any key to abort
	tst	r0			; get anything?
	beq	20$			; nope
	inc	cccnt			; fake abort so modem is stopped
	call	clrcns			; eat LF after a CR, etc..
	br	24$			; and bail out

20$:	calls	xbinrea	,<#-1>		; this actually waits one tick
	tst	r0			; did that work?
	beq	30$			; ya
	sob	r2	,15$		; no, try it all again

24$:	mov	#aborted,(r5)		; flag modem needs to be killed
	br	90$			; exit loop

30$:	tstb	r1			; never suffer embedded nulls
	beq	15$			; a null, skip it
	bicb	#^c177	,r1		; ensure a real seven bit character
	movb	r1	,(r3)+		; copy the byte over
	clrb	(r3)			; ensure we stay .asciz
	tst	res.bin(r4)		; exit loop on single character I/O?
	bne	41$			; yes
	cmpb	r1	,#cr		; carriage return finally found?
	beq	40$			; yes
	cmpb	r1	,#lf		; no, but
	beq	40$			; a line feed will do nicely
	mov	r1	,@sp		; it's neither, set "msg rec'd" flag
	mov	r1	,r0		; pass char to writ1char
	call	writ1char		; echo to TT
	br	15$			; then go back for more input

40$:	cmpb	buffer	,#cr		; leading return?
	beq	10$			; can't be a valid response
	cmpb	buffer	,#lf		; leading line feed?
	beq	10$			; ditto..

41$:	tst	(sp)			; was anything echo'd to TT?
	beq	47$			; no, cursor is already on column one
	.newline			; ya, tag it
47$:	jsr	pc,.default		; go check result message
	br	10$			; next please

90$:	mov	(r5)	,r0		; recover error
	tst	(sp)+			; pop "msg rec'd" flag buffer
	add	#locsiz	,sp		; pop temp buffer
	unsave	<r5>
	return


	.sbttl	Check modem's response	; /BBS/ about 50% new..
	.enabl	lsb			; /39/ 4-DEC-1985, Brian Nelson

;	Read possible responses and their message classes from a linked
;	list whose first address is in res.header(modem_address).  If a
;	modem has no mod$res entries this routine will fail any call.

.default:save	<r3>
	mov	res.head(r4),r3		; get listhead of responses
	beq	90$			; nothing defined..
10$:	save	<r1,r2,r3>
	add	#4	,r3		; 4 byte offset for text
	mov	#buffer	,r2		; address of response to find text in
13$:	cmpb	(r2)	,#space		; is this a space or below?
	bgt	15$			; no, continue
	inc	r2			; ya, skip past leading blanks and non
	br	13$			; printing stuff before checking match
15$:	upcase	r3			; uppercase text
	strlen	r3			; get its length
	mov	r0	,r1		; save it
	upcase	r2			; uppercase response from modem
	strlen	r2			; get its length
	calls	instr	,<r2,r0,r3,r1>	; see if desired text is in response
	unsave	<r3,r2,r1>
	dec	r0			; match must begin from the top of
	beq	20$			; the response string, else ignore it
	mov	(r3)	,r3		; get the next in the list
	bne	10$			; something is left to try
	br	100$			; tried 'em all..
20$:	mov	2(r3)	,(r5)		; response class
	blt	21$			; /62/ < is 38.4kb or a failed call
	bgt	33$			; 1 = ring, >1 = connect..
	br	100$			; 0 = info only, display but no action
21$:	cmp	(r5)	,#con38400	; /62/ is it 38.4kb?
	bne	90$			; /62/ no, it's a failed call..

33$:	cmp	(r5)	,#2		; what to do ??
	blo	55$			; it wuz ring /62/ fix for 38.4kb
	beq	100$			; connect without speed check
	call	ttspeed			; speed supplied, get handler's speed
	tst	r0			; is it settable?
	beq	37$			; /62/ nope..
	cmp	r0	,(r5)		; does modem speed = handler speed?
	beq	37$			; ya..
	mov	r0	,b4speed	; no, save speed before fallback..
	calls	setspd	,<@r5>		; set it now
37$:	mov	#connect,@r5		; say it's time to connect
	br	100$

55$:	clr	@r5			; turn ring into an info message
	dec	nrings(r5)		; if more than number in nrings
	bne	100$			; then give up
	message	<% No answer>,cr
	mov	#aborted,(r5)		; flag need to make modem stop
	br	100$
90$:	mov	#failed	,(r5)		; come here if modem stopped itself
100$:	unsave	<r3>
	return

	.dsabl	lsb


	.sbttl	Format dial string

;	passed:	  r3	= address of buffer to place result
;		argbuf	= the phone number to insert via %S

fmtstr:	save	<r3>
	mov	dial.string(r4),r2	; point to the dial format string
10$:	tstb	(r2)			; done?
	beq	50$			; yes
	cmpb	(r2)	,#'%		; look for a format effector
	bne	30$			; no

	mov	argbuf	,r0		; assume phone number insertion
	cmpb	1(r2)	,#'s!40		; %S formatting?
	beq	20$			; no
	cmpb	1(r2)	,#'S&137	; check both cases
	beq	20$			; yes

	mov	dial.wait(r4),r0	; no, assume pause string formatting
	cmpb	1(r2)	,#'p!40		; %P for pause string?
	beq	20$			; yes
	cmpb	1(r2)	,#'P&137	; check both cases
	beq	20$			; yes

	cmpb	1(r2)	,#'x!40		; /BBS/ "%X" for Hayes extended mode?
	beq	12$			; /BBS/ yes
	cmpb	1(r2)	,#'X&137	; /BBS/ check both cases
	bne	13$			; /BBS/ no
12$:	tstb	xresult			; /BBS/ is there an xmode set?
	beq	1250$			; /BBS/ no, kill leading space here
	movb	#'X&137	,(r3)+		; /BBS/ ya, insert an "X"
	movb	xresult	,(r3)+		; /BBS/ then the mode, ala "X4"
	movb	xresult+1,(r3)+		; /BBS/ one char or two?
	bne	25$			; /BBS/ it was two this time..
1250$:	dec	r3			; /BBS/ it was one, fix pointer
	br	25$			; /BBS/ and continue

13$:	cmpb	1(r2)	,#'M&137	; /54/ mode (ie PULSE, TONE)?
	beq	15$			; /54/ found it
	cmpb	1(r2)	,#'m!40		; /54/ try lower case also..
	bne	16$			; /54/ nope
15$:	mov	dial.pulse(r4),r0	; /54/ assume PULSE dialing
	tst	pulse			; /54/ ever SET PHONE PULSE or TONE?
	beq	25$			; /54/ no, ignore string
	bmi	20$			; /54/ ya, it's PULSE
	mov	dial.nopulse(r4),r0	; /54/ it's TONE
	br	20$

16$:	cmpb	1(r2)	,#'B&137	; /54/ SET PHONE BLIND?
	beq	17$			; /54/ ya..
	cmpb	1(r2)	,#'b!40		; /54/ no, perhaps lower case?
	bne	18$			; /62/ nope
17$:	tst	blind			; /54/ ever do the SET PHONE BLIND?
	beq	25$			; /54/ no, ignore string
	mov	dial.blind(r4),r0	; /54/ yes, insert the data then
	br	20$

18$:	cmpb	1(r2)	,#'A&137	; /62/ auto-answer format effector?
	beq	19$			; /62/ ya
	cmpb	1(r2)	,#'a!40		; /62/ try lower case also..
	bne	30$			; /62/ no, copy data then
19$:	mov	ph.noanswer(r4),r0	; /62/ default to not answering phone
	tst	answer			; /62/ did user SET PHONE ANSWER?
	beq	20$			; /62/ no
	mov	ph.answer(r4),r0	; /62/ ya, insert answer command

20$:	movb	(r0)+	,(r3)+		; copy a byte please
	bne	20$			; not a null, next please
	dec	r3			; fix current pointer up
25$:	inc	r2			; skip over the "%" please
	br	40$			; next please
30$:	movb	(r2)	,(r3)+		; not formatting, copy character
40$:	inc	r2			; skip over current character now
	br	10$			; next

50$:	clrb	(r3)			; ensure dial string is .asciz
	unsave	<r3>
	return


	.sbttl	Wait for a response	; /BBS/ moderately revised..

;	passed:	 2(sp)	= string
;		 4(sp)	= time_out
;	return:	   r0	= <> for success, 0 for time out

waitfor:save	<r2,r3,r4>		; this decrements stack pointer 6
	mov	2+6(sp)	,r4		; string we are expecting
	mov	4+6(sp)	,r3		; time_out in seconds
	mul	clkflg	,r3		; make it ticks
	clr	-(sp)			; init data rec'd flag
10$:	movb	(r4)+	,r2		; next character to await
	beq	30$			; success, we can leave now

15$:	tst	mute			; allow strike any key abort?
	bne	20$			; no
	call	chkabo			; strike any key to abort
	tst	r0			; get anything?
	beq	20$			; nope
	inc	cccnt			; fake abort so modem is stopped
	call	clrcns			; eat LF after a CR, etc..
	br	90$			; and bail out

20$:	dec	r3			; one less tick to wait
	beq	90$			; no more ticks left
	calls	xbinrea	,<#-1>		; this actually waits one tick
	tst	r0			; success?
	bne	15$			; no
	bicb	#^c177	,r1		; remove parity always
	cmpb	r1	,#cr		; is it a return?
	beq	27$			; ya, don't echo it
	cmpb	r1	,#lf		; is it a line feed?
	beq	27$			; ya, don't echo it
	movb	r1	,r0		; get a copy of it
	beq	15$			; dump nulls
	tst	mute			; echo to TT this time?
	bne	27$			; no, don't echo modem I/O
	mov	r0	,@sp		; set "msg rec'd" flag
	call	writ1char		; keep user informed of what's up..
27$:	cmpb	r1	,r2		; did we get the correct character?
	bne	15$			; no, keep waiting then
	br	10$			; found it, check for next character

30$:	mov	sp	,r0		; success
	br	100$
90$:	clr	r0			; failure
100$:	tst	(sp)+			; was anything dumped to TT?
	beq	101$			; nope
	.newline			; ya, tag it with a newline
101$:	unsave	<r4,r3,r2>
	mov	(sp)	,4(sp)		; move return address up and fix stack
	cmp	(sp)+	,(sp)+		; here instead of in calling macro
	return


	.sbttl	Eat junk from modem

eatjunk:save	<r0,r1>
10$:	ttgetc	#-1			; /BBS/ speed up junk consumption
	tst	r0			; /BBS/ and thus redial faster..
	beq	10$			; loop until nothing remains
	unsave	<r1,r0>
	return


	.sbttl	Send a string to the modem

doput:	strlen	r1			; get length
	tst	r0			; anything to send?
	beq	10$			; no
	calls	binwri	,<r1,r0>	; ya, length is in r0
10$:	return


	.sbttl	SHOW MODEM, SHOW DIAL	; /BBS/ heavily hacked
	.enabl	lsb

shodia::mov	modtype	,r4		; get address of descriptor
	bne	5$			; got it
	direrr	#er$mdm			; no modem type has been set
	return

5$:	mov	#slist	,r3		; info list start
15$:	movb	(r3)+	,r1		; /62/ type 2=on/off,1=string,0=number
	movb	(r3)+	,r2		; /62/ offset, zero implies end
	beq	60$			; all done
	add	r4	,r2		; move to the correct offset
	mov	r3	,-(sp)		; /62/ save the header address
20$:	tstb	(r3)+			; now look for the end of it
	bne	20$			; not yet
	decb	r1			; /62/ determine data type
	bgt	35$			; /62/ it's "2"  goto on/off displayer
	beq	30$			; /62/ it's "1"  goto string handler
	wrtall	(sp)+			; /62/ dump the header
	mov	@r2	,r0		; it is "0"  copy number to display
	call	L10266			; write it to terminal
	br	50$			; next please

30$:	mov	(r2)	,r0		; get the string address
	beq	31$			; /62/ nothing there
	tstb	@r0			; again
	bne	33$			; /62/ there is something to see
31$:	tst	(sp)+			; /62/ nothing, dump unused header
	br	15$			; /62/ skip newline, try next one
33$:	wrtall	(sp)+			; /62/ dump the header
	call	unfmts			; convert and print it
	wrtall	r0			; do it
	br	50$			; next

35$:	wrtall	(sp)+			; /62/ dump the header
	mov	(r2)	,r0		; /62/ get the data
	beq	37$			; /62/ 0 = no
	message	<Yes>			; /62/ anything_else = yes
	br	50$			; /62/
37$:	message	<No>			; /62/

50$:	.newline
	br	15$			; next

60$:	message	<Dial time_out secs: >	; /62/
	mov	diatmo	,r0		; /62/ get time_out time
	call	L10266			; /62/ display it
	.newline			; /62/

	message	<Settle_time ticks:  >	; /62/
	mov	settle	,r0		; get settle time
	call	L10266			; display it
	.newline			; /62/

	clr	-(sp)			; a flag, if <> something found

	mov	ph.noanswer(r4),r1	; /62/ default to not answering phone
	tst	answer			; /62/ did user SET PHONE ANSWER?
	beq	690$			; /62/ no
	mov	ph.answer(r4),r1	; /62/ ya, insert answer command
690$:	tstb	@r1			; /62/ if there is any..
	beq	699$			; /62/ there isn't
	movb	#'A&137	,r2		; /62/ there is, and it's this type
	call	foreff			; /62/ go display it

699$:	tst	blind			; ever SET PHONE BLIND?
	beq	601$			; no, ignore string
	mov	dial.blind(r4),r1	; yes, insert the data then
	tstb	@r1			; if there is any..
	beq	601$			; there isn't
	movb	#'B&137	,r2		; /62/ there is, and it's this type
	call	foreff			; go display it

601$:	mov	dial.pulse(r4),r1	; assume PULSE dialing
	tst	pulse			; ever SET PHONE PULSE or TONE?
	beq	603$			; no, ignore string
	bmi	602$			; ya, it's PULSE
	mov	dial.nopulse(r4),r1	; it's TONE
602$:	tstb	@r1			; anything defined?
	beq	603$			; nope
	movb	#'M&137	,r2		; /62/ there is, and it's this type
	call	foreff			; go display it

603$:	tstb	xresult			; anything set here?
	beq	604$			; nope..
	tst	(sp)			; /62/ has this stuff been identified?
	bne	6030$			; /62 ya
	wrtall	#msg$fmt		; /62/ no, do that now
	mov	sp	,(sp)		; /62/ and set flag it has been done
6030$:	message	<%X = "X>		; ya, dump a header
	wrtall	#xresult		; and the actual number
	mov	#'"	,r0		; /62/
	call	writ1char		; /62/

604$:	tst	(sp)+			; /62/ dump formatter flag buffer
	beq	605$			; /62/ no newline needed..
	.newline			; done with format effectors

605$:	message	<Binary_responses:   >	; /62/
	tst	res.bin(r4)		; /62/ on or off?
	beq	637$			; /62/ 0 = no
	message	<Yes>			; /62/ anything_else = yes
	br	640$			; /62/
637$:	message	<No>			; /62/
640$:	.newline			; /62/

	mov	res.head(r4),r3		; response header
	beq	100$			; nothing present
	message	<Result strings:>,cr
65$:	mov	r3	,r0		; /62/ get the response address
	beq	100$			; all done
	add	#4	,r0		; /62/ offset to text
	call	unfmts			; /62/ convert it
	wrtall	r0			; /62/ and print it
	strlen	r0			; /62/ ..more efficient
	sub	#col.act,r0		; number of blanks needed to pad
	neg	r0			; make it positive
	mov	r0	,r5		; save it in a safe place
	ble	75$			; avoid this please
	mov	#space	,r0		; load up a space
70$:	call	writ1ch			; this way is more efficient
	sob	r5	,70$		; loop until done

75$:	mov	2(r3)	,r0		; what is the message class?
	bmi	85$			; if < it's failure to connect
76$:	dec	r0			; if = 1 it's ringing
	beq	83$			; it was one, because now it's 0
	message	<Success>
	dec	r0			; if = 2 connect w/o speed check
	beq	77$			; it wuz 2
	inc	r0			; restore
	inc	r0			; r0
	wrtall	#msg$dte		; "  DTE>>"
	call	L10266			; tag above with speed
77$:	.newline
	br	90$
83$:	message	<Rings+1>,cr
	br	90$
85$:	cmp	r0	,#con38400	; /62/ kludge to see if it's 38.4kb
	beq	76$			; /62/ it is..
	message	<Failure>,CR
90$:	mov	(r3)	,r3		; pick up link to..
	br	65$			; ..next please

100$:	clr	r0			; /62/
	return

	.dsabl	lsb

foreff:	tst	2(sp)			; /62/ need to print header?
	bne	199$			; /62/ nope..
	wrtall	#msg$fmt		; /62/ ya
	mov	sp	,2(sp)		; /62/ but not anymore
199$:	mov	#'%	,r0		; /62/ a percent sign char
	call	writ1char		; /62/ dump it to the terminal
	movb	r2	,r0		; /62/ the format effector character
	call	writ1char		; /62/ now dump it to tt
	wrtall	#prefix			; /62/ do some display formatting
	wrtall	r1			; /62/ now display what is inserted
	wrtall	#tripsp			; /62/ format display
	return

	.save
	.psect	$pdata
msg$fmt:.asciz	"Format effectors:   "	; /62/
msg$dte:.asciz	"  DTE>>"		; tags CONNECT msgs that change speed
prefix:	.asciz	\ = "\			; /62/ prefix for format effector data
tripsp:	.asciz	\"   \			; /62/ a " followed by three blanks

	.macro	des  type ,offset ,title
	.if  b	<type>
	.byte	0	,0
	.iff
	.byte	type	,offset		; type_0=integer, type_1=string
	.asciz	@title@			; /62/ type_2=on/off
	.endc
	.endm	des

slist:	des	1 ,mod.string	,<Modem name:         >
	des	1 ,mod.comment	,<Modem type:         >
	des	1 ,wake.string	,<Wakeup string:      >
	des	0 ,wake.rate	,<Wake_rate in ticks: >
	des	1 ,wake.prompt	,<Response to wakeup: >
	des	1 ,dial.string	,<Dial FORMAT string: >
	des	0 ,dial.rate	,<Dial_rate in ticks: >
	des	1 ,dial.wait	,<Pause character(s): >
	des	1 ,dial.ack	,<Dial_acknowledge:   >
	des	1 ,dmod.string	,<"Initiate" string:  >
	des	1 ,dmod.prompt	,<"Initiate" prompt:  >
	des	1 ,dial.confirm	,<"Confirm" string:   >
	des	1 ,dial.go	,<"Confirm" ack:      >
	des	2 ,dial.echo	,<Echoes dial string: >
	des	2 ,init.once	,<Redial w/o reinit:  >
	des	1 ,dial.blind	,<Blind dial string:  >
	des	1 ,dial.pulse	,<Pulse dial string:  >
	des	1 ,dial.nopulse	,<Tone dial string:   >
	des	1 ,dial.xabort	,<Dial abort string:  >
	des	1 ,dial.idle	,<Reset/idle string:  >
	des	1 ,ph.answer	,<Enable autoanswer:  >
	des	1 ,ph.noasnwer	,<Disable autoanswer: >
	des
	.even
	.restore

	.end