.equ	a, %eax
	.equ	b, %ebx
	.equ	c, %ecx
	.equ	d, %edx
	.equ	bp, %ebp
	.equ	sp, %esp
	.equ	di, %edi
#-----------------------------------------------
#	M A C R O   D E C L A R A T I O N S
#-----------------------------------------------
# subroutines list
	.macro	SUBRLIST
	SUBR	_start
	SUBR	D.init
	SUBR	D.setId
	SUBR	D.log
	SUBR	D.getTs
	SUBR	D.subr
	SUBR	Node
	SUBR	N.bind
	SUBR	N.conn
	SUBR	N.acc
	SUBR	N.closeSocket
	SUBR	N.read
	SUBR	N.write
	SUBR	N.get
	SUBR	N.put
	SUBR	N.sslErr
	SUBR	Data
	SUBR	Da.load
	SUBR	Da.chk
	SUBR	Da.unl
	SUBR	Da.dttl
	SUBR	Da.ttl
	SUBR	Da.getTs
	.endm
#-----------------------------------------------
# push subroutine addr, prints its name and addr
# leave subr name and addr on stack
	.macro	SUBR	subr:req
	push	$\subr
	push	$9f
	push	$8f
	push	stderr
	call	fprintf
	jmp	7f
9:	.asciz	"\subr"
8:	.asciz	"%-12s\t%p\n"
7:	lea	8(sp), sp
	.endm
#-----------------------------------------------
# prepare to define subroutine args; use macro DS to define args
	.macro	ARGS
	ac = 40
	.endm
#-----------------------------------------------
# prepare to define subroutine args; use macro DS to define args
	.macro	M_ARGS
	ac = 40
	DS	thisP
	.endm
#-----------------------------------------------
# declare storage
	.macro	DS	id:req, len=4
	\id = ac
	ac = ac + \len
	.endm
#-----------------------------------------------
# prepare to define subroutine local vars
	.macro	PROLOC
	ac = 0
	.endm
#-----------------------------------------------
# prepare to define subroutine local vars
	.macro	M_LOCAL
	ac = 0
	DL	deP
	.endm
#-----------------------------------------------
# declare local var
	.macro	DL	id:req, len=4
	ac = ac + \len
	\id = -ac
	.endm
#-----------------------------------------------
# terminate subroutine local vars definition
	.macro	EPILOC
	locL = ac
	.endm
#-----------------------------------------------
# subroutine prolog
# expects length of local storage under the name "locL"
	.macro	PROLOG
	pusha
	enter	$locL, $0
	.endm
#-----------------------------------------------
# subroutine prolog
# expects length of local storage under the name "locL"
	.altmacro
	.macro	M_PROLOG	m_prefix:req, m_name:req
	.global	\m_prefix\().\m_name
\m_prefix\().\m_name:
	pusha
	enter	$ac, $0
	mov	thisP(bp), b
	lea	\m_prefix\().debug(b), a
	mov	a, deP(bp)
	.endm
	.noaltmacro
#-----------------------------------------------
# subroutine epilog without return value
	.macro	EPILOG
	leave
	popa
	ret
	.endm
#-----------------------------------------------
# subroutine epilog with return value in EAX
# expects length of local storage under the name "locL"
	.macro	EPILOG_R
	leave
	mov	a, 28(sp)
	popa
	ret
#	mov	-36(sp), a
	.endm
#-----------------------------------------------
# ABEND at system routine err
	.macro	ERR	causer:req
	pushl	$9f
	call	printf
	pushl	$1
	call	exit
9:	.asciz	"\causer: %m\n"
	.endm
#-----------------------------------------------
# ABEND at system routine err using debug structure
# expects deP(bp)-->Debug inst
	.macro	SYSERR	causer:req
	push	$9f				# -->format
	push	$0				# no. of values
	push	$0				# msg debug level
	pushl	deP(bp)				# -->Debug instance
	call	D.log				# print msg
	call	C.abend
