libk  Check-in [f9bf0d662b]

; register order for syscall convention
%define sys.reg.n 6
%define sys.reg.ret eax
%define sys.reg.0 eax
%define sys.reg.1 ebx
%define sys.reg.2 ecx
%define sys.reg.3 edx
%define sys.reg.4 esi
%define sys.reg.5 edi

%define sys.call int 0x80

; syscall ops
%define sys.call syscall

; register order for syscall convention
%define sys.reg.n 7
%define sys.reg.ret rax
%define sys.reg.err rbx
%define sys.reg.0 rax
%define sys.reg.1 rdi
%define sys.reg.2 rsi
%define sys.reg.3 rdx
%define sys.reg.4 r10
%define sys.reg.5 r8
%define sys.reg.6 r9

; syscall ops
%define sys.call syscall

; register order for syscall convention
%define sys.reg.n 7
%define sys.reg.ret rax

%define sys.reg.0 rax
%define sys.reg.1 rdi
%define sys.reg.2 rsi
%define sys.reg.3 rdx
%define sys.reg.4 r10
%define sys.reg.5 r8
%define sys.reg.6 r9

has gcc && _cc=gcc # prefer gcc
cc=${cc:-$_cc}
has m4 && _m4=m4
m4=${m4:-$_m4}
has nasm && asm=nasm
has yasm && asm=yasm # prefer yasm
export gen=${gen:-gen}
library=${libkind:-static} # {static|shared|both}


doc=${doc:-yes}
export doc_html=${doc_html:-yes}
export doc_pdf=${doc_pdf:-yes}
export doc_man=${doc_man:-yes}

case $library in
................................................................................
macro_compile_env="-Datom_target_arch=$arch -Datom_target_os=$os -Dtarget_posix=$posix -Dtarget_unix=$unix"

if test "$bits" != ""; then
	macro_compile_env="$macro_compile_env -Datom_target_bits=$bits"
fi


































comp_mac() { $m4 $macro_compile_env -I "$gen" $3 "$1" > "$2"; }

















comp_asm() { $asm "-f$bin_fmt" -i "$gen" $1 -o "$2"; }

comp_co()  { comp_c $1 $2 "-c -fPIC"; }
comp_c(){
	src=$1
	output=$2
	flags=$3






	$cc $src $3 -std=c11 -isystem "$out" -isystem "$gen" -isystem "arch/" -nostdlib "-L$out" "-o$output"
}

scan() { find "$1" -name "$2"; }

say "commencing libk build $build at $(timestamp)"
set -x

# get type data
mkdir -p $gen
$cc -D_emit_m4_include arch/typesize.c -o $gen/typesize 
$gen/typesize > gen/typesize.m

# generate syscall tables
................................................................................

if test "$doc" = "yes"; then
	global/build-manpage.sh libk.md
	for mod in ${modules[@]}; do
		for doc in $(scan $mod '*.md'); do
			base="$(basename $doc)"
			stem="${base%%.md}"
			global/build-manpage.sh "$doc"
		done
	done
fi

# third pass: compile sources and save the
# resulting object files to $out, tracking
# which is a runtime or function unit. exe's
................................................................................
done

# fourth pass: link the libraries that are
# configured to be built

if test $build_static_library == yes; then
	for obj in ${fn_objects[@]} ${rt_objects[@]} ${data_objects[@]}; do
		ar rc $out/libk.a $obj
	done
	ranlib $out/libk.a
fi

if test $build_shared_library == yes; then
	ld -r ${rt_objects[@]} -o $out/boot.o
	ld -shared ${fn_objects[@]} -o $out/libk.so
fi

# fifth pass: compile the executable tools
# against the libraries created in pass 5

for mod in ${modules[@]}; do
	for exe in $(scan $mod '*.exe.c'); do

has gcc && _cc=gcc # prefer gcc
cc=${cc:-$_cc}
has m4 && _m4=m4
m4=${m4:-$_m4}
has nasm && asm=nasm
has yasm && asm=yasm # prefer yasm
export gen=${gen:-gen}
library=${library:-static} # {static|shared|both}
export verbose=${verbose:-quiet} # {no|quiet|loud}

doc=${doc:-yes}
export doc_html=${doc_html:-yes}
export doc_pdf=${doc_pdf:-yes}
export doc_man=${doc_man:-yes}

case $library in
................................................................................
macro_compile_env="-Datom_target_arch=$arch -Datom_target_os=$os -Dtarget_posix=$posix -Dtarget_unix=$unix"

