head	1.2;
access;
symbols;
locks
	gtoal:1.2; strict;
comment	@# @;


1.2
date	2024.05.19.22.20.24;	author gtoal;	state Exp;
branches;
next	1.1;

1.1
date	2024.05.18.00.58.01;	author gtoal;	state Exp;
branches;
next	;


desc
@backup
@


1.2
log
@*** empty log message ***
@
text
@LANGUAGE := gram-v80X2
EXT := imp

# LANGUAGE := project-name      # replace with your own language to be compiled

REMAKE=-f Makefile-$(LANGUAGE)

# setting CC to gcc or clang explicitly should be OK.
CC=cc 

# Pick one:
#SAFEOPTS=-Ofast -DFAST   # for a factor of 3 speedup.
SAFEOPTS=-DSUPPLY_DEFAULT_WALK_AST -g -Wall         

# Pick one: (Note that two programs fail with runtime-checking options on, so those always use SAFEOPTS )
#OPTS=$(SAFEOPTS)
OPTS=-DSUPPLY_DEFAULT_WALK_AST -Wall -Wno-return-type -Wno-comment -fsanitize=undefined -fsanitize-undefined-trap-on-error  -fno-sanitize-recover=all -frecord-gcc-switches  -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow  -fstack-protector -O2  -ftrapv -grecord-gcc-switches  -ggdb3 # -fsanitize=address - always fails in getwc.

all: $(LANGUAGE:%=%) regen Makefile $(LANGUAGE:%=%.ng)  # mnemalyse
	make $(REMAKE) regression-$(LANGUAGE)
	echo All up to date.

# This builds the actual compiler.  The demo only outputs the compiler source
# but with variables converted into upper case as a demonstration.
# Your own code could be an actual compiler, or perhaps a translator
# from your language to C.
$(LANGUAGE:%=%): $(LANGUAGE:%=%.h) Makefile regexp-lexer.o flex.o uparse.o # mnemosyne.o
	$(CC) $(OPTS) -o $(LANGUAGE:%=%) uparse.o regexp-lexer.o flex.o # mnemosyne.o
	# can't use gdb with gzexe binaries
	# which gzexe && gzexe $(LANGUAGE:%=%) || exit 0


# This regenerates the skeleton compiler code (CST to AST conversion) from the grammar.
$(LANGUAGE:%=%-ast.h): regen
	./regen > $(LANGUAGE:%=%-ast.h)

# This regenerates the skeleton compiler code (CST to AST conversion) from the grammar.
$(LANGUAGE:%=%-comp.h): gencomp
	./gencomp > $(LANGUAGE:%=%-comp.h)

# This builds the tool to regenerate the skeleton compiler code from the grammar.
# It currently only builds the CST to AST conversion.
regen: regen.c $(LANGUAGE:%=%.h) parser.h flex.o Makefile
	$(CC) $(SAFEOPTS) -o regen -DGRAMMAR=\"$(LANGUAGE:%=%.h)\" regen.c flex.o

# This builds the tool to regenerate the skeleton compiler code from the grammar.
# It currently only builds the CST to AST conversion.
gencomp: gencomp.c $(LANGUAGE:%=%.h) parser.h flex.o Makefile
	$(CC) $(SAFEOPTS) -o gencomp -DGRAMMAR=\"$(LANGUAGE:%=%.h)\" gencomp.c flex.o

# This is a backup of the grammar extracted from the grammar tables.
# Only the basic rules are saved. Comments and some grammar extensions are dropped.
# It may be useful when making changes to the grammar after the compiler code is written.
$(LANGUAGE:%=%.ng): $(LANGUAGE:%=%-ast.h)
	sed -ne 's|\(.*\)//\\\\ \(.*\)|\2|gp' $(LANGUAGE:%=%-ast.h) > $(LANGUAGE:%=%.ng)

# This is the body of the parser.  It requires the grammar to have been converted to table form.
uparse.o: uparse.c uparse-main.c parser.h flex.h Makefile $(LANGUAGE:%=%.c) $(LANGUAGE:%=%-ast.h) $(LANGUAGE:%=%-comp.h) # $(LANGUAGE:%=%-indent.c)
	$(CC) $(OPTS) -DGRAMMAR=\"$(LANGUAGE:%=%.h)\" -DCOMPILER=\"$(LANGUAGE:%=%.c)\" -DCST2AST=\"$(LANGUAGE:%=%-ast.h)\" -Wno-unused-variable -c uparse.c 

# This converts the grammar to table form.
$(LANGUAGE:%=%.h): $(LANGUAGE:%=%.g) takeon Makefile
	./takeon $(LANGUAGE:%=%.g) > $(LANGUAGE:%=%.h) || mv $(LANGUAGE:%=%.h) $(LANGUAGE:%=%.h).FAILED

# This builds the utility which converts the grammar to table form.
# NOTE: -fsanitize=address causes erroneous trap when running takeon.  Do not use that option here.
takeon: takeon.c takeon-output.c takeon-checks.c flex.h Makefile flex.o
	$(CC) $(SAFEOPTS) -o takeon takeon.c flex.o

# This is a utility used in much of the code to support flex arrays, i.e. arrays
# which extend their allocated space as more elements are accessed.  It also
# supplies some checks on array bounds and unassigned variables.  These are
# relatively cheap to implement - the runtime of a program using flex arrays
# and checking is about 3 times that of the same program with static arrays
# and no checks.  Use the "-DFAST" option at the head of this file for a
# faster executable but only once the code is stable and ready for release testing.
flex.o: flex.c flex.h Makefile
	$(CC) $(SAFEOPTS) -c flex.c