9:	.asciz	"\causer: %m"
	.endm
#-----------------------------------------------
# print SSL err msg queue and then abend
# -->Debug in deP(bp) is expected
	.macro	SSLERR	msg:req
	pushl	$9f
	pushl	deP(bp)
	call	N.sslErr
9:	.asciz	"\msg"
	.endm
#-----------------------------------------------------------
	.macro	SYS	name:req
	call	\name
	cmp	$-1, a
	jne	8f
	SYSERR	"\name"
8:	mov	thisP(bp), b
	test	a, a
	.endm
#-----------------------------------------------
# get integer value from ENV
	.macro	GETINTENV key:req
	pushl	$9f
	call	C.getArg
	lea	4(sp), sp
	cmp	$0, a
	jmp	8f
9:	.asciz	"\key"
8:
	.endm
#-----------------------------------------------
# set local debug ID
# supposed: local deP-->Debug
# expected on the stack:
#	\argc values to be put in debug ID according to format
# \argc may be zero
	.macro	DEBID	format:req, argc=0
	push	$9f				# -->format
	push	$\argc				# no. of values
	pushl	deP(bp)				# -->Debug instance
	call	D.setId				# put debug ID to Debug inst
	jmp	8f
9:	.asciz	"\format"
8:	lea	12(sp), sp
	.endm
#-----------------------------------------------
# debug output
# supposed: local deP-->Debug
# expected on the stack:
#	\argc values to be printed by \format at debug level \level
# \argc may be zero
# all regs are preserved
	.macro LOG	level:req, format:req, argc=7
	push	$9f				# -->format
	push	$\argc				# no. of values
	push	$\level				# msg debug level
	pushl	deP(bp)				# -->Debug instance
	call	D.log		 		# print msg
	jmp	8f
9:	.asciz	"\format"
8:	lea	16(sp), sp
	.endm
#-----------------------------------------------
# flat print
# sp, bp are preserved
	.macro	PR	format:req
	push	$9f
	push	stderr
	call	fprintf
	jmp	8f
9:	.asciz	">>> \format\n"
8:	lea	8(sp), sp
	.endm
#-----------------------------------------------
# print ip, bp, sp before subroutine call
# to be placed directly before a call instruction
# expected deP(bp) as -->Debug
# all regs are preserved
	.macro	B_CALL	level:req, label="BEFORE SUBR CALL "
	push	a
	lea	4(sp), a
	push	a
	push	bp
	pushl	$7f+5
	LOG	\level, "\label: ip: %p, bp: %p, sp: %p", 3
	lea	12(sp), sp
	pop	a
	jmp	7f
7:
	.endm
#-----------------------------------------------
# print ip, bp, sp saved in sburoutine's stack frame
# to be placed anywhere before return seq and after deP(bp) is set
# expected deP(bp) as -->Debug
# all regs are preserved
	.macro	B_RET	level:req, label="BEFORE SUBR RETURN"
	push	a
	lea	8(bp), a
	push	a
	push	(bp)
	push	4(bp)
	LOG	\level, "\label: ip: %p, bp: %p, sp: %p", 3
	lea	12(sp), sp
	pop	a
	jmp	7f
7:
	.endm
#-----------------------------------------------
# print ip, bp, sp retained for return from sburoutine
# all regs are preserved
	.macro	A_CALL	label="AFTER  CALL"
	pusha
	lea	8(bp), a
	push	a
	push	(bp)
	push	4(bp)
	pushl	$9f
	call	printf
	lea	16(sp), sp
	popa
	jmp	8f
9:	.asciz	"\label: ip: %p, bp: %p, sp: %p\n"
8:
	.endm
#-----------------------------------------------
	.macro SLEEPER	time:req, ident=">>>"
	pusha
	LOG	7, "\ident: sleeping \time"
	pushl	$\time
	call	sleep
	lea	4(sp), sp
	LOG	7, "\ident: woken up"
	popa
	.endm