if test "$bits" != ""; then
	macro_compile_env="$macro_compile_env -Datom_target_bits=$bits"
fi


if test "$COLORTERM" != ""; then
	announce() {
		test "$verbose" = "silent" && return
		color="$1" cmd="$2"; shift 2;
		printf " → [38;5;$color;1m$cmd"
		for a in "$@"; do
			if test ${a:0:1} = "-"; then
				printf " $a";
			else
				printf " $a";
			fi
		done
		echo
	}
else
	announce() { shift; echo " --> " $@; }
fi

# the following function is called to report a command invocation
# the person compiling the library. the first argument should be
# an ansi format string; this is used to color-code the tool being
# launched and thus should be different for each one.
report() { announce $@; shift; $@; }
comp_mac() {
	local src=$1
	local output=$2
	local flags=$3
	if test -e "$output"; then
		if test ! "$output" -ot "$src"; then
			return
		fi
	fi
	         $m4 $macro_compile_env -I "$gen" $flags "$src"  > "$output"
	announce 207 $m4 $macro_compile_env -I "$gen" $flags "$src" \> "$output"
	# yes, this is incredibly stupid. if you know a better way, feel
	# free to submit a fix. the problem is there's no way to pass >
	# to report in such a way that it'll do the right thing, and if
	# you just write > it redirects *report's* output, instead of
	# m4's. piece of shit that it is, m4 doesn't have any way to emit
	# output into a fille - stdout only apparently. tl;dr i hate bash.
}
comp_asm() {
	local src=$1
	local output=$2
	local flags=$3
	if test -e "$output"; then
		if test ! "$output" -ot "$src"; then
			return
		fi
	fi
	report 198 $asm $flags "-f$bin_fmt" -i "$gen" "$src" -o "$output";
}
comp_co()  { comp_c $1 $2 "-c -fPIC"; }
comp_c(){
	local src=$1
	local output=$2
	local flags=$3
	if test -e "$output"; then
		if test ! "$output" -ot "$src"; then
			return
		fi
	fi
	# only rebuild the file if the source file is newer
	report 213 $cc $src $3 -std=c11 -isystem "$out" -isystem "$gen" -isystem "arch/" -nostdlib "-L$out" "-o$output"
}

scan() { find "$1" -name "$2"; }

say "commencing libk build $build at $(timestamp)"
# set -x

# get type data
mkdir -p $gen
$cc -D_emit_m4_include arch/typesize.c -o $gen/typesize 
$gen/typesize > gen/typesize.m

# generate syscall tables
................................................................................

if test "$doc" = "yes"; then
	global/build-manpage.sh libk.md
	for mod in ${modules[@]}; do
		for doc in $(scan $mod '*.md'); do
			base="$(basename $doc)"
			stem="${base%%.md}"
			report 177 global/build-manpage.sh "$doc"
		done
	done
fi

# third pass: compile sources and save the
# resulting object files to $out, tracking
# which is a runtime or function unit. exe's
................................................................................
done

# fourth pass: link the libraries that are
# configured to be built

if test $build_static_library == yes; then
	for obj in ${fn_objects[@]} ${rt_objects[@]} ${data_objects[@]}; do
		report 120 ar rc $out/libk.a $obj
	done
	report 105 ranlib $out/libk.a
fi

if test $build_shared_library == yes; then
	report 216 ld -r ${rt_objects[@]} -o $out/boot.o
	report 216 ld -shared ${fn_objects[@]} -o $out/libk.so
fi

# fifth pass: compile the executable tools
# against the libraries created in pass 5

for mod in ${modules[@]}; do
	for exe in $(scan $mod '*.exe.c'); do

echo >>"$fmt" ".SH DESCRIPTION"

tail -n+$(expr $descline + $offset) "$file"  | cmark -t man >> "$fmt"

test "$doc_html" = "yes" && {
	mkdir -p "$htmldest"
	groff -Thtml -Kutf8 -m man "$fmt" > "$html"

	say "wrote html page for $stem to $html"
}

test "$doc_pdf" = "yes" && {
	mkdir -p "$pdfdest"
	groff -Tpdf  -Kutf8 -m man "$fmt" > "$pdf"

	say "wrote pdf for $stem to $pdf"
}

test "$doc_man" = "yes" && {
	mkdir -p "$mandest"

	if has gzip; then
		man="$man.gz"
		gzip -c -f "$fmt" > "$man"
	else
		mv "$fmt" "$man"
	fi


	say "wrote manpage for $stem to $man"
}