# This is an internal regular expression matcher which has been modified
# to support Unicode characters.
regexp-lexer.o: regexp-lexer.c Makefile parser.h # tools/mnemosyne.h 
	$(CC) $(OPTS) -c regexp-lexer.c -Itools

# This is an old memory leak utility I used to use in the 80's - you can get
# equally good results nowadays by using valgrind instead.  It is off by default.
mnemosyne.o: tools/mnemosyne.c tools/mnemosyne.h Makefile
	$(CC) $(OPTS) -Wno-unused-variable -Wno-pointer-to-int-cast -c tools/mnemosyne.c -Itools

# The post-execution analyzer for mnemosyne (the Greek Goddess of memory)
mnemalyse: tools/mnemalyse.c tools/mnemosyne.h Makefile
	$(CC) $(OPTS) -o mnemalyse tools/mnemalyse.c -Itools

web:
	make $(REMAKE) clean
	cc -o grammar2html tools/grammar2html.c
	cc -o ctohtml tools/ctohtml.c
	./grammar2html $(LANGUAGE:%=%.g) > $(LANGUAGE:%=%.g.html)
	./ctohtml takeon.c > takeon.c.html
	./ctohtml uparse.c > uparse.c.html
	./ctohtml $(LANGUAGE:%=%.h) > $(LANGUAGE:%=%.h.html)
	./ctohtml regexp-lexer.c > regexp-lexer.c.html
	./ctohtml regexp-lexer.h > regexp-lexer.h.html
	./ctohtml flex.c > flex.c.html
	./ctohtml flex.h > flex.h.html
	./ctohtml parser.h > parser.h.html
	./ctohtml regen.c > regen.c.html
	./ctohtml gencomp.c > gencomp.c.html
	./ctohtml $(LANGUAGE:%=%-ast.h) > $(LANGUAGE:%=%-ast.h.html)
	./ctohtml $(LANGUAGE:%=%-comp.h) > $(LANGUAGE:%=%-comp.h.html)
	# ./ctohtml $(LANGUAGE:%=%-indent.c) > $(LANGUAGE:%=%-indent.c.html)
	rm -f grammar2html ctohtml

# Only for the author. These won't work for anyone else.
upload:
	make web
	tar -cvf $(LANGUAGE:%=%.tar) *.[cgh] *.ng Makefile *.sh README.html tools/mnem*.[ch] tools/grammar2html.c tools/ctohtml.c tests-$(LANGUAGE)/*.$(EXT) *.[chg].html
	make $(REMAKE) clean
	scp Makefile $(LANGUAGE:%=%.tar) gtoal@@gtoal.com:gtoal.com/languages/$(LANGUAGE:%=%)/new-unicode-parser/
	ssh gtoal@@gtoal.com "( cd gtoal.com/languages/$(LANGUAGE:%=%)/new-unicode-parser ; make $(REMAKE) clean )"
	ssh gtoal@@gtoal.com "( cd gtoal.com/languages/$(LANGUAGE:%=%)/new-unicode-parser ; tar -xvf $(LANGUAGE:%=%.tar) )"

# Parse test files
regression-$(LANGUAGE):
	find tests-$(LANGUAGE) -name '*.$(EXT)' > REGRESSION-TESTS-$(LANGUAGE).sh
	# Oops. Does require ecce. Need to avoid that. Use sed instead?
	ecce REGRESSION-TESTS-$(LANGUAGE).sh -command "(rli=./$(LANGUAGE:%=%) =m)0m-0i.#!/bin/sh.b;%c"
	chmod +x REGRESSION-TESTS-$(LANGUAGE).sh
	./REGRESSION-TESTS-$(LANGUAGE).sh -x

# Mr Sheen.
clean:
	rm -f *~ *.o $(LANGUAGE:%=%) mnemalyse takeon regen gencomp ctohtml grammar2html \#*\# [a-z]*.[chg].html $(LANGUAGE)-ast.h $(LANGUAGE)-comp.h

tidy:
	rm -f *~ *.o $(LANGUAGE:%=%) mnemalyse takeon regen gencomp ctohtml grammar2html \#*\# 
@


1.1
log
@Initial revision
@
text
@d2 2
d6 2
d20 1
d58 1
a58 1
uparse.o: uparse.c parser.h flex.h Makefile $(LANGUAGE:%=%.c) $(LANGUAGE:%=%-ast.h) $(LANGUAGE:%=%-comp.h) # $(LANGUAGE:%=%-indent.c)
d95 1
a95 1
	make clean
d117 2
a118 2
	tar -cvf $(LANGUAGE:%=%.tar) *.[cgh] *.ng Makefile *.sh README.html tools/mnem*.[ch] tools/grammar2html.c tools/ctohtml.c tests/*.a60 *.[chg].html
	make clean
d120 1
a120 1
	ssh gtoal@@gtoal.com "( cd gtoal.com/languages/$(LANGUAGE:%=%)/new-unicode-parser ; make clean )"
d123 3
a125 3
# Parse a lot of Algol source files with the ALGOL 60 demonstration parser.
regression:
	find tests -name '*.a60' > REGRESSION-TESTS.sh
d127 3
a129 3
	ecce REGRESSION-TESTS.sh -command "(rli=./$(LANGUAGE:%=%) =m)0m-0i.#!/bin/sh.b;%c"
	chmod +x REGRESSION-TESTS.sh
	./REGRESSION-TESTS.sh -x
d133 1
a133 1
	rm -f *~ *.o $(LANGUAGE:%=%) mnemalyse takeon regen gencomp ctohtml grammar2html \#*\# [a-z]*.[chg].html
@