#-----------------------------------------------
#	A B S T R A C T   D A T A   D E C L A R A T I O N S
#-----------------------------------------------
# 	rSA	reg save area
	ac = 0
	DS	retSA
	DS	regSA, 32
	DS	bpSA
	rSAL = ac
#-----------------------------------------------
# 	Timeval
	ac = 0
	DS	secs
	DS	usecs
	timevalL = ac
#-----------------------------------------------
#	AddrInfo		IP family net addr block
	ac = 0
	DS	ai_flags
	DS	ai_family
	DS	ai_socktype
	DS	ai_protocol
	DS	ai_addrlen
	DS	ai_addrP	# -->sockaddr
	DS	ai_canonnameP
	DS	ai_nextP
	AddrInfoL = ac
#-----------------------------------------------
	SIGUSR2 = 12
	SIG_IGN = 1
	SIG_UNBLOCK = 1
#	sigaction		signal handler definition
	ac = 0
	DS	sa_handler
	DS	sa_mask, 128
	DS	sa_flags
	DS	sa_unused
	SigActionL = ac
#-----------------------------------------------
#	SockAddr
	ac = 0
	DS	sa_family, 2
	DS	sa_data, 14
	SockAddrL = ac
#-----------------------------------------------
# 	timeval struct
	ac = 0
	DS	Ti.secs
	DS	Ti.usecs
	timevalL = ac
#-----------------------------------------------
#	Debug		debug info
	ac = 0
	D.idL = 128
	DS	D.id, D.idL			# debug ID of process
	D.msgL = 256
	DS	D.msg, D.msgL			# debug msg workspace
	DebugL = ac

	.macro	DebugA				# returns -->Debug
	push	$DebugL
	call	malloc
	cmp	$0, a
	ja	8f
	SYSERR	"malloc"
8:	movl	$0, D.id(a)
	.endm
#-----------------------------------------------
#	CS		top level attributes
	ac = 0
	DS	C.debug, DebugL
	DS	C.debMaxLev			# max level of debug msgs to be printed
	DS	C.txtP				# -->text to be sent in messages
	DS	C.ttl				# TTL for circulating msgs
	DS	C.mp0				# TCP port of first mash node
	DS	C.mn				# intended # of nodes in mash
	DS	C.rp0				# TCP port of first ring node
	DS	C.rn				# intended # of nodes in ring
	DS	C.pace.tv_sec			# timespec.tv_sec
	DS	C.pace.tv_nsec			# timespec.tv_nsec
	DS	C.pacing			# pacing indicator
#	DS	C.rs				# random() seed
	DS	C.ssl				# ssl mask: 01B=noSSL, 10B=SSL, 11B=both
	DS	C.connTh			# connection retry threshhold
	DS	C.shP				# -->shared counters
	DS	C.pathP				# -->pathname to application home dir
	DS	C.cePathP			# -->pathname to SSL dir
	DS	C.caPathP			# -->pathname to SSL CA CERT dir
	CSL = ac

	.macro	CSA				# returns -->CS
	push	$CSL
	call	malloc
	cmp	$0, a
	ja	8f
	SYSERR	"malloc"
8:
	.endm
#-----------------------------------------------
# 	Share		counters shared between procs or threads
	ac = 0
	DS	S.counter_sem, 16		# semaphore for counters
	DS	S.conns				# overall connections counter both in ring and mash
	DS	S.msgs				# overall forewards# both in ring and mash
	DS	S.act				# active node processes counter
	DS	S.mash_open_client_count	# no. of opened clients in mash
	DS	S.mash_open_SSL_client_count	# no. of opened SSL clients in mash
	ShareL = ac

	.macro ShareA				# returns -->Share
	push	$0
	push	$-1
	push	$0x21				# PROT_READ | PROT_WRITE
	push	$0x03				# MAP_SHARED | MAP_ANONYMOUS
	push	$ShareL
	push	$0
	call	mmap
	cmp	$-1, a
	jne	8f
	SYSERR	"mmap"
