d0p1/ack
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Import aap@github's B compiler.

Browse source
This commit is contained in:
David Given 2016-11-27 11:37:25 +01:00
parent 4f446467c8
commit a69045c0e4
16 changed files with 2299 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
lang/b/distr/LICENSE Normal file
View file

@ -0,0 +1,22 @@
The MIT License (MIT)
Copyright (c) 2013-2016 aap
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

15
lang/b/distr/Makefile Normal file
View file

@ -0,0 +1,15 @@
CFLAGS=-Wall -Wextra
b: b0.o b1.o
cc b0.o b1.o -o b
b0.o: b0.c b.h
b1.o: b1.c b.h
libs:
./abc -c brt.s lib.b
install: b abc
cp abc $(HOME)/bin
%.o: %.s
as --32 $^ -o $@

53
lang/b/distr/README.md Normal file
View file

@ -0,0 +1,53 @@
A B Compiler
============
abc is a compiler for the [B Programming Language](http://en.wikipedia.org/wiki/B_(programming_language)) that targets x86\_32 processors. It is currently tested under Linux but should work (or at least be easily ported) to other UNIX-like systems. The code is based on [an early C compiler (last1120c)](http://www.cs.bell-labs.com/who/dmr/primevalC.html) by Dennis Ritchie.
Documentation
-------------
* [The Programming Language B](http://9p.io/cm/cs/who/dmr/bintro.html)
* [B Reference by Ken Thompson](http://9p.io/cm/cs/who/dmr/kbman.html) describes a presumably earlier variant of B, which is slightly different from the one described above. The compiler cannot understand it, but I plan to implement a compatibility mode (the differences are minor).
Implementation
--------------
Since B was first implemented for machines with word addressing, some hacking was required to make it work on the byte addressed x86. Addresses filled in by the linker are always byte addresses, so pointers to these addresses are collectively stored at the end of the .data section and are then converted to word addresses at runtime, before main() is called.
The generated assembly is *very* inefficient, not even constant expressions are reduced at compile time. Also I/O is currently not buffered.
How to use
----------
The installation requires a little configuration:
'abc' is a frontend for the actual compiler which feels somewhat like gcc (it also handles assembling and linking). Before you can use it, set it's BDIR variable to the directory of the B compiler.
In the Makefile, change the directory of the 'install' rule to wherever you want your 'abc' file to reside.
Then type
make install libs
which compiles the compiler 'b', installs the 'abc' frontend and compiles the B runtime and library (brt.o and lib.o).
To compile and link a B program, simply type
abc -o outfile file1.b [file2.b ...]
If you want to compile and assemble only:
abc -c file1.b [file2.b ...]
or generate only the assembly:
abc -S file1.b [file2.b ...]
Examples of B programs are in the 'examples' directory, they are mostly from Brian Kernighan's tutorial.
Bugs
----
Since command line parameters aren't passed word-aligned, B can't handle them easily. brt.s copies the strings to another location and aligns them, the space is not dynamically allocated however and only 256 bytes are available by default.
The library is incomplete but has some of the most important functions.
I have only tested the compiler on an x86\_64 gentoo system.

95
lang/b/distr/abc Executable file
View file

@ -0,0 +1,95 @@
#!/bin/sh
BDIR="$HOME/abc"
objs="$BDIR/brt.o $BDIR/lib.o"
BC="$BDIR/b"
# compile in.b [out.s]
compile() {
if [ "${1##*.}" != "b" ]; then
echo "Error: can only compile b files" >&2
exit 1
fi
cout=$2
[ "$cout" != "" ] || cout=${1%b}s
tmp1=`mktemp`; tmp2=`mktemp`
$BC $1 $tmp2 $tmp1
retval=$?
cat $tmp1 $tmp2 > $cout
rm $tmp1 $tmp2
[ $retval -eq 0 ] || rm $cout && return $retval
echo $cout
return $retval
}
# assemble in.{sb} [out.o]
assemble() {
atmp=""
ain=$1
aout=$2;
if [ "${1##*.}" = "b" ]; then
[ "$aout" != "" ] || aout=${ain%b}o
ain=`mktemp --suffix=.s`
compile $1 $ain >/dev/null || return 1
atmp="foo"
elif [ "${1##*.}" = "s" ]; then
[ "$aout" != "" ] || aout=${ain%s}o
else
echo "Error: can only compile b and s files" >&2
exit 1
fi
as --32 -g $ain -o $aout
[ "$atmp" != "" ] && rm $ain
echo $aout
}
out=""
action="link"
while getopts "o:Sc" o
do case "$o" in
o) out="$OPTARG";;
S) action=compile;;
c) action=assemble;;
esac
done
shift $(($OPTIND - 1))
# ignore -o option if more than one file given and not linking objs
if [ $# -gt 1 ]; then
if [ "$action" != "link" ]; then
out=""
fi
fi
[ $# -ne 1 ] && havelist=yes
tmpobjs=""
for i in $@; do
if [ "$action" != "link" ]; then
[ "$havelist" = "yes" ] && echo $i:
$action $i $out >/dev/null
[ $? -eq 0 ] || break=1
else
if [ "${i##*.}" = "o" ]; then
objs="$objs $i"
else
[ "$havelist" = "yes" ] && echo $i:
ltmp=`mktemp --suffix=.o`
tmpobjs="$tmpobjs $ltmp"
assemble $i $ltmp >/dev/null
[ $? -eq 0 ] || break=1
fi
fi
done
if [ $break ]; then
[ "$tmpobjs" = "" ] || rm $tmpobjs
echo "Error" >&2
exit 1
fi
if [ "$action" = "link" ]; then
if [ "$out" = "" ]; then
out="-o a.out"
else
out="-o $out"
fi
ld -m elf_i386 -T $BDIR/link.ld $out $objs $tmpobjs
rm $tmpobjs
fi

164
lang/b/distr/b.h Normal file
View file

@ -0,0 +1,164 @@
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#define NCPS 8 /* chars per symbol */
#define NCPW 4 /* chars per word */
#define ALIGN 4 /* Passed directly to the assembler's .align */
#define HSHSIZ 400 /* hash table size */
#define SWSIZ 230 /* switch table size */
#define CMSIZ 40 /* symbol stack size */
#define SSIZE 20 /* operator and precedence stack size */
#define OSSIZ 300*8 /* space for expression tree */
#define EOS 04 /* end of string marker */
/*
* Holds a B symbol.
* class is one of the storage classes below.
* offset is used depending on class.
*/
struct hshtab {
int class;
int offset;
int dim;
struct hshtab *next;
char name[NCPS+1];
};
struct tnode {
int op;
int value;
struct tnode *tr1;
struct tnode *tr2;
};
struct swtab {
int swlab;
int swval;
};
struct hshtab hshtab[HSHSIZ];
int hshused;
int eof;
int peekc;
char ctab[128];
struct hshtab *bsym;
struct hshtab *paraml, *parame;
int cval;
int isn;
char symbuf[NCPS+1];
FILE *sbufp;
int stack;
struct tnode **cp;
int *space;
int ospace[OSSIZ];
int retlab;
int nerror;
struct swtab swtab[SWSIZ];
struct swtab *swp;
int deflab;
extern int contlab;
extern int brklab;
extern int opdope[];
extern int line;
extern int peeksym, peeksym2;
void error(char *s, ...);
void printtoken(int tok, FILE *out);
struct tnode * block(int op, int value, struct tnode *tr1, struct tnode *tr2);
void rcexpr(struct tnode *tr);
void cbranch(struct tnode *t, int lab, int val);
void jump(int lab);
void label(int l);
#define EOFC 0
#define SEMI 1
#define LBRACE 2
#define RBRACE 3
#define LBRACK 4
#define RBRACK 5
#define LPARN 6
#define RPARN 7
#define COLON 8
#define COMMA 9
#define MCALL 15
#define CALL 16
#define DECBEF 17
#define INCBEF 18
#define DECAFT 19
#define INCAFT 20
#define EXCLA 21
#define NEG 22
#define AMPER 23
#define STAR 24
#define QUEST 25
#define PLUS 30
#define MINUS 31
#define MOD 32
#define TIMES 33
#define DIVIDE 34
#define OR 35
#define AND 36
#define LSHIFT 37
#define RSHIFT 38
#define EQUAL 39
#define NEQUAL 40
#define LESSEQ 41
#define LESS 42
#define GREATEQ 43
#define GREAT 44
#define ASSIGN 49
#define ASPLUS 50
#define ASMINUS 51
#define ASMOD 52
#define ASTIMES 53
#define ASDIV 54
#define ASOR 55
#define ASAND 56
#define ASLSH 57
#define ASRSH 58
#define ASEQUAL 59
#define ASNEQL 60
#define ASLEQ 61
#define ASLESS 62
#define ASGTQ 63
#define ASGREAT 64
#define CON 65
#define STRING 66
#define NAME 67
#define KEYW 68
#define SQUOTE 121
#define DQUOTE 122
#define NEWLN 123
#define SPACE 124
#define LETTER 125
#define DIGIT 126
#define UNKN 127
#define SEOF 200
/* storage classes */
#define AUTO 1
#define EXTERN 2
#define INTERN 3
#define ARG 4
#define KEYWF 5
/* keywords */
#define CASE 3
#define IF 4
#define ELSE 5
#define WHILE 6
#define SWITCH 7
#define GOTO 8
#define RETURN 9
#define DEFAULT 10
#define BREAK 11

1277
lang/b/distr/b0.c Normal file
View file

File diff suppressed because it is too large Load diff

334
lang/b/distr/b1.c Normal file
View file

@ -0,0 +1,334 @@
#include "b.h"
/*
* Code generation (x86 assembly)
*/
void
push(void)
{
printf("\tpush\t%%eax\n");
}
void
pop(char *s)
{
printf("\tpop\t%%%s\n", s);
}
void
binary(struct tnode *tr)
{
rcexpr(tr->tr1);
push();
rcexpr(tr->tr2);
}
int
pushargs(struct tnode *tr)
{
int stk;
if (tr == NULL)
return 0;
if (tr->op == COMMA) {
rcexpr(tr->tr2);
push();
stk = pushargs(tr->tr1);
return stk+NCPW;
}
rcexpr(tr);
push();
return NCPW;
}
void
lvalexp(struct tnode *tr)
{
struct hshtab *bs;
char memloc[64];
switch (tr->op) {
case DECBEF:
case INCBEF:
case DECAFT:
case INCAFT:
if (tr->tr1->op == STAR) {
rcexpr(tr->tr1->tr1);
printf("\tmov\t%%eax,%%ebx\n");
sprintf(memloc,"(,%%ebx,4)");
} else { /* NAME, checked in "build" */
bs = (struct hshtab *) tr->tr1->tr1;
if (bs->class == EXTERN)
sprintf(memloc,"_%s", bs->name);
else if (bs->class == AUTO)
sprintf(memloc,"%d(%%ebp)", bs->offset);
else
goto classerror;
}
if (tr->op == DECBEF || tr->op == INCBEF) {
printf("\t%s\t%s\n", tr->op == DECBEF ? "decl" : "incl",
memloc);
printf("\tmov\t%s,%%eax\n", memloc);
} else {
printf("\tmov\t%s,%%eax\n", memloc);
printf("\t%s\t%s\n", tr->op == DECAFT ? "decl" : "incl",
memloc);
}
return;
case ASSIGN:
rcexpr(tr->tr2);
if (tr->tr1->op == STAR) {
push();
rcexpr(tr->tr1->tr1);
pop("ebx");
printf("\tmov\t%%ebx,(,%%eax,4)\n");
} else { /* NAME */
bs = (struct hshtab *) tr->tr1->tr1;
if (bs->class == EXTERN)
printf("\tmov\t%%eax,_%s\n", bs->name);
else if (bs->class == AUTO)
printf("\tmov\t%%eax,%d(%%ebp)\n", bs->offset);
else
goto classerror;
}
return;
case ASPLUS:
case ASMINUS:
case ASMOD:
case ASTIMES:
case ASDIV:
case ASOR:
case ASAND:
case ASLSH:
case ASRSH:
case ASEQUAL:
case ASNEQL:
case ASLEQ:
case ASLESS:
case ASGTQ:
case ASGREAT:
tr->op -= ASPLUS-PLUS;
rcexpr(block(ASSIGN,0,tr->tr1,tr));
return;
}
classerror:
error("Storage class");
}
void
rcexpr(struct tnode *tr)
{
int o1, o2;
int stk;
struct hshtab *bs;
if (tr == NULL)
return;
if (opdope[tr->op]&02) {
lvalexp(tr);
return;
}
switch (tr->op) {
case CON:
printf("\tmov\t$%d,%%eax\n", tr->value);
return;
case STRING:
printf("\tmov\t$L%d,%%eax\n", tr->value);
printf("\tshr\t$2,%%eax\n");
return;
case NAME: /* only rvalue */
bs = (struct hshtab *) tr->tr1;
if (bs->class == EXTERN)
printf("\tmov\t_%s,%%eax\n", bs->name);
else if (bs->class == AUTO)
printf("\tmov\t%d(%%ebp),%%eax\n", bs->offset);
else
goto classerror;
return;
case CALL:
stk = pushargs(tr->tr2);
rcexpr(tr->tr1);
printf("\tshl\t$2,%%eax\n");
printf("\tcall\t*%%eax\n");
if (stk)
printf("\tadd\t$%d,%%esp\n",stk);
return;
case AMPER:
bs = (struct hshtab *) tr->tr1->tr1;
if (bs->class == EXTERN) {
printf("\tmov\t$_%s,%%eax\n", bs->name);
printf("\tshr\t$2,%%eax\n");
} else if (bs->class == AUTO) {
printf("\tlea\t%d(%%ebp),%%eax\n", bs->offset);
printf("\tshr\t$2,%%eax\n");
} else
goto classerror;
return;
case STAR: /* only rvalue */
rcexpr(tr->tr1);
printf("\tmov\t(,%%eax,4),%%eax\n");
return;
case PLUS:
binary(tr);
pop("ebx");
printf("\tadd\t%%ebx,%%eax\n");
return;
case MINUS:
binary(tr);
printf("\tmov\t%%eax,%%ebx\n");
pop("eax");
printf("\tsub\t%%ebx,%%eax\n");
return;
case TIMES:
binary(tr);
pop("ebx");
printf("\tmul\t%%ebx\n");
return;
case DIVIDE:
binary(tr);
printf("\tmov\t%%eax,%%ebx\n");
pop("eax");
printf("\txor\t%%edx,%%edx\n");
printf("\tdiv\t%%ebx\n");
return;
case MOD:
binary(tr);
printf("\tmov\t%%eax,%%ebx\n");
pop("eax");
printf("\txor\t%%edx,%%edx\n");
printf("\tdiv\t%%ebx\n");
printf("\tmov\t%%edx,%%eax\n");
return;
case AND:
binary(tr);
pop("ebx");
printf("\tand\t%%ebx,%%eax\n");
return;
case OR:
binary(tr);
pop("ebx");
printf("\tor\t%%ebx,%%eax\n");
return;
case LSHIFT:
binary(tr);
printf("\tmov\t%%eax,%%ecx\n");
pop("eax");
printf("\tshl\t%%cl,%%eax\n");
return;
case RSHIFT:
binary(tr);
printf("\tmov\t%%eax,%%ecx\n");
pop("eax");
printf("\tshr\t%%cl,%%eax\n");
return;
case EQUAL:
case NEQUAL:
case LESS:
case LESSEQ:
case GREAT:
case GREATEQ:
binary(tr);
pop("ebx");
printf("\tcmp\t%%eax,%%ebx\n");
switch (tr->op) {
case EQUAL:
printf("\tsete\t%%al\n");
break;
case NEQUAL:
printf("\tsetne\t%%al\n");
break;
case LESS:
printf("\tsetl\t%%al\n");
break;
case LESSEQ:
printf("\tsetle\t%%al\n");
break;
case GREAT:
printf("\tsetg\t%%al\n");
break;
case GREATEQ:
printf("\tsetge\t%%al\n");
break;
}
printf("\tmovzb\t%%al,%%eax\n");
return;
case EXCLA:
rcexpr(tr->tr1);
printf("\ttest\t%%eax,%%eax\n");
printf("\tsete\t%%al\n");
printf("\tmovzb\t%%al,%%eax\n");
return;
case NEG:
rcexpr(tr->tr1);
printf("\tneg\t%%eax\n");
return;
case QUEST:
cbranch(tr->tr1, o1=isn++, 0);
rcexpr(tr->tr2->tr1);
jump(o2 = isn++);
label(o1);
rcexpr(tr->tr2->tr2);
label(o2);
return;
default:
error("Can't print tree (op: %d)", tr->op);
}
classerror:
error("Storage class");
}
/* Prints the tree in RPN, for debugging */
/*
void
rcexpr(struct tnode *tr)
{
struct hshtab *bs;
if (tr == NULL)
printf("(NULL) ");
else if (tr->op == CON)
printf("%d ", tr->value);
else if (tr->op == STRING)
printf("s(L%d) ", tr->value);
else if (tr->op == NAME) {
bs = (struct hshtab *)tr->tr1;
if (bs->class == AUTO)
printf("%s(%d) ", bs->name, bs->offset);
else
printf("%s ", bs->name);
} else {
rcexpr(tr->tr1);
if (opdope[tr->op]&01)
rcexpr(tr->tr2);
printtoken(tr->op, stdout);
}
}
*/

151
lang/b/distr/brt.s Normal file
View file

@ -0,0 +1,151 @@
.globl _argv
.data
.align 4
.comm argstr,256,4
_argv: .long 0
.text
.globl start
start:
# clear bss (could be done better)
# is it actually necessary?
mov $__bss,%eax
1:
movb $0,(%eax)
inc %eax
cmp $__ebss,%eax
jbe 1b
# copy command line args (can't use them directly, not aligned)
mov %esp,%eax
shr $2,%eax
mov %eax,_argv
mov (%esp),%ecx # number of arguments
mov $argstr,%edi
1:
mov (%esp,%ecx,4),%esi
mov %edi,%eax
shr $2,%eax
mov %eax,(%esp,%ecx,4)
call cpystr
loop 1b
call bsymbs
mov _main,%eax
shl $2,%eax
call *%eax
mov %eax,%ebx
mov $1,%eax
int $0x80
# copy string from esi to edi and convert '\0' to B's '*e', align edi
cpystr:
mov (%esi),%al
test %al,%al
jz 1f
mov %al,(%edi)
inc %edi
inc %esi
jmp cpystr
1:
movb $04,(%edi)
inc %edi
add $3,%edi
and $~3,%edi
ret
# shift addresses filled in by the linker 2 bits to the right
# so B only ever sees word addresses
bsymbs:
mov $__bsymb,%eax
1:
cmp $__ebsymb,%eax
jge 1f
mov (%eax),%ebx
mov (%ebx),%ecx
shr $2,%ecx
mov %ecx,(%ebx)
add $4,%eax
jmp 1b
1:
ret
.globl retrn
retrn:
mov %ebp,%esp
pop %ebp
ret
# handle switch table:
# eax has the value, ebx the address of the switch table
.globl bswitch
bswitch:
xor %ecx,%ecx
1:
mov (%ebx,%ecx,8),%edx
mov 4(%ebx,%ecx,8),%edi
test %edi,%edi
jz 1f # default (last in table)
cmp %eax,%edx
je 2f
inc %ecx
jmp 1b
1:
jmp *%edx
2:
jmp *%edi
#
# Library functions in assembly
#
.globl _exit
.data
.align 4
.section .bsymb; .long _exit; .data
_exit: .long 1f
.text
.align 4
1: mov $1,%eax
mov $0,%ebx
int $0x80
.globl _write
.data
.align 4
.section .bsymb; .long _write; .data
_write: .long 1f
.text
.align 4
1: mov 4(%esp),%ebx
mov 8(%esp),%ecx
shl $2,%ecx
mov 12(%esp),%edx
mov $4,%eax
int $0x80
ret
.globl _read
.data
.align 4
.section .bsymb; .long _read; .data
_read: .long 1f
.text
.align 4
1: mov 4(%esp),%ebx
mov 8(%esp),%ecx
shl $2,%ecx
mov 12(%esp),%edx
mov $3,%eax
int $0x80
ret
.globl _inv
.data
.align 4
.section .bsymb; .long _inv; .data
_inv: .long 1f
.text
.align 4
1: mov 4(%esp),%eax
not %eax
ret

7
lang/b/distr/examples/1_var.b Normal file
View file

@ -0,0 +1,7 @@
main() {
auto a, b, c, sum;
a = 1; b = 2; c = 3;
sum = a+b+c;
putnumb(sum);
}

9
lang/b/distr/examples/2_ext.b Normal file
View file

@ -0,0 +1,9 @@
main() {
extrn a, b, c;
putchar(a); putchar(b); putchar(c); putchar('!*n');
}
a 'hell';
b 'o, w';
c 'orld';

13
lang/b/distr/examples/3_fun.b Normal file
View file

@ -0,0 +1,13 @@
main() {
extrn a, b, c, d;
put2char(a,b);
put2char(c,d);
}
put2char(x,y) {
putchar(x);
putchar(y);
}
a 'hell'; b 'o, w'; c 'orld'; d '!*n';

7
lang/b/distr/examples/4_goto.b Normal file
View file

@ -0,0 +1,7 @@
main() {
auto c;
read:
c= getchar();
putchar(c);
if(c != '*n') goto read;
}

10
lang/b/distr/examples/5_while.b Normal file
View file

@ -0,0 +1,10 @@
main() {
auto c;
while (1) {
while ( (c=getchar()) != ' ')
if (putchar(c) == '*n') exit();
putchar( '*n' );
while ( (c=getchar()) == ' '); /* skip blanks */
if (putchar(c)=='*n') exit();
}
}

10
lang/b/distr/examples/printargs.b Normal file
View file

@ -0,0 +1,10 @@
main() {
extrn argv;
auto i;
i = 1;
printf("%d args:*n", argv[0]);
while (i <= argv[0])
printf("%s*n", argv[i++]);
return(0);
}

111
lang/b/distr/lib.b Normal file
View file

@ -0,0 +1,111 @@
char(s, n)
return((s[n/4]>>8*(n%4))&0377); /* s[n/4] */
lchar(s, n, char) {
auto i;
i = 8*(n%4);
char = (char&0377)<<i;
i = inv(0377<<i);
s[(n/4)*4] = s[n/4]&i | char;
}
putchar(char) {
auto c, i;
c = char;
i = 4;
while ((c&0377) != '*e' & (c&0377) != '*0' & i != 0) {
i--;
c =>> 8;
}
write(1, &char, 4-i);
return(char);
}
getchar() {
auto char;
char = 0;
read(1, &char, 1);
return(char);
}
printn(n,b) {
extrn putchar;
auto a;
if (a = n/b)
printn(a, b);
putchar(char("0123456789ABCDEF", n%b));
}
putnumb(n) {
printn(n,10);
putchar('*n');
}
putstr(s) {
auto c, i;
i = 0;
while ((c = char(s,i++)) != '*e')
putchar(c);
}
getstr(s) {
auto c, i;
while ((c = getchar()) != '*n')
lchar(s,i++,c);
lchar(s,i,'*e');
return(s);
}
printf(fmt, x1,x2,x3,x4,x5,x6,x7,x8,x9) {
extrn printn, char, putchar;
auto adx, x, c, i, j;
i = 0;
adx = &x1;
loop:
while((c=char(fmt,i++)) != '%') {
if(c == '*e')
return;
putchar(c);
}
x = *adx++;
switch (c = char(fmt,i++)) {
case 'd':
case 'o':
if(x < 0) {
x = -x;
putchar('-');
}
printn(x, c=='o'?8:10);
goto loop;
case 'x':
if(x < 0) {
x = -x;
putchar('-');
}
printn(x, 16);
goto loop;
case 'c':
putchar(x);
goto loop;
case 's':
j = 0;
while((c=char(x,j++)) != '*e')
putchar(c);
goto loop;
}
putchar('%');
i--;
adx--;
goto loop;
}

21
lang/b/distr/link.ld Normal file
View file

@ -0,0 +1,21 @@
OUTPUT_FORMAT("elf32-i386")
OUTPUT_ARCH(i386)
ENTRY(start)
SECTIONS
{
. = 0x400000;
.text : { *(.text) }
. = 0x8000000;
.data : {
*(.data)
__bsymb = .;
*(.bsymb)
__ebsymb = .;
}
. = ALIGN(16);
__bss = .;
.bss : { *(.bss) }
__ebss = .;
}