echo >>"$fmt" ".SH DESCRIPTION"

tail -n+$(expr $descline + $offset) "$file"  | cmark -t man >> "$fmt"

test "$doc_html" = "yes" && {
	mkdir -p "$htmldest"
	groff -Thtml -Kutf8 -m man "$fmt" > "$html"
	test "$verbose" != "loud" ||
	say "wrote html page for $stem to $html"
}

test "$doc_pdf" = "yes" && {
	mkdir -p "$pdfdest"
	groff -Tpdf  -Kutf8 -m man "$fmt" > "$pdf"
	test "$verbose" != "loud" ||
	say "wrote pdf for $stem to $pdf"
}

test "$doc_man" = "yes" && {
	mkdir -p "$mandest"

	if has gzip; then
		man="$man.gz"
		gzip -c -f "$fmt" > "$man"
	else
		mv "$fmt" "$man"
	fi

	test "$verbose" != "loud" ||
	say "wrote manpage for $stem to $man"
}

	%assign i 0
	%rep 6
		handle_arg i
		%assign i i+1
	%endrep

	; valency >= 7. this is not valid, so
	; we set our return value to 0 and the
	; error number to its maximum value in
	; order to indicate that the syscall
	; was invalid
	mov qword [rbx], 0
	mov qword [r12], -1
	ret

	; we have a valency match - perform the
	; requested syscall already store in rax
	.perform_call: sys.call





	
	; move our return values into place and
	; return to the caller (which should
	; always be k_platform_syscall, btw)
	mov [rbx], sys.reg.ret








	mov [r12], sys.reg.err
	ret

	%assign i 0
	%rep 6
		handle_arg i
		%assign i i+1
	%endrep

	; valency >= 7. this is not valid, so
	; we set our return value to -1 and the
	; error number to its maximum value in
	; order to indicate that the syscall
	; was invalid
	mov qword [rbx], -1
	mov qword [r12], -1
	ret

	; we have a valency match - perform the
	; requested syscall already store in rax
	.perform_call: sys.call

	; check for an error - on x86, error is
	; returned as a negative value in %rax
	test sys.reg.ret, sys.reg.ret
	js .error ; jump if sign flag set
	
	; move our return values into place and
	; return to the caller (which should
	; always be k_platform_syscall, btw)
	mov       [rbx], sys.reg.ret
	mov qword [r12], 0 ; no error
	ret

	; an error was returned - we need to set
	; the errno to its positive equivalent,
	; and store -1 in the return variable
	.error: neg sys.reg.ret
	        mov qword [rbx], -1
			mov       [r12], sys.reg.ret
			ret

 * `cc=<autodetect> {executable}` - the compiler to compile C sources with
 * `m4=<autodetect> {executable}` - the m4 binary to compile the macro sources with
 * `asm=<autodetect> {executable}` - the assembler to assemble the assembly listings with. it must take Intel-syntax input and handle nasm-style macros. only `yasm` and `nasm` are likely to be viable.
 * `doc=yes {yes|no}` - whether to typeset the documentation (very slow with all three formats set to "yes")
 * `doc_html=yes {yes|no}` - enable or disable html output of the documentation
 * `doc_pdf=yes {yes|no}` - enable or disable pdf output of the documentation
 * `doc_man=yes {yes|no}` - enable or disable manpage output of the documentation


two other shell scripts complete the build system:
 * `install.sh` - installs compiled libraries, objects, documentation, and headers into the appropriate directories.

# design principles

there are four overriding principles that guide the design of libk.

 * `cc=<autodetect> {executable}` - the compiler to compile C sources with
 * `m4=<autodetect> {executable}` - the m4 binary to compile the macro sources with
 * `asm=<autodetect> {executable}` - the assembler to assemble the assembly listings with. it must take Intel-syntax input and handle nasm-style macros. only `yasm` and `nasm` are likely to be viable.
 * `doc=yes {yes|no}` - whether to typeset the documentation (very slow with all three formats set to "yes")
 * `doc_html=yes {yes|no}` - enable or disable html output of the documentation
 * `doc_pdf=yes {yes|no}` - enable or disable pdf output of the documentation
 * `doc_man=yes {yes|no}` - enable or disable manpage output of the documentation
 * `verbose=quiet {silent|quiet|loud}` - control level of verbosity. `silent` silences most output.

two other shell scripts complete the build system:
 * `install.sh` - installs compiled libraries, objects, documentation, and headers into the appropriate directories.

# design principles

there are four overriding principles that guide the design of libk.