8:
	.endm
#-----------------------------------------------
# Data - container for data sent through connection topology
#	Container Header
	ac = 0
	DS	H.ttl				# msg TTL
	DS	H.ts				# timestamp
	DS	H.lport				# listening TCP port
	HeaderL = ac
#	Container Payload
	ac = 0
#	Pa.loadL = 256
	DS	Pa.ts				# timestamp
	DS	Pa.text, 0			# load sent in msg
	PayloadL = ac
#	Container to be send
	ac = 0
	DS	Co.hdr, HeaderL			# Header
	DS	Co.payl, PayloadL		# Payload
#	ContainerL = ac
# 	Data instantion
	ac = 0
	DS	Da.debug, DebugL		# Debug
	DS	Da.contP			# -->Container
	DS	Da.datalen			# container length
	DataL = ac

	.macro	DataA				# returns -->Data
	push	$DataL
	call	malloc
	cmp	$0, a
	ja	8f
	SYSERR	"malloc"
8:
	.endm
#-----------------------------------------------
#	Node		general attributes of node
	ac = 0
	DS	N.debug, DebugL			# debug info
	DS	N.cnstlnP			# -->Constellation block
	DS	N.topo				# constellation topology
	DS 	N.locPort			# TCP port node binds to
	DS	N.first				# port # of first node in constellation
	DS	N.last				# port # of last node in constellation
	DS	N.nodes				# number of nodes
	DS	N.div				# random node choise divisor (MAX_INT / nodes)
	DS	N.kicker			# kicker indicator
	DS	N.forwP				# -->shared forward indicator
	DS	N.closing			# closing in progress indicator
	DS	N.ssc				# server side socket
	DS	N.data, DataL			# data block
	DS	N.dataP				# -->data block
	DS	N.srvSideP			# -->array of server side Sockets
	DS	N.cliSideP			# -->array of client side Sockets
	DS	N.sockArrLen			# socket array length
	DS	N.next				# next node's port#
	DS	N.nfds				# highest FD# in FD sets
	DS	N.rs, 128			# read FD set
	DS	N.es, 128			# exceptional FD set
	DS	N.t, timevalL			# timeval for select
	DS	N.ssl				# SSL switch: 0=noSSL, 1=SSL
	DS	N.ctxP				# -->SSL context
	DS	N.pid				# process ID
	DS	N.ptid				# closing thread ID
	NodeL = ac

	.macro	NodeA				# returns -->Node
	push	$NodeL
	call	malloc
	cmp	$0, a
	ja	8f
	SYSERR	"malloc"
8:
	.endm
#-----------------------------------------------
#	SocketInfo	comm socket info
	ac = 0
	DS	So.remPort			# TCP port on remote site
	DS	So.sc				# comm socket#
	DS	So.sslP				# -->SSL structure
	SocketInfoL = ac

	.macro	SocketA				# returns -->Socket
	push	$SocketL
	call	malloc
	cmp	$0, a
	ja	8f
	SYSERR	"malloc"
8:
	.endm
#-----------------------------------------------
#	Constellation	attributes of constellation of nodes (mash or ring)
	ac = 0
	DS	Cn.debug, DebugL		# debug info
	DS	Cn.topo				# Constellation topology
		Cn.ring = 0
		Cn.mash = 1
	DS	Cn.first
	DS	Cn.nodes
	DS	Cn.div				# random node choise divisor (MAX_INT / nodes)
	DS	Cn.ssl
	DS	Cn.forwP
	ConstellationL = ac

	.macro	ConstellationA			# returns -->Constellation
	push	$ConstellationL
	call	malloc
	cmp	$0, a
	ja	8f
	SYSERR	"malloc"
8:
	.endm