From 55b6a3f313670d2cb13847d1f1b04fe3e4b21d63 Mon Sep 17 00:00:00 2001 From: David Robillard Date: Thu, 8 Apr 2010 20:09:16 +0000 Subject: Tuplr -> Resp (RESource Processing). git-svn-id: http://svn.drobilla.net/resp/resp@252 ad02d1e2-f140-0410-9f75-f8b11f17cedd --- Makefile | 20 +- resp.dox | 1523 ++++++++++++++++++++++++++++++++++++++++++++++++++++ resp_highlight.py | 152 ++++++ src/c.cpp | 14 +- src/compile.cpp | 10 +- src/constrain.cpp | 10 +- src/cps.cpp | 34 +- src/gc.cpp | 10 +- src/lex.cpp | 10 +- src/lift.cpp | 10 +- src/llvm.cpp | 16 +- src/parse.cpp | 10 +- src/pprint.cpp | 10 +- src/repl.cpp | 10 +- src/resp.cpp | 149 +++++ src/resp.hpp | 727 +++++++++++++++++++++++++ src/resp_gc.cpp | 48 ++ src/tuplr.cpp | 149 ----- src/tuplr.hpp | 727 ------------------------- src/tuplr_gc.cpp | 48 -- src/unify.cpp | 10 +- test.sh | 14 +- test/ack.resp | 7 + test/ack.tpr | 7 - test/def.resp | 8 + test/def.tpr | 8 - test/fac.resp | 7 + test/fac.tpr | 7 - test/intro.resp | 148 +++++ test/intro.tpr | 148 ----- test/nest.resp | 6 + test/nest.tpr | 6 - test/poly.resp | 6 + test/poly.tpr | 6 - test/tup.resp | 6 + test/tup.tpr | 6 - tuplr.dox | 1523 ---------------------------------------------------- tuplr_highlight.py | 152 ------ 38 files changed, 2881 insertions(+), 2881 deletions(-) create mode 100644 resp.dox create mode 100755 resp_highlight.py create mode 100644 src/resp.cpp create mode 100644 src/resp.hpp create mode 100644 src/resp_gc.cpp delete mode 100644 src/tuplr.cpp delete mode 100644 src/tuplr.hpp delete mode 100644 src/tuplr_gc.cpp create mode 100644 test/ack.resp delete mode 100644 test/ack.tpr create mode 100644 test/def.resp delete mode 100644 test/def.tpr create mode 100644 test/fac.resp delete mode 100644 test/fac.tpr create mode 100644 test/intro.resp delete mode 100644 test/intro.tpr create mode 100644 test/nest.resp delete mode 100644 test/nest.tpr create mode 100644 test/poly.resp delete mode 100644 test/poly.tpr create mode 100644 test/tup.resp delete mode 100644 test/tup.tpr delete mode 100644 tuplr.dox delete mode 100755 tuplr_highlight.py diff --git a/Makefile b/Makefile index 0279d41..ad101f4 100644 --- a/Makefile +++ b/Makefile @@ -16,7 +16,7 @@ LDFLAGS=-rdynamic -lm -ldl #COMMON_FLAGS+=-fprofile-arcs -ftest-coverage #LDFLAGS+=-lgcov -all: builddir build/tuplr +all: builddir build/resp builddir: mkdir -p build @@ -33,26 +33,26 @@ OBJECTS = \ build/pprint.o \ build/repl.o \ build/tlsf.o \ - build/tuplr.o \ + build/resp.o \ build/unify.o \ - build/tuplr_gc.o + build/resp_gc.o LLVM_OBJECTS = build/llvm.o #LLVM_OBJECTS = -build/tuplr: $(OBJECTS) $(LLVM_OBJECTS) +build/resp: $(OBJECTS) $(LLVM_OBJECTS) g++ -o $@ $(OBJECTS) $(LLVM_OBJECTS) $(LDFLAGS) $(LLVM_LDFLAGS) -build/%.o: src/%.cpp src/tuplr.hpp +build/%.o: src/%.cpp src/resp.hpp g++ $(CXXFLAGS) -o $@ -c $< build/tlsf.o: src/tlsf.c src/tlsf.h gcc $(CFLAGS) -o $@ -c $< -build/llvm.o: src/llvm.cpp src/tuplr.hpp +build/llvm.o: src/llvm.cpp src/resp.hpp g++ $(CXXFLAGS) $(LLVM_CXXFLAGS) -o $@ -c src/llvm.cpp -build/%.so: src/%.cpp src/tuplr.hpp +build/%.so: src/%.cpp src/resp.hpp g++ -shared $(CXXFLAGS) -o $@ $^ clean: @@ -62,9 +62,9 @@ check: ./test.sh doc: - doxygen ./tuplr.dox + doxygen ./resp.dox install-support: install -d ~/.vim/indent ~/.vim/syntax - install -m 644 ./support/vim/indent/tuplr.vim ~/.vim/indent/tuplr.vim - install -m 644 ./support/vim/syntax/tuplr.vim ~/.vim/syntax/tuplr.vim + install -m 644 ./support/vim/indent/resp.vim ~/.vim/indent/resp.vim + install -m 644 ./support/vim/syntax/resp.vim ~/.vim/syntax/resp.vim diff --git a/resp.dox b/resp.dox new file mode 100644 index 0000000..11dae18 --- /dev/null +++ b/resp.dox @@ -0,0 +1,1523 @@ +# Doxyfile 1.5.8 + +# This file describes the settings to be used by the documentation system +# doxygen (www.doxygen.org) for a project +# +# All text after a hash (#) is considered a comment and will be ignored +# The format is: +# TAG = value [value, ...] +# For lists items can also be appended using: +# TAG += value [value, ...] +# Values that contain spaces should be placed between quotes (" ") + +#--------------------------------------------------------------------------- +# Project related configuration options +#--------------------------------------------------------------------------- + +# This tag specifies the encoding used for all characters in the config file +# that follow. The default is UTF-8 which is also the encoding used for all +# text before the first occurrence of this tag. Doxygen uses libiconv (or the +# iconv built into libc) for the transcoding. See +# http://www.gnu.org/software/libiconv for the list of possible encodings. + +DOXYFILE_ENCODING = UTF-8 + +# The PROJECT_NAME tag is a single word (or a sequence of words surrounded +# by quotes) that should identify the project. + +PROJECT_NAME = Resp + +# The PROJECT_NUMBER tag can be used to enter a project or revision number. +# This could be handy for archiving the generated documentation or +# if some version control system is used. + +PROJECT_NUMBER = 0.0 + +# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) +# base path where the generated documentation will be put. +# If a relative path is entered, it will be relative to the location +# where doxygen was started. If left blank the current directory will be used. + +OUTPUT_DIRECTORY = build/doc + +# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create +# 4096 sub-directories (in 2 levels) under the output directory of each output +# format and will distribute the generated files over these directories. +# Enabling this option can be useful when feeding doxygen a huge amount of +# source files, where putting all generated files in the same directory would +# otherwise cause performance problems for the file system. + +CREATE_SUBDIRS = NO + +# The OUTPUT_LANGUAGE tag is used to specify the language in which all +# documentation generated by doxygen is written. Doxygen will use this +# information to generate all constant output in the proper language. +# The default language is English, other supported languages are: +# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional, +# Croatian, Czech, Danish, Dutch, Farsi, Finnish, French, German, Greek, +# Hungarian, Italian, Japanese, Japanese-en (Japanese with English messages), +# Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian, Polish, +# Portuguese, Romanian, Russian, Serbian, Serbian-Cyrilic, Slovak, Slovene, +# Spanish, Swedish, and Ukrainian. + +OUTPUT_LANGUAGE = English + +# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will +# include brief member descriptions after the members that are listed in +# the file and class documentation (similar to JavaDoc). +# Set to NO to disable this. + +BRIEF_MEMBER_DESC = NO + +# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend +# the brief description of a member or function before the detailed description. +# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the +# brief descriptions will be completely suppressed. + +REPEAT_BRIEF = NO + +# This tag implements a quasi-intelligent brief description abbreviator +# that is used to form the text in various listings. Each string +# in this list, if found as the leading text of the brief description, will be +# stripped from the text and the result after processing the whole list, is +# used as the annotated text. Otherwise, the brief description is used as-is. +# If left blank, the following values are used ("$name" is automatically +# replaced with the name of the entity): "The $name class" "The $name widget" +# "The $name file" "is" "provides" "specifies" "contains" +# "represents" "a" "an" "the" + +ABBREVIATE_BRIEF = + +# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then +# Doxygen will generate a detailed section even if there is only a brief +# description. + +ALWAYS_DETAILED_SEC = NO + +# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all +# inherited members of a class in the documentation of that class as if those +# members were ordinary class members. Constructors, destructors and assignment +# operators of the base classes will not be shown. + +INLINE_INHERITED_MEMB = NO + +# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full +# path before files name in the file list and in the header files. If set +# to NO the shortest path that makes the file name unique will be used. + +FULL_PATH_NAMES = NO + +# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag +# can be used to strip a user-defined part of the path. Stripping is +# only done if one of the specified strings matches the left-hand part of +# the path. The tag can be used to show relative paths in the file list. +# If left blank the directory from which doxygen is run is used as the +# path to strip. + +STRIP_FROM_PATH = + +# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of +# the path mentioned in the documentation of a class, which tells +# the reader which header file to include in order to use a class. +# If left blank only the name of the header file containing the class +# definition is used. Otherwise one should specify the include paths that +# are normally passed to the compiler using the -I flag. + +STRIP_FROM_INC_PATH = + +# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter +# (but less readable) file names. This can be useful is your file systems +# doesn't support long names like on DOS, Mac, or CD-ROM. + +SHORT_NAMES = NO + +# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen +# will interpret the first line (until the first dot) of a JavaDoc-style +# comment as the brief description. If set to NO, the JavaDoc +# comments will behave just like regular Qt-style comments +# (thus requiring an explicit @brief command for a brief description.) + +JAVADOC_AUTOBRIEF = YES + +# If the QT_AUTOBRIEF tag is set to YES then Doxygen will +# interpret the first line (until the first dot) of a Qt-style +# comment as the brief description. If set to NO, the comments +# will behave just like regular Qt-style comments (thus requiring +# an explicit \brief command for a brief description.) + +QT_AUTOBRIEF = NO + +# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen +# treat a multi-line C++ special comment block (i.e. a block of //! or /// +# comments) as a brief description. This used to be the default behaviour. +# The new default is to treat a multi-line C++ comment block as a detailed +# description. Set this tag to YES if you prefer the old behaviour instead. + +MULTILINE_CPP_IS_BRIEF = NO + +# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented +# member inherits the documentation from any documented member that it +# re-implements. + +INHERIT_DOCS = YES + +# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce +# a new page for each member. If set to NO, the documentation of a member will +# be part of the file/class/namespace that contains it. + +SEPARATE_MEMBER_PAGES = NO + +# The TAB_SIZE tag can be used to set the number of spaces in a tab. +# Doxygen uses this value to replace tabs by spaces in code fragments. + +TAB_SIZE = 4 + +# This tag can be used to specify a number of aliases that acts +# as commands in the documentation. An alias has the form "name=value". +# For example adding "sideeffect=\par Side Effects:\n" will allow you to +# put the command \sideeffect (or @sideeffect) in the documentation, which +# will result in a user-defined paragraph with heading "Side Effects:". +# You can put \n's in the value part of an alias to insert newlines. + +ALIASES = + +# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C +# sources only. Doxygen will then generate output that is more tailored for C. +# For instance, some of the names that are used will be different. The list +# of all members will be omitted, etc. + +OPTIMIZE_OUTPUT_FOR_C = NO + +# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java +# sources only. Doxygen will then generate output that is more tailored for +# Java. For instance, namespaces will be presented as packages, qualified +# scopes will look different, etc. + +OPTIMIZE_OUTPUT_JAVA = NO + +# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran +# sources only. Doxygen will then generate output that is more tailored for +# Fortran. + +OPTIMIZE_FOR_FORTRAN = NO + +# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL +# sources. Doxygen will then generate output that is tailored for +# VHDL. + +OPTIMIZE_OUTPUT_VHDL = NO + +# Doxygen selects the parser to use depending on the extension of the files it parses. +# With this tag you can assign which parser to use for a given extension. +# Doxygen has a built-in mapping, but you can override or extend it using this tag. +# The format is ext=language, where ext is a file extension, and language is one of +# the parsers supported by doxygen: IDL, Java, Javascript, C#, C, C++, D, PHP, +# Objective-C, Python, Fortran, VHDL, C, C++. For instance to make doxygen treat +# .inc files as Fortran files (default is PHP), and .f files as C (default is Fortran), +# use: inc=Fortran f=C + +EXTENSION_MAPPING = + +# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want +# to include (a tag file for) the STL sources as input, then you should +# set this tag to YES in order to let doxygen match functions declarations and +# definitions whose arguments contain STL classes (e.g. func(std::string); v.s. +# func(std::string) {}). This also make the inheritance and collaboration +# diagrams that involve STL classes more complete and accurate. + +BUILTIN_STL_SUPPORT = YES + +# If you use Microsoft's C++/CLI language, you should set this option to YES to +# enable parsing support. + +CPP_CLI_SUPPORT = NO + +# Set the SIP_SUPPORT tag to YES if your project consists of sip sources only. +# Doxygen will parse them like normal C++ but will assume all classes use public +# instead of private inheritance when no explicit protection keyword is present. + +SIP_SUPPORT = NO + +# For Microsoft's IDL there are propget and propput attributes to indicate getter +# and setter methods for a property. Setting this option to YES (the default) +# will make doxygen to replace the get and set methods by a property in the +# documentation. This will only work if the methods are indeed getting or +# setting a simple type. If this is not the case, or you want to show the +# methods anyway, you should set this option to NO. + +IDL_PROPERTY_SUPPORT = YES + +# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC +# tag is set to YES, then doxygen will reuse the documentation of the first +# member in the group (if any) for the other members of the group. By default +# all members of a group must be documented explicitly. + +DISTRIBUTE_GROUP_DOC = NO + +# Set the SUBGROUPING tag to YES (the default) to allow class member groups of +# the same type (for instance a group of public functions) to be put as a +# subgroup of that type (e.g. under the Public Functions section). Set it to +# NO to prevent subgrouping. Alternatively, this can be done per class using +# the \nosubgrouping command. + +SUBGROUPING = YES + +# When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum +# is documented as struct, union, or enum with the name of the typedef. So +# typedef struct TypeS {} TypeT, will appear in the documentation as a struct +# with name TypeT. When disabled the typedef will appear as a member of a file, +# namespace, or class. And the struct will be named TypeS. This can typically +# be useful for C code in case the coding convention dictates that all compound +# types are typedef'ed and only the typedef is referenced, never the tag name. + +TYPEDEF_HIDES_STRUCT = NO + +# The SYMBOL_CACHE_SIZE determines the size of the internal cache use to +# determine which symbols to keep in memory and which to flush to disk. +# When the cache is full, less often used symbols will be written to disk. +# For small to medium size projects (<1000 input files) the default value is +# probably good enough. For larger projects a too small cache size can cause +# doxygen to be busy swapping symbols to and from disk most of the time +# causing a significant performance penality. +# If the system has enough physical memory increasing the cache will improve the +# performance by keeping more symbols in memory. Note that the value works on +# a logarithmic scale so increasing the size by one will rougly double the +# memory usage. The cache size is given by this formula: +# 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0, +# corresponding to a cache size of 2^16 = 65536 symbols + +SYMBOL_CACHE_SIZE = 0 + +#--------------------------------------------------------------------------- +# Build related configuration options +#--------------------------------------------------------------------------- + +# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in +# documentation are documented, even if no documentation was available. +# Private class members and static file members will be hidden unless +# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES + +EXTRACT_ALL = YES + +# If the EXTRACT_PRIVATE tag is set to YES all private members of a class +# will be included in the documentation. + +EXTRACT_PRIVATE = NO + +# If the EXTRACT_STATIC tag is set to YES all static members of a file +# will be included in the documentation. + +EXTRACT_STATIC = NO + +# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) +# defined locally in source files will be included in the documentation. +# If set to NO only classes defined in header files are included. + +EXTRACT_LOCAL_CLASSES = NO + +# This flag is only useful for Objective-C code. When set to YES local +# methods, which are defined in the implementation section but not in +# the interface are included in the documentation. +# If set to NO (the default) only methods in the interface are included. + +EXTRACT_LOCAL_METHODS = NO + +# If this flag is set to YES, the members of anonymous namespaces will be +# extracted and appear in the documentation as a namespace called +# 'anonymous_namespace{file}', where file will be replaced with the base +# name of the file that contains the anonymous namespace. By default +# anonymous namespace are hidden. + +EXTRACT_ANON_NSPACES = NO + +# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all +# undocumented members of documented classes, files or namespaces. +# If set to NO (the default) these members will be included in the +# various overviews, but no documentation section is generated. +# This option has no effect if EXTRACT_ALL is enabled. + +HIDE_UNDOC_MEMBERS = YES + +# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all +# undocumented classes that are normally visible in the class hierarchy. +# If set to NO (the default) these classes will be included in the various +# overviews. This option has no effect if EXTRACT_ALL is enabled. + +HIDE_UNDOC_CLASSES = YES + +# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all +# friend (class|struct|union) declarations. +# If set to NO (the default) these declarations will be included in the +# documentation. + +HIDE_FRIEND_COMPOUNDS = NO + +# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any +# documentation blocks found inside the body of a function. +# If set to NO (the default) these blocks will be appended to the +# function's detailed documentation block. + +HIDE_IN_BODY_DOCS = YES + +# The INTERNAL_DOCS tag determines if documentation +# that is typed after a \internal command is included. If the tag is set +# to NO (the default) then the documentation will be excluded. +# Set it to YES to include the internal documentation. + +INTERNAL_DOCS = NO + +# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate +# file names in lower-case letters. If set to YES upper-case letters are also +# allowed. This is useful if you have classes or files whose names only differ +# in case and if your file system supports case sensitive file names. Windows +# and Mac users are advised to set this option to NO. + +CASE_SENSE_NAMES = YES + +# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen +# will show members with their full class and namespace scopes in the +# documentation. If set to YES the scope will be hidden. + +HIDE_SCOPE_NAMES = NO + +# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen +# will put a list of the files that are included by a file in the documentation +# of that file. + +SHOW_INCLUDE_FILES = YES + +# If the INLINE_INFO tag is set to YES (the default) then a tag [inline] +# is inserted in the documentation for inline members. + +INLINE_INFO = YES + +# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen +# will sort the (detailed) documentation of file and class members +# alphabetically by member name. If set to NO the members will appear in +# declaration order. + +SORT_MEMBER_DOCS = NO + +# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the +# brief documentation of file, namespace and class members alphabetically +# by member name. If set to NO (the default) the members will appear in +# declaration order. + +SORT_BRIEF_DOCS = NO + +# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the +# hierarchy of group names into alphabetical order. If set to NO (the default) +# the group names will appear in their defined order. + +SORT_GROUP_NAMES = NO + +# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be +# sorted by fully-qualified names, including namespaces. If set to +# NO (the default), the class list will be sorted only by class name, +# not including the namespace part. +# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. +# Note: This option applies only to the class list, not to the +# alphabetical list. + +SORT_BY_SCOPE_NAME = YES + +# The GENERATE_TODOLIST tag can be used to enable (YES) or +# disable (NO) the todo list. This list is created by putting \todo +# commands in the documentation. + +GENERATE_TODOLIST = NO + +# The GENERATE_TESTLIST tag can be used to enable (YES) or +# disable (NO) the test list. This list is created by putting \test +# commands in the documentation. + +GENERATE_TESTLIST = NO + +# The GENERATE_BUGLIST tag can be used to enable (YES) or +# disable (NO) the bug list. This list is created by putting \bug +# commands in the documentation. + +GENERATE_BUGLIST = NO + +# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or +# disable (NO) the deprecated list. This list is created by putting +# \deprecated commands in the documentation. + +GENERATE_DEPRECATEDLIST= YES + +# The ENABLED_SECTIONS tag can be used to enable conditional +# documentation sections, marked by \if sectionname ... \endif. + +ENABLED_SECTIONS = + +# The MAX_INITIALIZER_LINES tag determines the maximum number of lines +# the initial value of a variable or define consists of for it to appear in +# the documentation. If the initializer consists of more lines than specified +# here it will be hidden. Use a value of 0 to hide initializers completely. +# The appearance of the initializer of individual variables and defines in the +# documentation can be controlled using \showinitializer or \hideinitializer +# command in the documentation regardless of this setting. + +MAX_INITIALIZER_LINES = 30 + +# Set the SHOW_USED_FILES tag to NO to disable the list of files generated +# at the bottom of the documentation of classes and structs. If set to YES the +# list will mention the files that were used to generate the documentation. + +SHOW_USED_FILES = YES + +# If the sources in your project are distributed over multiple directories +# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy +# in the documentation. The default is NO. + +SHOW_DIRECTORIES = NO + +# Set the SHOW_FILES tag to NO to disable the generation of the Files page. +# This will remove the Files entry from the Quick Index and from the +# Folder Tree View (if specified). The default is YES. + +SHOW_FILES = YES + +# Set the SHOW_NAMESPACES tag to NO to disable the generation of the +# Namespaces page. +# This will remove the Namespaces entry from the Quick Index +# and from the Folder Tree View (if specified). The default is YES. + +SHOW_NAMESPACES = YES + +# The FILE_VERSION_FILTER tag can be used to specify a program or script that +# doxygen should invoke to get the current version for each file (typically from +# the version control system). Doxygen will invoke the program by executing (via +# popen()) the command , where is the value of +# the FILE_VERSION_FILTER tag, and is the name of an input file +# provided by doxygen. Whatever the program writes to standard output +# is used as the file version. See the manual for examples. + +FILE_VERSION_FILTER = + +# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed by +# doxygen. The layout file controls the global structure of the generated output files +# in an output format independent way. The create the layout file that represents +# doxygen's defaults, run doxygen with the -l option. You can optionally specify a +# file name after the option, if omitted DoxygenLayout.xml will be used as the name +# of the layout file. + +LAYOUT_FILE = + +#--------------------------------------------------------------------------- +# configuration options related to warning and progress messages +#--------------------------------------------------------------------------- + +# The QUIET tag can be used to turn on/off the messages that are generated +# by doxygen. Possible values are YES and NO. If left blank NO is used. + +QUIET = YES + +# The WARNINGS tag can be used to turn on/off the warning messages that are +# generated by doxygen. Possible values are YES and NO. If left blank +# NO is used. + +WARNINGS = YES + +# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings +# for undocumented members. If EXTRACT_ALL is set to YES then this flag will +# automatically be disabled. + +WARN_IF_UNDOCUMENTED = NO + +# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for +# potential errors in the documentation, such as not documenting some +# parameters in a documented function, or documenting parameters that +# don't exist or using markup commands wrongly. + +WARN_IF_DOC_ERROR = YES + +# This WARN_NO_PARAMDOC option can be abled to get warnings for +# functions that are documented, but have no documentation for their parameters +# or return value. If set to NO (the default) doxygen will only warn about +# wrong or incomplete parameter documentation, but not about the absence of +# documentation. + +WARN_NO_PARAMDOC = NO + +# The WARN_FORMAT tag determines the format of the warning messages that +# doxygen can produce. The string should contain the $file, $line, and $text +# tags, which will be replaced by the file and line number from which the +# warning originated and the warning text. Optionally the format may contain +# $version, which will be replaced by the version of the file (if it could +# be obtained via FILE_VERSION_FILTER) + +WARN_FORMAT = "$file:$line: $text" + +# The WARN_LOGFILE tag can be used to specify a file to which warning +# and error messages should be written. If left blank the output is written +# to stderr. + +WARN_LOGFILE = + +#--------------------------------------------------------------------------- +# configuration options related to the input files +#--------------------------------------------------------------------------- + +# The INPUT tag can be used to specify the files and/or directories that contain +# documented source files. You may enter file names like "myfile.cpp" or +# directories like "/usr/src/myproject". Separate the files or directories +# with spaces. + +INPUT = \ + src/constrain.cpp \ + src/cps.cpp \ + src/gc.cpp \ + src/lex.cpp \ + src/llvm.cpp \ + src/parse.cpp \ + src/pprint.cpp \ + src/repl.cpp \ + src/resp.cpp \ + src/resp.hpp \ + src/resp_gc.cpp \ + src/unify.cpp + +# This tag can be used to specify the character encoding of the source files +# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is +# also the default input encoding. Doxygen uses libiconv (or the iconv built +# into libc) for the transcoding. See http://www.gnu.org/software/libiconv for +# the list of possible encodings. + +INPUT_ENCODING = UTF-8 + +# If the value of the INPUT tag contains directories, you can use the +# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp +# and *.h) to filter out the source-files in the directories. If left +# blank the following patterns are tested: +# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx +# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py *.f90 + +FILE_PATTERNS = + +# The RECURSIVE tag can be used to turn specify whether or not subdirectories +# should be searched for input files as well. Possible values are YES and NO. +# If left blank NO is used. + +RECURSIVE = NO + +# The EXCLUDE tag can be used to specify files and/or directories that should +# excluded from the INPUT source files. This way you can easily exclude a +# subdirectory from a directory tree whose root is specified with the INPUT tag. + +EXCLUDE = + +# The EXCLUDE_SYMLINKS tag can be used select whether or not files or +# directories that are symbolic links (a Unix filesystem feature) are excluded +# from the input. + +EXCLUDE_SYMLINKS = NO + +# If the value of the INPUT tag contains directories, you can use the +# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude +# certain files from those directories. Note that the wildcards are matched +# against the file with absolute path, so to exclude all test directories +# for example use the pattern */test/* + +EXCLUDE_PATTERNS = + +# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names +# (namespaces, classes, functions, etc.) that should be excluded from the +# output. The symbol name can be a fully qualified name, a word, or if the +# wildcard * is used, a substring. Examples: ANamespace, AClass, +# AClass::ANamespace, ANamespace::*Test + +EXCLUDE_SYMBOLS = + +# The EXAMPLE_PATH tag can be used to specify one or more files or +# directories that contain example code fragments that are included (see +# the \include command). + +EXAMPLE_PATH = + +# If the value of the EXAMPLE_PATH tag contains directories, you can use the +# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp +# and *.h) to filter out the source-files in the directories. If left +# blank all files are included. + +EXAMPLE_PATTERNS = *.c + +# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be +# searched for input files to be used with the \include or \dontinclude +# commands irrespective of the value of the RECURSIVE tag. +# Possible values are YES and NO. If left blank NO is used. + +EXAMPLE_RECURSIVE = NO + +# The IMAGE_PATH tag can be used to specify one or more files or +# directories that contain image that are included in the documentation (see +# the \image command). + +IMAGE_PATH = + +# The INPUT_FILTER tag can be used to specify a program that doxygen should +# invoke to filter for each input file. Doxygen will invoke the filter program +# by executing (via popen()) the command , where +# is the value of the INPUT_FILTER tag, and is the name of an +# input file. Doxygen will then use the output that the filter program writes +# to standard output. +# If FILTER_PATTERNS is specified, this tag will be +# ignored. + +INPUT_FILTER = + +# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern +# basis. +# Doxygen will compare the file name with each pattern and apply the +# filter if there is a match. +# The filters are a list of the form: +# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further +# info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER +# is applied to all files. + +FILTER_PATTERNS = + +# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using +# INPUT_FILTER) will be used to filter the input files when producing source +# files to browse (i.e. when SOURCE_BROWSER is set to YES). + +FILTER_SOURCE_FILES = NO + +#--------------------------------------------------------------------------- +# configuration options related to source browsing +#--------------------------------------------------------------------------- + +# If the SOURCE_BROWSER tag is set to YES then a list of source files will +# be generated. Documented entities will be cross-referenced with these sources. +# Note: To get rid of all source code in the generated output, make sure also +# VERBATIM_HEADERS is set to NO. + +SOURCE_BROWSER = NO + +# Setting the INLINE_SOURCES tag to YES will include the body +# of functions and classes directly in the documentation. + +INLINE_SOURCES = NO + +# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct +# doxygen to hide any special comment blocks from generated source code +# fragments. Normal C and C++ comments will always remain visible. + +STRIP_CODE_COMMENTS = YES + +# If the REFERENCED_BY_RELATION tag is set to YES +# then for each documented function all documented +# functions referencing it will be listed. + +REFERENCED_BY_RELATION = YES + +# If the REFERENCES_RELATION tag is set to YES +# then for each documented function all documented entities +# called/used by that function will be listed. + +REFERENCES_RELATION = YES + +# If the REFERENCES_LINK_SOURCE tag is set to YES (the default) +# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from +# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will +# link to the source code. +# Otherwise they will link to the documentation. + +REFERENCES_LINK_SOURCE = YES + +# If the USE_HTAGS tag is set to YES then the references to source code +# will point to the HTML generated by the htags(1) tool instead of doxygen +# built-in source browser. The htags tool is part of GNU's global source +# tagging system (see http://www.gnu.org/software/global/global.html). You +# will need version 4.8.6 or higher. + +USE_HTAGS = NO + +# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen +# will generate a verbatim copy of the header file for each class for +# which an include is specified. Set to NO to disable this. + +VERBATIM_HEADERS = YES + +#--------------------------------------------------------------------------- +# configuration options related to the alphabetical class index +#--------------------------------------------------------------------------- + +# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index +# of all compounds will be generated. Enable this if the project +# contains a lot of classes, structs, unions or interfaces. + +ALPHABETICAL_INDEX = NO + +# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then +# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns +# in which this list will be split (can be a number in the range [1..20]) + +COLS_IN_ALPHA_INDEX = 5 + +# In case all classes in a project start with a common prefix, all +# classes will be put under the same header in the alphabetical index. +# The IGNORE_PREFIX tag can be used to specify one or more prefixes that +# should be ignored while generating the index headers. + +IGNORE_PREFIX = + +#--------------------------------------------------------------------------- +# configuration options related to the HTML output +#--------------------------------------------------------------------------- + +# If the GENERATE_HTML tag is set to YES (the default) Doxygen will +# generate HTML output. + +GENERATE_HTML = YES + +# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `html' will be used as the default path. + +HTML_OUTPUT = html + +# The HTML_FILE_EXTENSION tag can be used to specify the file extension for +# each generated HTML page (for example: .htm,.php,.asp). If it is left blank +# doxygen will generate files with .html extension. + +HTML_FILE_EXTENSION = .html + +# The HTML_HEADER tag can be used to specify a personal HTML header for +# each generated HTML page. If it is left blank doxygen will generate a +# standard header. + +HTML_HEADER = + +# The HTML_FOOTER tag can be used to specify a personal HTML footer for +# each generated HTML page. If it is left blank doxygen will generate a +# standard footer. + +HTML_FOOTER = + +# The HTML_STYLESHEET tag can be used to specify a user-defined cascading +# style sheet that is used by each HTML page. It can be used to +# fine-tune the look of the HTML output. If the tag is left blank doxygen +# will generate a default style sheet. Note that doxygen will try to copy +# the style sheet file to the HTML output directory, so don't put your own +# stylesheet in the HTML output directory as well, or it will be erased! + +HTML_STYLESHEET = + +# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, +# files or namespaces will be aligned in HTML using tables. If set to +# NO a bullet list will be used. + +HTML_ALIGN_MEMBERS = YES + +# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML +# documentation will contain sections that can be hidden and shown after the +# page has loaded. For this to work a browser that supports +# JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox +# Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari). + +HTML_DYNAMIC_SECTIONS = NO + +# If the GENERATE_DOCSET tag is set to YES, additional index files +# will be generated that can be used as input for Apple's Xcode 3 +# integrated development environment, introduced with OSX 10.5 (Leopard). +# To create a documentation set, doxygen will generate a Makefile in the +# HTML output directory. Running make will produce the docset in that +# directory and running "make install" will install the docset in +# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find +# it at startup. +# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html for more information. + +GENERATE_DOCSET = NO + +# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the +# feed. A documentation feed provides an umbrella under which multiple +# documentation sets from a single provider (such as a company or product suite) +# can be grouped. + +DOCSET_FEEDNAME = "Doxygen generated docs" + +# When GENERATE_DOCSET tag is set to YES, this tag specifies a string that +# should uniquely identify the documentation set bundle. This should be a +# reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen +# will append .docset to the name. + +DOCSET_BUNDLE_ID = org.doxygen.Project + +# If the GENERATE_HTMLHELP tag is set to YES, additional index files +# will be generated that can be used as input for tools like the +# Microsoft HTML help workshop to generate a compiled HTML help file (.chm) +# of the generated HTML documentation. + +GENERATE_HTMLHELP = NO + +# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can +# be used to specify the file name of the resulting .chm file. You +# can add a path in front of the file if the result should not be +# written to the html output directory. + +CHM_FILE = + +# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can +# be used to specify the location (absolute path including file name) of +# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run +# the HTML help compiler on the generated index.hhp. + +HHC_LOCATION = + +# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag +# controls if a separate .chi index file is generated (YES) or that +# it should be included in the master .chm file (NO). + +GENERATE_CHI = NO + +# If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING +# is used to encode HtmlHelp index (hhk), content (hhc) and project file +# content. + +CHM_INDEX_ENCODING = + +# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag +# controls whether a binary table of contents is generated (YES) or a +# normal table of contents (NO) in the .chm file. + +BINARY_TOC = NO + +# The TOC_EXPAND flag can be set to YES to add extra items for group members +# to the contents of the HTML help documentation and to the tree view. + +TOC_EXPAND = NO + +# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and QHP_VIRTUAL_FOLDER +# are set, an additional index file will be generated that can be used as input for +# Qt's qhelpgenerator to generate a Qt Compressed Help (.qch) of the generated +# HTML documentation. + +GENERATE_QHP = NO + +# If the QHG_LOCATION tag is specified, the QCH_FILE tag can +# be used to specify the file name of the resulting .qch file. +# The path specified is relative to the HTML output folder. + +QCH_FILE = + +# The QHP_NAMESPACE tag specifies the namespace to use when generating +# Qt Help Project output. For more information please see +# http://doc.trolltech.com/qthelpproject.html#namespace + +QHP_NAMESPACE = + +# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating +# Qt Help Project output. For more information please see +# http://doc.trolltech.com/qthelpproject.html#virtual-folders + +QHP_VIRTUAL_FOLDER = doc + +# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to add. +# For more information please see +# http://doc.trolltech.com/qthelpproject.html#custom-filters + +QHP_CUST_FILTER_NAME = + +# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the custom filter to add.For more information please see +# Qt Help Project / Custom Filters. + +QHP_CUST_FILTER_ATTRS = + +# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this project's +# filter section matches. +# Qt Help Project / Filter Attributes. + +QHP_SECT_FILTER_ATTRS = + +# If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can +# be used to specify the location of Qt's qhelpgenerator. +# If non-empty doxygen will try to run qhelpgenerator on the generated +# .qhp file. + +QHG_LOCATION = + +# The DISABLE_INDEX tag can be used to turn on/off the condensed index at +# top of each HTML page. The value NO (the default) enables the index and +# the value YES disables it. + +DISABLE_INDEX = NO + +# This tag can be used to set the number of enum values (range [1..20]) +# that doxygen will group on one line in the generated HTML documentation. + +ENUM_VALUES_PER_LINE = 4 + +# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index +# structure should be generated to display hierarchical information. +# If the tag value is set to FRAME, a side panel will be generated +# containing a tree-like index structure (just like the one that +# is generated for HTML Help). For this to work a browser that supports +# JavaScript, DHTML, CSS and frames is required (for instance Mozilla 1.0+, +# Netscape 6.0+, Internet explorer 5.0+, or Konqueror). Windows users are +# probably better off using the HTML help feature. Other possible values +# for this tag are: HIERARCHIES, which will generate the Groups, Directories, +# and Class Hierarchy pages using a tree view instead of an ordered list; +# ALL, which combines the behavior of FRAME and HIERARCHIES; and NONE, which +# disables this behavior completely. For backwards compatibility with previous +# releases of Doxygen, the values YES and NO are equivalent to FRAME and NONE +# respectively. + +GENERATE_TREEVIEW = NO + +# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be +# used to set the initial width (in pixels) of the frame in which the tree +# is shown. + +TREEVIEW_WIDTH = 250 + +# Use this tag to change the font size of Latex formulas included +# as images in the HTML documentation. The default is 10. Note that +# when you change the font size after a successful doxygen run you need +# to manually remove any form_*.png images from the HTML output directory +# to force them to be regenerated. + +FORMULA_FONTSIZE = 10 + +#--------------------------------------------------------------------------- +# configuration options related to the LaTeX output +#--------------------------------------------------------------------------- + +# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will +# generate Latex output. + +GENERATE_LATEX = NO + +# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `latex' will be used as the default path. + +LATEX_OUTPUT = latex + +# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be +# invoked. If left blank `latex' will be used as the default command name. + +LATEX_CMD_NAME = pdflatex + +# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to +# generate index for LaTeX. If left blank `makeindex' will be used as the +# default command name. + +MAKEINDEX_CMD_NAME = makeindex + +# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact +# LaTeX documents. This may be useful for small projects and may help to +# save some trees in general. + +COMPACT_LATEX = YES + +# The PAPER_TYPE tag can be used to set the paper type that is used +# by the printer. Possible values are: a4, a4wide, letter, legal and +# executive. If left blank a4wide will be used. + +PAPER_TYPE = a4wide + +# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX +# packages that should be included in the LaTeX output. + +EXTRA_PACKAGES = + +# The LATEX_HEADER tag can be used to specify a personal LaTeX header for +# the generated latex document. The header should contain everything until +# the first chapter. If it is left blank doxygen will generate a +# standard header. Notice: only use this tag if you know what you are doing! + +LATEX_HEADER = + +# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated +# is prepared for conversion to pdf (using ps2pdf). The pdf file will +# contain links (just like the HTML output) instead of page references +# This makes the output suitable for online browsing using a pdf viewer. + +PDF_HYPERLINKS = YES + +# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of +# plain latex in the generated Makefile. Set this option to YES to get a +# higher quality PDF documentation. + +USE_PDFLATEX = YES + +# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. +# command to the generated LaTeX files. This will instruct LaTeX to keep +# running if errors occur, instead of asking the user for help. +# This option is also used when generating formulas in HTML. + +LATEX_BATCHMODE = NO + +# If LATEX_HIDE_INDICES is set to YES then doxygen will not +# include the index chapters (such as File Index, Compound Index, etc.) +# in the output. + +LATEX_HIDE_INDICES = NO + +#--------------------------------------------------------------------------- +# configuration options related to the RTF output +#--------------------------------------------------------------------------- + +# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output +# The RTF output is optimized for Word 97 and may not look very pretty with +# other RTF readers or editors. + +GENERATE_RTF = NO + +# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `rtf' will be used as the default path. + +RTF_OUTPUT = rtf + +# If the COMPACT_RTF tag is set to YES Doxygen generates more compact +# RTF documents. This may be useful for small projects and may help to +# save some trees in general. + +COMPACT_RTF = NO + +# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated +# will contain hyperlink fields. The RTF file will +# contain links (just like the HTML output) instead of page references. +# This makes the output suitable for online browsing using WORD or other +# programs which support those fields. +# Note: wordpad (write) and others do not support links. + +RTF_HYPERLINKS = NO + +# Load stylesheet definitions from file. Syntax is similar to doxygen's +# config file, i.e. a series of assignments. You only have to provide +# replacements, missing definitions are set to their default value. + +RTF_STYLESHEET_FILE = + +# Set optional variables used in the generation of an rtf document. +# Syntax is similar to doxygen's config file. + +RTF_EXTENSIONS_FILE = + +#--------------------------------------------------------------------------- +# configuration options related to the man page output +#--------------------------------------------------------------------------- + +# If the GENERATE_MAN tag is set to YES (the default) Doxygen will +# generate man pages + +GENERATE_MAN = NO + +# The MAN_OUTPUT tag is used to specify where the man pages will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `man' will be used as the default path. + +MAN_OUTPUT = man + +# The MAN_EXTENSION tag determines the extension that is added to +# the generated man pages (default is the subroutine's section .3) + +MAN_EXTENSION = .3 + +# If the MAN_LINKS tag is set to YES and Doxygen generates man output, +# then it will generate one additional man file for each entity +# documented in the real man page(s). These additional files +# only source the real man page, but without them the man command +# would be unable to find the correct page. The default is NO. + +MAN_LINKS = NO + +#--------------------------------------------------------------------------- +# configuration options related to the XML output +#--------------------------------------------------------------------------- + +# If the GENERATE_XML tag is set to YES Doxygen will +# generate an XML file that captures the structure of +# the code including all documentation. + +GENERATE_XML = NO + +# The XML_OUTPUT tag is used to specify where the XML pages will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `xml' will be used as the default path. + +XML_OUTPUT = xml + +# The XML_SCHEMA tag can be used to specify an XML schema, +# which can be used by a validating XML parser to check the +# syntax of the XML files. + +XML_SCHEMA = + +# The XML_DTD tag can be used to specify an XML DTD, +# which can be used by a validating XML parser to check the +# syntax of the XML files. + +XML_DTD = + +# If the XML_PROGRAMLISTING tag is set to YES Doxygen will +# dump the program listings (including syntax highlighting +# and cross-referencing information) to the XML output. Note that +# enabling this will significantly increase the size of the XML output. + +XML_PROGRAMLISTING = YES + +#--------------------------------------------------------------------------- +# configuration options for the AutoGen Definitions output +#--------------------------------------------------------------------------- + +# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will +# generate an AutoGen Definitions (see autogen.sf.net) file +# that captures the structure of the code including all +# documentation. Note that this feature is still experimental +# and incomplete at the moment. + +GENERATE_AUTOGEN_DEF = NO + +#--------------------------------------------------------------------------- +# configuration options related to the Perl module output +#--------------------------------------------------------------------------- + +# If the GENERATE_PERLMOD tag is set to YES Doxygen will +# generate a Perl module file that captures the structure of +# the code including all documentation. Note that this +# feature is still experimental and incomplete at the +# moment. + +GENERATE_PERLMOD = NO + +# If the PERLMOD_LATEX tag is set to YES Doxygen will generate +# the necessary Makefile rules, Perl scripts and LaTeX code to be able +# to generate PDF and DVI output from the Perl module output. + +PERLMOD_LATEX = NO + +# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be +# nicely formatted so it can be parsed by a human reader. +# This is useful +# if you want to understand what is going on. +# On the other hand, if this +# tag is set to NO the size of the Perl module output will be much smaller +# and Perl will parse it just the same. + +PERLMOD_PRETTY = YES + +# The names of the make variables in the generated doxyrules.make file +# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. +# This is useful so different doxyrules.make files included by the same +# Makefile don't overwrite each other's variables. + +PERLMOD_MAKEVAR_PREFIX = + +#--------------------------------------------------------------------------- +# Configuration options related to the preprocessor +#--------------------------------------------------------------------------- + +# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will +# evaluate all C-preprocessor directives found in the sources and include +# files. + +ENABLE_PREPROCESSING = YES + +# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro +# names in the source code. If set to NO (the default) only conditional +# compilation will be performed. Macro expansion can be done in a controlled +# way by setting EXPAND_ONLY_PREDEF to YES. + +MACRO_EXPANSION = NO + +# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES +# then the macro expansion is limited to the macros specified with the +# PREDEFINED and EXPAND_AS_DEFINED tags. + +EXPAND_ONLY_PREDEF = NO + +# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files +# in the INCLUDE_PATH (see below) will be search if a #include is found. + +SEARCH_INCLUDES = YES + +# The INCLUDE_PATH tag can be used to specify one or more directories that +# contain include files that are not input files but should be processed by +# the preprocessor. + +INCLUDE_PATH = + +# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard +# patterns (like *.h and *.hpp) to filter out the header-files in the +# directories. If left blank, the patterns specified with FILE_PATTERNS will +# be used. + +INCLUDE_FILE_PATTERNS = + +# The PREDEFINED tag can be used to specify one or more macro names that +# are defined before the preprocessor is started (similar to the -D option of +# gcc). The argument of the tag is a list of macros of the form: name +# or name=definition (no spaces). If the definition and the = are +# omitted =1 is assumed. To prevent a macro definition from being +# undefined via #undef or recursively expanded use the := operator +# instead of the = operator. + +PREDEFINED = + +# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then +# this tag can be used to specify a list of macro names that should be expanded. +# The macro definition that is found in the sources will be used. +# Use the PREDEFINED tag if you want to use a different macro definition. + +EXPAND_AS_DEFINED = + +# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then +# doxygen's preprocessor will remove all function-like macros that are alone +# on a line, have an all uppercase name, and do not end with a semicolon. Such +# function macros are typically used for boiler-plate code, and will confuse +# the parser if not removed. + +SKIP_FUNCTION_MACROS = YES + +#--------------------------------------------------------------------------- +# Configuration::additions related to external references +#--------------------------------------------------------------------------- + +# The TAGFILES option can be used to specify one or more tagfiles. +# Optionally an initial location of the external documentation +# can be added for each tagfile. The format of a tag file without +# this location is as follows: +# +# TAGFILES = file1 file2 ... +# Adding location for the tag files is done as follows: +# +# TAGFILES = file1=loc1 "file2 = loc2" ... +# where "loc1" and "loc2" can be relative or absolute paths or +# URLs. If a location is present for each tag, the installdox tool +# does not have to be run to correct the links. +# Note that each tag file must have a unique name +# (where the name does NOT include the path) +# If a tag file is not located in the directory in which doxygen +# is run, you must also specify the path to the tagfile here. + +TAGFILES = + +# When a file name is specified after GENERATE_TAGFILE, doxygen will create +# a tag file that is based on the input files it reads. + +GENERATE_TAGFILE = + +# If the ALLEXTERNALS tag is set to YES all external classes will be listed +# in the class index. If set to NO only the inherited external classes +# will be listed. + +ALLEXTERNALS = NO + +# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed +# in the modules index. If set to NO, only the current project's groups will +# be listed. + +EXTERNAL_GROUPS = YES + +# The PERL_PATH should be the absolute path and name of the perl script +# interpreter (i.e. the result of `which perl'). + +PERL_PATH = /usr/bin/perl + +#--------------------------------------------------------------------------- +# Configuration options related to the dot tool +#--------------------------------------------------------------------------- + +# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will +# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base +# or super classes. Setting the tag to NO turns the diagrams off. Note that +# this option is superseded by the HAVE_DOT option below. This is only a +# fallback. It is recommended to install and use dot, since it yields more +# powerful graphs. + +CLASS_DIAGRAMS = YES + +# You can define message sequence charts within doxygen comments using the \msc +# command. Doxygen will then run the mscgen tool (see +# http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the +# documentation. The MSCGEN_PATH tag allows you to specify the directory where +# the mscgen tool resides. If left empty the tool is assumed to be found in the +# default search path. + +MSCGEN_PATH = + +# If set to YES, the inheritance and collaboration graphs will hide +# inheritance and usage relations if the target is undocumented +# or is not a class. + +HIDE_UNDOC_RELATIONS = YES + +# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is +# available from the path. This tool is part of Graphviz, a graph visualization +# toolkit from AT&T and Lucent Bell Labs. The other options in this section +# have no effect if this option is set to NO (the default) + +HAVE_DOT = YES + +# By default doxygen will write a font called FreeSans.ttf to the output +# directory and reference it in all dot files that doxygen generates. This +# font does not include all possible unicode characters however, so when you need +# these (or just want a differently looking font) you can specify the font name +# using DOT_FONTNAME. You need need to make sure dot is able to find the font, +# which can be done by putting it in a standard location or by setting the +# DOTFONTPATH environment variable or by setting DOT_FONTPATH to the directory +# containing the font. + +DOT_FONTNAME = FreeSans + +# The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs. +# The default size is 10pt. + +DOT_FONTSIZE = 10 + +# By default doxygen will tell dot to use the output directory to look for the +# FreeSans.ttf font (which doxygen will put there itself). If you specify a +# different font using DOT_FONTNAME you can set the path where dot +# can find it using this tag. + +DOT_FONTPATH = + +# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for each documented class showing the direct and +# indirect inheritance relations. Setting this tag to YES will force the +# the CLASS_DIAGRAMS tag to NO. + +CLASS_GRAPH = YES + +# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for each documented class showing the direct and +# indirect implementation dependencies (inheritance, containment, and +# class references variables) of the class with other documented classes. + +COLLABORATION_GRAPH = YES + +# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for groups, showing the direct groups dependencies + +GROUP_GRAPHS = YES + +# If the UML_LOOK tag is set to YES doxygen will generate inheritance and +# collaboration diagrams in a style similar to the OMG's Unified Modeling +# Language. + +UML_LOOK = NO + +# If set to YES, the inheritance and collaboration graphs will show the +# relations between templates and their instances. + +TEMPLATE_RELATIONS = YES + +# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT +# tags are set to YES then doxygen will generate a graph for each documented +# file showing the direct and indirect include dependencies of the file with +# other documented files. + +INCLUDE_GRAPH = NO + +# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and +# HAVE_DOT tags are set to YES then doxygen will generate a graph for each +# documented header file showing the documented files that directly or +# indirectly include this file. + +INCLUDED_BY_GRAPH = NO + +# If the CALL_GRAPH and HAVE_DOT options are set to YES then +# doxygen will generate a call dependency graph for every global function +# or class method. Note that enabling this option will significantly increase +# the time of a run. So in most cases it will be better to enable call graphs +# for selected functions only using the \callgraph command. + +CALL_GRAPH = NO + +# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then +# doxygen will generate a caller dependency graph for every global function +# or class method. Note that enabling this option will significantly increase +# the time of a run. So in most cases it will be better to enable caller +# graphs for selected functions only using the \callergraph command. + +CALLER_GRAPH = NO + +# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen +# will graphical hierarchy of all classes instead of a textual one. + +GRAPHICAL_HIERARCHY = YES + +# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES +# then doxygen will show the dependencies a directory has on other directories +# in a graphical way. The dependency relations are determined by the #include +# relations between the files in the directories. + +DIRECTORY_GRAPH = YES + +# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images +# generated by dot. Possible values are png, jpg, or gif +# If left blank png will be used. + +DOT_IMAGE_FORMAT = png + +# The tag DOT_PATH can be used to specify the path where the dot tool can be +# found. If left blank, it is assumed the dot tool can be found in the path. + +DOT_PATH = + +# The DOTFILE_DIRS tag can be used to specify one or more directories that +# contain dot files that are included in the documentation (see the +# \dotfile command). + +DOTFILE_DIRS = + +# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of +# nodes that will be shown in the graph. If the number of nodes in a graph +# becomes larger than this value, doxygen will truncate the graph, which is +# visualized by representing a node as a red box. Note that doxygen if the +# number of direct children of the root node in a graph is already larger than +# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note +# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH. + +DOT_GRAPH_MAX_NODES = 50 + +# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the +# graphs generated by dot. A depth value of 3 means that only nodes reachable +# from the root by following a path via at most 3 edges will be shown. Nodes +# that lay further from the root node will be omitted. Note that setting this +# option to 1 or 2 may greatly reduce the computation time needed for large +# code bases. Also note that the size of a graph can be further restricted by +# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction. + +MAX_DOT_GRAPH_DEPTH = 0 + +# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent +# background. This is disabled by default, because dot on Windows does not +# seem to support this out of the box. Warning: Depending on the platform used, +# enabling this option may lead to badly anti-aliased labels on the edges of +# a graph (i.e. they become hard to read). + +DOT_TRANSPARENT = NO + +# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output +# files in one run (i.e. multiple -o and -T options on the command line). This +# makes dot run faster, but since only newer versions of dot (>1.8.10) +# support this, this feature is disabled by default. + +DOT_MULTI_TARGETS = NO + +# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will +# generate a legend page explaining the meaning of the various boxes and +# arrows in the dot generated graphs. + +GENERATE_LEGEND = YES + +# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will +# remove the intermediate dot files that are used to generate +# the various graphs. + +DOT_CLEANUP = YES + +#--------------------------------------------------------------------------- +# Options related to the search engine +#--------------------------------------------------------------------------- + +# The SEARCHENGINE tag specifies whether or not a search engine should be +# used. If set to NO the values of all tags below this one will be ignored. + +SEARCHENGINE = NO + diff --git a/resp_highlight.py b/resp_highlight.py new file mode 100755 index 0000000..11ae298 --- /dev/null +++ b/resp_highlight.py @@ -0,0 +1,152 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +import sys +import pygments +import re +from pygments import highlight +from pygments.lexers import SchemeLexer +from pygments.formatters import HtmlFormatter, LatexFormatter +from pygments.lexer import RegexLexer, bygroups +from pygments.token import * +from pygments.style import Style + +#from pygments.styles import STYLE_MAP +#print STYLE_MAP.keys() + +class RespLexer(RegexLexer): + name = 'Resp' + aliases = ['resp'] + filenames = ['*.resp'] + mimetypes = ['text/x-resp', 'application/x-resp'] + + keywords = [ 'fn', 'def', 'if', 'match', 'ns', 'type' ] + builtins = [ 'cons', 'car', 'cdr' ] + + valid_name = r'[.a-zA-Z0-9!$%&*+,/:<=>?@^_~|-]+' + + tokens = { + 'root' : [ + # types + (r':?[A-Z][a-zA-Z.]*|:\([A-Z][a-zA-Z.\ ]*\)', Keyword.Type), + + # line comments + (r';.*$', Comment.Single), + + # whitespace + (r'\s+', Text), + + # numbers + (r'-?\d+\.\d+', Number.Float), + (r'-?\d+', Number.Integer), + + # strings, symbols and characters + (r'"(\\\\|\\"|[^"])*"', String), + (r"'" + valid_name, String.Symbol), + (r"#\\([()/'\".'_!ยง$%& ?=+-]{1}|[a-zA-Z0-9]+)", String.Char), + + # constants + (r'(#t|#f)', Name.Constant), + + # highlight keywords + ('(%s)' % '|'.join([ + re.escape(entry) + ' ' for entry in keywords]), + Keyword + ), + + # highlight builtins + ("(?<=\()(%s)" % '|'.join([ + re.escape(entry) + ' ' for entry in builtins]), + Name.Builtin + ), + + # remaining functions + (r'(?<=\()' + valid_name, Name.Function), + + # remaining variables + (valid_name, Name.Variable), + + # parenthesis + (r'(\(|\))', Punctuation), + ], + } + +class RespStyleDark(Style): + default_style = "#FFF" + background_color = "#222" + styles = { + Comment: '#79E', + Keyword: '#EE5', + Name: '#DDD', + Text: '#DDD', + String: '#F88', + Keyword.Type: '#5E5', + Punctuation: '#AAA', + Number: '#F88' + } + +class RespStyleLight(Style): + default_style = "#FFF" + background_color = "#EEE" + styles = { + Comment: '#57C', + Keyword: '#AA0', + Name: '#777', + Text: '#777', + String: '#D66', + Keyword.Type: '#3C3', + Punctuation: '#888', + Number: '#D66' + } + +if len(sys.argv) != 3: + print 'USAGE: %s IN OUT' % sys.argv[0] + sys.exit(1) + +infile = open(sys.argv[1], 'r') +text = infile.read() +infile.close() + + +if re.match('.*\.html$', sys.argv[2]): + style = RespStyleDark + formatter = HtmlFormatter(style=style) +elif re.match('.*\.tex$', sys.argv[2]): + style = RespStyleLight + formatter = LatexFormatter(style=style) + +if re.match('.*\.html$', sys.argv[2]): + outfile = open(sys.argv[2], 'w') + print >>outfile, ''' + + + + %s + + + + ''' + print >>outfile, highlight(text, RespLexer(), formatter) + print >>outfile, ''' + + ''' + outfile.close() + +if re.match('.*\.tex$', sys.argv[2]): + outfile = open(sys.argv[2], 'w') + print >>outfile, '''\\documentclass[10pt]{article} +\\usepackage{fancyvrb} +\\usepackage{color}''' + print >>outfile, formatter.get_style_defs() + print >>outfile, '\\newcommand\\PYlambda{$\\lambda$}' + print >>outfile, '\\newcommand\\PYbiglambda{$\\Lambda$}' + print >>outfile, '\\begin{document}' + out = highlight(text, RespLexer(), formatter) + out = out.replace('[fn', '[@PYlambda') + out = out.replace('[Fn', '[@PYbiglambda') + print >>outfile, out + print >>outfile, '\\end{document}' + outfile.close() + diff --git a/src/c.cpp b/src/c.cpp index 563c2ba..7dbb6c2 100644 --- a/src/c.cpp +++ b/src/c.cpp @@ -1,18 +1,18 @@ -/* Tuplr: A programming language +/* Resp: A programming language * Copyright (C) 2008-2009 David Robillard * - * Tuplr is free software: you can redistribute it and/or modify it under + * Resp is free software: you can redistribute it and/or modify it under * the terms of the GNU Affero General Public License as published by the * Free Software Foundation, either version 3 of the License, or (at your * option) any later version. * - * Tuplr is distributed in the hope that it will be useful, but WITHOUT + * Resp is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General * Public License for more details. * * You should have received a copy of the GNU Affero General Public License - * along with Tuplr. If not, see . + * along with Resp. If not, see . */ /** @file @@ -22,7 +22,7 @@ #include #include #include -#include "tuplr.hpp" +#include "resp.hpp" using namespace std; using boost::format; @@ -80,7 +80,7 @@ struct CEngine : public Engine { : out( "#include \n" "#include \n" - "void* tuplr_gc_allocate(unsigned size, uint8_t tag);\n\n") + "void* resp_gc_allocate(unsigned size, uint8_t tag);\n\n") { } @@ -157,7 +157,7 @@ struct CEngine : public Engine { }; Engine* -tuplr_new_c_engine() +resp_new_c_engine() { return new CEngine(); } diff --git a/src/compile.cpp b/src/compile.cpp index 977ab27..2cf3b74 100644 --- a/src/compile.cpp +++ b/src/compile.cpp @@ -1,25 +1,25 @@ -/* Tuplr: A programming language +/* Resp: A programming language * Copyright (C) 2008-2009 David Robillard * - * Tuplr is free software: you can redistribute it and/or modify it under + * Resp is free software: you can redistribute it and/or modify it under * the terms of the GNU Affero General Public License as published by the * Free Software Foundation, either version 3 of the License, or (at your * option) any later version. * - * Tuplr is distributed in the hope that it will be useful, but WITHOUT + * Resp is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General * Public License for more details. * * You should have received a copy of the GNU Affero General Public License - * along with Tuplr. If not, see . + * along with Resp. If not, see . */ /** @file * @brief Compile all code (compilation pass 2) */ -#include "tuplr.hpp" +#include "resp.hpp" using namespace std; diff --git a/src/constrain.cpp b/src/constrain.cpp index d419036..4ab3924 100644 --- a/src/constrain.cpp +++ b/src/constrain.cpp @@ -1,18 +1,18 @@ -/* Tuplr Type Inferencing +/* Resp Type Inferencing * Copyright (C) 2008-2009 David Robillard * - * Tuplr is free software: you can redistribute it and/or modify it under + * Resp is free software: you can redistribute it and/or modify it under * the terms of the GNU Affero General Public License as published by the * Free Software Foundation, either version 3 of the License, or (at your * option) any later version. * - * Tuplr is distributed in the hope that it will be useful, but WITHOUT + * Resp is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General * Public License for more details. * * You should have received a copy of the GNU Affero General Public License - * along with Tuplr. If not, see . + * along with Resp. If not, see . */ /** @file @@ -20,7 +20,7 @@ */ #include -#include "tuplr.hpp" +#include "resp.hpp" #define CONSTRAIN_LITERAL(CT, NAME) \ template<> void \ diff --git a/src/cps.cpp b/src/cps.cpp index 6711556..831f53f 100644 --- a/src/cps.cpp +++ b/src/cps.cpp @@ -1,18 +1,18 @@ -/* Tuplr Type Inferencing +/* Resp Type Inferencing * Copyright (C) 2008-2009 David Robillard * - * Tuplr is free software: you can redistribute it and/or modify it under + * Resp is free software: you can redistribute it and/or modify it under * the terms of the GNU Affero General Public License as published by the * Free Software Foundation, either version 3 of the License, or (at your * option) any later version. * - * Tuplr is distributed in the hope that it will be useful, but WITHOUT + * Resp is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General * Public License for more details. * * You should have received a copy of the GNU Affero General Public License - * along with Tuplr. If not, see . + * along with Resp. If not, see . */ /** @file @@ -20,18 +20,18 @@ */ #include -#include "tuplr.hpp" +#include "resp.hpp" /** (cps x cont) => (cont x) */ AST* -AST::cps(TEnv& tenv, AST* cont) +AST::cps(TEnv& tenv, AST* cont) const { return tup(loc, cont, this, 0); } /** (cps (fn (a ...) body) cont) => (cont (fn (a ... k) (cps body k)) */ AST* -AFn::cps(TEnv& tenv, AST* cont) +AFn::cps(TEnv& tenv, AST* cont) const { ATuple* copyProt = new ATuple(*prot()); ASymbol* contArg = tenv.penv.gensym("_k"); @@ -45,14 +45,14 @@ AFn::cps(TEnv& tenv, AST* cont) } AST* -APrimitive::cps(TEnv& tenv, AST* cont) +APrimitive::cps(TEnv& tenv, AST* cont) const { return value() ? tup(loc, cont, this, 0) : ACall::cps(tenv, cont); } /** (cps (f a b ...)) => (a (fn (x) (b (fn (y) ... (cont (f x y ...)) */ AST* -ACall::cps(TEnv& tenv, AST* cont) +ACall::cps(TEnv& tenv, AST* cont) const { std::vector< std::pair > funcs; AFn* fn = NULL; @@ -62,10 +62,10 @@ ACall::cps(TEnv& tenv, AST* cont) // Argument evaluation continuations are not themselves in CPS. // Each makes a tail call to the next, and the last makes a tail // call to the continuation of this call - iterator firstFnIter = end(); - AFn* firstFn = NULL; - ssize_t index = 0; - FOREACHP(iterator, i, this) { + const_iterator firstFnIter = end(); + AFn* firstFn = NULL; + ssize_t index = 0; + FOREACHP(const_iterator, i, this) { if (!(*i)->to()) { funcs.push_back(make_pair((AFn*)NULL, (*i))); } else { @@ -102,9 +102,9 @@ ACall::cps(TEnv& tenv, AST* cont) } else { assert(head()->value()); ACall* ret = tup(loc, 0); - FOREACHP(iterator, i, this) + FOREACHP(const_iterator, i, this) ret->push_back((*i)); - if (!to()) + if (!to()) ret->push_back(cont); return ret; } @@ -112,7 +112,7 @@ ACall::cps(TEnv& tenv, AST* cont) /** (cps (def x y)) => (y (fn (x) (cont))) */ AST* -ADef::cps(TEnv& tenv, AST* cont) +ADef::cps(TEnv& tenv, AST* cont) const { AST* val = body()->cps(tenv, cont); ACall* valCall = val->to(); @@ -122,7 +122,7 @@ ADef::cps(TEnv& tenv, AST* cont) /** (cps (if c t ... e)) => */ AST* -AIf::cps(TEnv& tenv, AST* cont) +AIf::cps(TEnv& tenv, AST* cont) const { ASymbol* argSym = tenv.penv.gensym("c"); const_iterator i = begin(); diff --git a/src/gc.cpp b/src/gc.cpp index 9367921..c3dfa5a 100644 --- a/src/gc.cpp +++ b/src/gc.cpp @@ -1,18 +1,18 @@ -/* Tuplr: A programming language +/* Resp: A programming language * Copyright (C) 2008-2009 David Robillard * - * Tuplr is free software: you can redistribute it and/or modify it under + * Resp is free software: you can redistribute it and/or modify it under * the terms of the GNU Affero General Public License as published by the * Free Software Foundation, either version 3 of the License, or (at your * option) any later version. * - * Tuplr is distributed in the hope that it will be useful, but WITHOUT + * Resp is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General * Public License for more details. * * You should have received a copy of the GNU Affero General Public License - * along with Tuplr. If not, see . + * along with Resp. If not, see . */ /** @file @@ -22,7 +22,7 @@ #include #include #include -#include "tuplr.hpp" +#include "resp.hpp" #include "tlsf.h" using namespace std; diff --git a/src/lex.cpp b/src/lex.cpp index 597ca34..0097346 100644 --- a/src/lex.cpp +++ b/src/lex.cpp @@ -1,18 +1,18 @@ -/* Tuplr: A programming language +/* Resp: A programming language * Copyright (C) 2008-2009 David Robillard * - * Tuplr is free software: you can redistribute it and/or modify it under + * Resp is free software: you can redistribute it and/or modify it under * the terms of the GNU Affero General Public License as published by the * Free Software Foundation, either version 3 of the License, or (at your * option) any later version. * - * Tuplr is distributed in the hope that it will be useful, but WITHOUT + * Resp is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General * Public License for more details. * * You should have received a copy of the GNU Affero General Public License - * along with Tuplr. If not, see . + * along with Resp. If not, see . */ /** @file @@ -21,7 +21,7 @@ #include #include -#include "tuplr.hpp" +#include "resp.hpp" using namespace std; diff --git a/src/lift.cpp b/src/lift.cpp index 636757c..733c7b6 100644 --- a/src/lift.cpp +++ b/src/lift.cpp @@ -1,25 +1,25 @@ -/* Tuplr: A programming language +/* Resp: A programming language * Copyright (C) 2008-2009 David Robillard * - * Tuplr is free software: you can redistribute it and/or modify it under + * Resp is free software: you can redistribute it and/or modify it under * the terms of the GNU Affero General Public License as published by the * Free Software Foundation, either version 3 of the License, or (at your * option) any later version. * - * Tuplr is distributed in the hope that it will be useful, but WITHOUT + * Resp is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General * Public License for more details. * * You should have received a copy of the GNU Affero General Public License - * along with Tuplr. If not, see . + * along with Resp. If not, see . */ /** @file * @brief Lift functions (compilation pass 1) */ -#include "tuplr.hpp" +#include "resp.hpp" using namespace std; diff --git a/src/llvm.cpp b/src/llvm.cpp index fdb9783..5b6d69f 100644 --- a/src/llvm.cpp +++ b/src/llvm.cpp @@ -1,18 +1,18 @@ -/* Tuplr: A programming language +/* Resp: A programming language * Copyright (C) 2008-2009 David Robillard * - * Tuplr is free software: you can redistribute it and/or modify it under + * Resp is free software: you can redistribute it and/or modify it under * the terms of the GNU Affero General Public License as published by the * Free Software Foundation, either version 3 of the License, or (at your * option) any later version. * - * Tuplr is distributed in the hope that it will be useful, but WITHOUT + * Resp is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General * Public License for more details. * * You should have received a copy of the GNU Affero General Public License - * along with Tuplr. If not, see . + * along with Resp. If not, see . */ /** @file @@ -39,7 +39,7 @@ #include "llvm/Target/TargetData.h" #include "llvm/Target/TargetSelect.h" #include "llvm/Transforms/Scalar.h" -#include "tuplr.hpp" +#include "resp.hpp" using namespace llvm; using namespace std; @@ -54,7 +54,7 @@ struct LLVMEngine : public Engine { : builder(context) { InitializeNativeTarget(); - module = new Module("tuplr", context); + module = new Module("resp", context); emp = new ExistingModuleProvider(module); engine = EngineBuilder(module).create(); opt = new FunctionPassManager(emp); @@ -71,7 +71,7 @@ struct LLVMEngine : public Engine { std::vector argsT(1, Type::getInt32Ty(context)); // unsigned size FunctionType* funcT = FunctionType::get(PointerType::get(Type::getInt8Ty(context), 0), argsT, false); alloc = Function::Create(funcT, Function::ExternalLinkage, - "tuplr_gc_allocate", module); + "resp_gc_allocate", module); } ~LLVMEngine() @@ -227,7 +227,7 @@ struct LLVMEngine : public Engine { }; Engine* -tuplr_new_llvm_engine() +resp_new_llvm_engine() { return new LLVMEngine(); } diff --git a/src/parse.cpp b/src/parse.cpp index 52d3d78..1c448db 100644 --- a/src/parse.cpp +++ b/src/parse.cpp @@ -1,25 +1,25 @@ -/* Tuplr: A programming language +/* Resp: A programming language * Copyright (C) 2008-2009 David Robillard * - * Tuplr is free software: you can redistribute it and/or modify it under + * Resp is free software: you can redistribute it and/or modify it under * the terms of the GNU Affero General Public License as published by the * Free Software Foundation, either version 3 of the License, or (at your * option) any later version. * - * Tuplr is distributed in the hope that it will be useful, but WITHOUT + * Resp is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General * Public License for more details. * * You should have received a copy of the GNU Affero General Public License - * along with Tuplr. If not, see . + * along with Resp. If not, see . */ /** @file * @brief Parsing (build a code AST from a textual AST) */ -#include "tuplr.hpp" +#include "resp.hpp" using namespace std; diff --git a/src/pprint.cpp b/src/pprint.cpp index 8f1276d..7dd36c5 100644 --- a/src/pprint.cpp +++ b/src/pprint.cpp @@ -1,25 +1,25 @@ -/* Tuplr Serialisation +/* Resp Serialisation * Copyright (C) 2008-2009 David Robillard * - * Tuplr is free software: you can redistribute it and/or modify it under + * Resp is free software: you can redistribute it and/or modify it under * the terms of the GNU Affero General Public License as published by the * Free Software Foundation, either version 3 of the License, or (at your * option) any later version. * - * Tuplr is distributed in the hope that it will be useful, but WITHOUT + * Resp is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General * Public License for more details. * * You should have received a copy of the GNU Affero General Public License - * along with Tuplr. If not, see . + * along with Resp. If not, see . */ /** @file * @brief Pretty-print AST expressions */ -#include "tuplr.hpp" +#include "resp.hpp" ostream& operator<<(ostream& out, const AST* ast) diff --git a/src/repl.cpp b/src/repl.cpp index a5c6adf..9fa5781 100644 --- a/src/repl.cpp +++ b/src/repl.cpp @@ -1,18 +1,18 @@ -/* Tuplr: A programming language +/* Resp: A programming language * Copyright (C) 2008-2009 David Robillard * - * Tuplr is free software: you can redistribute it and/or modify it under + * Resp is free software: you can redistribute it and/or modify it under * the terms of the GNU Affero General Public License as published by the * Free Software Foundation, either version 3 of the License, or (at your * option) any later version. * - * Tuplr is distributed in the hope that it will be useful, but WITHOUT + * Resp is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General * Public License for more details. * * You should have received a copy of the GNU Affero General Public License - * along with Tuplr. If not, see . + * along with Resp. If not, see . */ /** @file @@ -22,7 +22,7 @@ #include #include #include -#include "tuplr.hpp" +#include "resp.hpp" using namespace std; diff --git a/src/resp.cpp b/src/resp.cpp new file mode 100644 index 0000000..003a76c --- /dev/null +++ b/src/resp.cpp @@ -0,0 +1,149 @@ +/* Resp: A programming language + * Copyright (C) 2008-2009 David Robillard + * + * Resp is free software: you can redistribute it and/or modify it under + * the terms of the GNU Affero General Public License as published by the + * Free Software Foundation, either version 3 of the License, or (at your + * option) any later version. + * + * Resp is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General + * Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with Resp. If not, see . + */ + +/** @file + * @brief Main program + */ + +#include +#include +#include +#include "resp.hpp" + +using namespace std; + +GC Object::pool(8 * 1024 * 1024); + +int +print_usage(char* name, bool error) +{ + ostream& os = error ? cerr : cout; + os << "Usage: " << name << " [OPTION]... [FILE]..." << endl; + os << "Evaluate and/or compile Resp code" << endl; + os << endl; + os << " -h Display this help and exit" << endl; + os << " -r Enter REPL after evaluating files" << endl; + os << " -p Pretty-print input only" << endl; + os << " -b BACKEND Backend (llvm or c)" << endl; + os << " -g Debug (disable optimisation)" << endl; + os << " -d Dump assembly output" << endl; + os << " -e EXPRESSION Evaluate EXPRESSION" << endl; + os << " -o FILE Compile output to FILE (don't run)" << endl; + return error ? 1 : 0; +} + +int +main(int argc, char** argv) +{ + // Read command line arguments + map args; + list files; + for (int i = 1; i < argc; ++i) { + if (!strncmp(argv[i], "-h", 3)) { + return print_usage(argv[0], false); + } else if (argv[i][0] != '-') { + files.push_back(argv[i]); + } else if (!strncmp(argv[i], "-r", 3) + || !strncmp(argv[i], "-p", 3) + || !strncmp(argv[i], "-g", 3) + || !strncmp(argv[i], "-d", 3)) { + args.insert(make_pair(argv[i], "")); + } else if (i == argc-1 || argv[i+1][0] == '-') { + return print_usage(argv[0], true); + } else { + args.insert(make_pair(argv[i], argv[i+1])); + ++i; + } + } + + PEnv penv; + TEnv tenv(penv); + initLang(penv, tenv); + + Engine* engine = NULL; + + map::const_iterator a = args.find("-b"); + const string backend_name = (a != args.end() ? a->second : "llvm"); + + if (backend_name == "llvm") + engine = resp_new_llvm_engine(); + else if (backend_name == "c") + engine = resp_new_c_engine(); + + if (!engine) { + std::cerr << "Unable to open backend " << backend_name << std::endl; + return 1; + } + + CEnv* cenv = new CEnv(penv, tenv, engine); + cenv->args = args; + + Object::pool.lock(); + + int ret = 0; + + a = args.find("-o"); + bool batch = a != args.end(); + const string output = (a != args.end()) ? a->second : ""; + + if (args.find("-p") != args.end()) { + ifstream is(files.front().c_str()); + if (is.good()) { + Cursor loc; + AST* exp = readExpression(loc, is); + AST* ast = penv.parse(exp); + pprint(cout, ast); + } + return 0; + } + + a = args.find("-e"); + if (a != args.end()) { + istringstream is(a->second); + ret = eval(*cenv, "(command line)", is, !batch); + } + + for (list::iterator f = files.begin(); f != files.end(); ++f) { + ifstream is(f->c_str()); + if (is.good()) { + ret = ret | eval(*cenv, *f, is, !batch); + } else { + cerr << argv[0] << ": " << *f << ": " << strerror(errno) << endl; + ++ret; + } + is.close(); + } + + if (args.find("-r") != args.end() || (files.empty() && args.find("-e") == args.end())) + ret = repl(*cenv); + + if (output != "") { + ofstream os(output.c_str()); + if (os.good()) { + cenv->engine()->writeModule(*cenv, os); + } else { + cerr << argv[0] << ": " << a->second << ": " << strerror(errno) << endl; + ++ret; + } + os.close(); + } + + delete cenv; + delete engine; + + return ret; +} diff --git a/src/resp.hpp b/src/resp.hpp new file mode 100644 index 0000000..81574e9 --- /dev/null +++ b/src/resp.hpp @@ -0,0 +1,727 @@ +/* Resp: A programming language + * Copyright (C) 2008-2009 David Robillard + * + * Resp is free software: you can redistribute it and/or modify it under + * the terms of the GNU Affero General Public License as published by the + * Free Software Foundation, either version 3 of the License, or (at your + * option) any later version. + * + * Resp is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General + * Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with Resp. If not, see . + */ + +/** @file + * @brief Interface and type definitions + */ + +#ifndef RESP_HPP +#define RESP_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define FOREACH(IT, i, c) for (IT i = (c).begin(); i != (c).end(); ++i) +#define FOREACHP(IT, i, c) for (IT i = (c)->begin(); i != (c)->end(); ++i) +#define THROW_IF(cond, error, ...) { if (cond) throw Error(error, __VA_ARGS__); } + +using namespace std; +using boost::format; + + +/*************************************************************************** + * Basic Utility Classes * + ***************************************************************************/ + +/// Location in textual code +struct Cursor { + Cursor(const string& n="", unsigned l=1, unsigned c=0) : name(n), line(l), col(c) {} + operator bool() const { return !(line == 1 && col == 0); } + string str() const { return (format("%1%:%2%:%3%") % name % line % col).str(); } + string name; + unsigned line; + unsigned col; +}; + +/// Compiler error +struct Error { + Error(Cursor c, const string& m) : loc(c), msg(m) {} + const string what() const { return (loc ? loc.str() + ": " : "") + "error: " + msg; } + const Cursor loc; + const string msg; +}; + +/// Generic Lexical Environment +template +struct Env : public list< vector< pair > > { + typedef vector< pair > Frame; + Env() : list(1) {} + virtual ~Env() {} + virtual void push(Frame f=Frame()) { list::push_front(f); } + virtual void pop() { list::pop_front(); } + const V& def(const K& k, const V& v) { + for (typename Frame::iterator b = this->begin()->begin(); b != this->begin()->end(); ++b) + if (b->first == k) + return (b->second = v); + this->front().push_back(make_pair(k, v)); + return v; + } + V* ref(const K& key) { + for (typename Env::iterator f = this->begin(); f != this->end(); ++f) + for (typename Frame::iterator b = f->begin(); b != f->end(); ++b) + if (b->first == key) + return &b->second; + return NULL; + } + bool topLevel(const K& key) const { + for (typename Frame::const_iterator b = this->back().begin(); b != this->back().end(); ++b) + if (b->first == key) + return true; + return false; + } +}; + +template +ostream& operator<<(ostream& out, const Env& env) { + out << "(Env" << endl; + for (typename Env::const_reverse_iterator f = env.rbegin(); f != env.rend(); ++f) { + out << " (" << endl; + for (typename Env::Frame::const_iterator b = f->begin(); b != f->end(); ++b) + cout << " " << b->first << " " << b->second << endl; + out << " )" << endl; + } + out << ")" << endl; + return out; +} + + +/*************************************************************************** + * Lexer: Text (istream) -> S-Expressions (SExp) * + ***************************************************************************/ + +class AST; +AST* readExpression(Cursor& cur, std::istream& in); + + +/*************************************************************************** + * Backend Types * + ***************************************************************************/ + +typedef void* CVal; ///< Compiled value (opaque) +typedef void* CFunc; ///< Compiled function (opaque) + + +/*************************************************************************** + * Garbage Collection * + ***************************************************************************/ + +struct Object; + +/// Garbage collector +struct GC { + typedef std::list Roots; + typedef std::list Heap; + GC(size_t pool_size); + ~GC(); + void* alloc(size_t size); + void collect(const Roots& roots); + void addRoot(const Object* obj) { assert(obj); _roots.push_back(obj); } + void lock() { _roots.insert(_roots.end(), _heap.begin(), _heap.end()); } + const Roots& roots() const { return _roots; } +private: + void* _pool; + Heap _heap; + Roots _roots; +}; + +/// Garbage collected object (including AST and runtime data) +struct Object { + enum Tag { OBJECT = 123, AST = 456 }; + + struct Header { + uint32_t mark; + uint32_t tag; + }; + + inline Tag tag() const { return (Tag)header()->tag; } + inline void tag(Tag t) { header()->tag = t; } + inline bool marked() const { return header()->mark != 0; } + inline void mark(bool b) const { header()->mark = (b ? 1 : 0); } + + static void* operator new(size_t size) { return pool.alloc(size); } + static void operator delete(void* ptr) {} + + // Memory used with placement new MUST always be allocated with pool.alloc! + static void* operator new(size_t size, void* ptr) { return ptr; } + + static GC pool; + +private: + /// Always allocated with pool.alloc, so this - sizeof(Header) is a valid Header*. + inline Header* header() const { return (Header*)((char*)this - sizeof(Header)); } +}; + + +/*************************************************************************** + * Abstract Syntax Tree * + ***************************************************************************/ + +struct TEnv; ///< Type-Time Environment +struct Constraints; ///< Type Constraints +struct Subst; ///< Type substitutions +struct CEnv; ///< Compile-Time Environment + +struct AST; +extern ostream& operator<<(ostream& out, const AST* ast); + +/// Base class for all AST nodes +struct AST : public Object { + AST(Cursor c=Cursor()) : loc(c) {} + virtual ~AST() {} + virtual bool value() const { return true; } + virtual bool operator==(const AST& o) const = 0; + virtual bool contains(const AST* child) const { return false; } + virtual void constrain(TEnv& tenv, Constraints& c) const {} + virtual AST* cps(TEnv& tenv, AST* cont) const; + virtual void lift(CEnv& cenv) {} + virtual CVal compile(CEnv& cenv) = 0; + string str() const { ostringstream ss; ss << this; return ss.str(); } + template T to() { return dynamic_cast(this); } + template T const to() const { return dynamic_cast(this); } + template T as() { + T t = dynamic_cast(this); + return t ? t : throw Error(loc, "internal error: bad cast"); + } + template T const as() const { + T const t = dynamic_cast(this); + return t ? t : throw Error(loc, "internal error: bad cast"); + } + Cursor loc; +}; + +template +static T* tup(Cursor c, AST* ast, ...) +{ + va_list args; + va_start(args, ast); + T* ret = new T(c, ast, args); + va_end(args); + return ret; +} + +/// Literal value +template +struct ALiteral : public AST { + ALiteral(T v, Cursor c) : AST(c), val(v) {} + bool operator==(const AST& rhs) const { + const ALiteral* r = rhs.to*>(); + return (r && (val == r->val)); + } + void constrain(TEnv& tenv, Constraints& c) const; + CVal compile(CEnv& cenv); + const T val; +}; + +/// String, e.g. ""a"" +struct AString : public AST, public std::string { + AString(Cursor c, const string& s) : AST(c), std::string(s) {} + bool operator==(const AST& rhs) const { return this == &rhs; } + void constrain(TEnv& tenv, Constraints& c) const; + CVal compile(CEnv& cenv) { return NULL; } +}; + +/// Symbol, e.g. "a" +struct ASymbol : public AST { + bool operator==(const AST& rhs) const { return this == &rhs; } + void constrain(TEnv& tenv, Constraints& c) const; + CVal compile(CEnv& cenv); + const string cppstr; +private: + friend class PEnv; + ASymbol(const string& s, Cursor c) : AST(c), cppstr(s) {} +}; + +/// Tuple (heterogeneous sequence of fixed length), e.g. "(a b c)" +struct ATuple : public AST { + ATuple(Cursor c) : AST(c), _len(0), _vec(0) {} + ATuple(const ATuple& exp) : AST(exp.loc), _len(exp._len) { + _vec = (AST**)malloc(sizeof(AST*) * _len); + memcpy(_vec, exp._vec, sizeof(AST*) * _len); + } + ATuple(Cursor c, AST* ast, va_list args) : AST(c), _len(0), _vec(0) { + if (!ast) return; + push_back(ast); + for (AST* a = va_arg(args, AST*); a; a = va_arg(args, AST*)) + push_back(a); + } + ~ATuple() { free(_vec); } + void push_back(AST* ast) { + AST** newvec = (AST**)realloc(_vec, sizeof(AST*) * (_len + 1)); + newvec[_len++] = ast; + _vec = newvec; + } + const AST* head() const { assert(_len > 0); return _vec[0]; } + AST* head() { assert(_len > 0); return _vec[0]; } + const AST* last() const { return _vec[_len - 1]; } + AST* last() { return _vec[_len - 1]; } + size_t size() const { return _len; } + bool empty() const { return _len == 0; } + + typedef AST** iterator; + typedef AST* const* const_iterator; + const_iterator begin() const { return _vec; } + iterator begin() { return _vec; } + const_iterator end() const { return _vec + _len; } + iterator end() { return _vec + _len; } + + bool value() const { return false; } + bool operator==(const AST& rhs) const { + const ATuple* rt = rhs.to(); + if (!rt || rt->size() != size()) return false; + const_iterator l = begin(); + FOREACHP(const_iterator, r, rt) + if (!(*(*l++) == *(*r))) + return false; + return true; + } + bool contains(AST* child) const { + if (*this == *child) return true; + FOREACHP(const_iterator, p, this) + if (**p == *child || (*p)->contains(child)) + return true; + return false; + } + void constrain(TEnv& tenv, Constraints& c) const; + void lift(CEnv& cenv) { FOREACHP(iterator, t, this) (*t)->lift(cenv); } + + CVal compile(CEnv& cenv) { throw Error(loc, "tuple compiled"); } + +private: + size_t _len; + AST** _vec; +}; + +/// Type Expression, e.g. "Int", "(Fn (Int Int) Float)" +struct AType : public ATuple { + enum Kind { VAR, PRIM, EXPR, DOTS }; + AType(ASymbol* s) : ATuple(s->loc), kind(PRIM), id(0) { push_back(s); } + AType(Cursor c, unsigned i) : ATuple(c), kind(VAR), id(i) {} + AType(Cursor c, Kind k=EXPR) : ATuple(c), kind(k), id(0) {} + AType(Cursor c, AST* ast, va_list args) : ATuple(c, ast, args), kind(EXPR), id(0) {} + AType(const AType& copy) : ATuple(copy), kind(copy.kind), id(copy.id) {} + CVal compile(CEnv& cenv) { return NULL; } + const ATuple* prot() const { assert(kind == EXPR); return (*(begin() + 1))->to(); } + ATuple* prot() { assert(kind == EXPR); return (*(begin() + 1))->to(); } + bool concrete() const { + switch (kind) { + case VAR: return false; + case PRIM: return head()->str() != "Nothing"; + case EXPR: + FOREACHP(const_iterator, t, this) { + AType* kid = (*t)->to(); + if (kid && !kid->concrete()) + return false; + } + } + return true; + } + bool operator==(const AST& rhs) const { + const AType* rt = rhs.to(); + if (!rt || kind != rt->kind) + return false; + else + switch (kind) { + case VAR: return id == rt->id; + case PRIM: return head()->str() == rt->head()->str(); + case EXPR: return ATuple::operator==(rhs); + } + return false; // never reached + } + Kind kind; + unsigned id; +}; + +/// Type substitution +struct Subst : public list< pair > { + Subst(AType* s=0, AType* t=0) { if (s && t) { assert(s != t); push_back(make_pair(s, t)); } } + static Subst compose(const Subst& delta, const Subst& gamma); + void add(const AType* from, AType* to) { push_back(make_pair(from, to)); } + const_iterator find(const AType* t) const { + for (const_iterator j = begin(); j != end(); ++j) + if (*j->first == *t) + return j; + return end(); + } + AType* apply(const AType* in) const { + if (in->kind == AType::EXPR) { + AType* out = tup(in->loc, NULL); + for (ATuple::const_iterator i = in->begin(); i != in->end(); ++i) + out->push_back(apply((*i)->as())); + return out; + } else { + const_iterator i = find(in); + if (i != end()) { + AType* out = i->second->as(); + if (out->kind == AType::EXPR && !out->concrete()) + out = apply(out->as()); + return out; + } else { + return new AType(*in); + } + } + } +}; + +inline ostream& operator<<(ostream& out, const Subst& s) { + for (Subst::const_iterator i = s.begin(); i != s.end(); ++i) + out << i->first << " => " << i->second << endl; + return out; +} + +/// Fn (first-class function with captured lexical bindings) +struct AFn : public ATuple { + AFn(Cursor c, AST* ast, va_list args) : ATuple(c, ast, args) {} + bool operator==(const AST& rhs) const { return this == &rhs; } + void constrain(TEnv& tenv, Constraints& c) const; + AST* cps(TEnv& tenv, AST* cont) const; + void lift(CEnv& cenv); + CVal compile(CEnv& cenv); + const ATuple* prot() const { return (*(begin() + 1))->to(); } + ATuple* prot() { return (*(begin() + 1))->to(); } + /// System level implementations of this (polymorphic) fn + struct Impls : public list< pair > { + CFunc find(AType* type) const { + for (const_iterator f = begin(); f != end(); ++f) + if (*f->first == *type) + return f->second; + return NULL; + } + }; + Impls impls; + string name; +}; + +/// Function call/application, e.g. "(func arg1 arg2)" +struct ACall : public ATuple { + ACall(const ATuple* exp) : ATuple(*exp) {} + ACall(Cursor c, AST* ast, va_list args) : ATuple(c, ast, args) {} + void constrain(TEnv& tenv, Constraints& c) const; + AST* cps(TEnv& tenv, AST* cont) const; + void lift(CEnv& cenv); + CVal compile(CEnv& cenv); +}; + +/// Definition special form, e.g. "(def x 2)" +struct ADef : public ACall { + ADef(const ATuple* exp) : ACall(exp) {} + ADef(Cursor c, AST* ast, va_list args) : ACall(c, ast, args) {} + const ASymbol* sym() const { + const AST* name = *(begin() + 1); + const ASymbol* sym = name->to(); + if (!sym) { + const ATuple* tup = name->to(); + if (tup && !tup->empty()) + return tup->head()->to(); + } + return sym; + } + const AST* body() const { return *(begin() + 2); } + AST* body() { return *(begin() + 2); } + void constrain(TEnv& tenv, Constraints& c) const; + AST* cps(TEnv& tenv, AST* cont) const; + void lift(CEnv& cenv); + CVal compile(CEnv& cenv); +}; + +/// Conditional special form, e.g. "(if cond thenexp elseexp)" +struct AIf : public ACall { + AIf(const ATuple* exp) : ACall(exp) {} + AIf(Cursor c, AST* ast, va_list args) : ACall(c, ast, args) {} + void constrain(TEnv& tenv, Constraints& c) const; + AST* cps(TEnv& tenv, AST* cont) const; + CVal compile(CEnv& cenv); +}; + +struct ACons : public ACall { + ACons(const ATuple* exp) : ACall(exp) {} + void constrain(TEnv& tenv, Constraints& c) const; + CVal compile(CEnv& cenv); +}; + +struct ADot : public ACall { + ADot(const ATuple* exp) : ACall(exp) {} + void constrain(TEnv& tenv, Constraints& c) const; + void lift(CEnv& cenv); + CVal compile(CEnv& cenv); +}; + +/// Primitive (builtin arithmetic function), e.g. "(+ 2 3)" +struct APrimitive : public ACall { + APrimitive(const ATuple* exp) : ACall(exp) {} + bool value() const { + ATuple::const_iterator i = begin(); + for (++i; i != end(); ++i) + if (!(*i)->value()) + return false;; + return true; + } + void constrain(TEnv& tenv, Constraints& c) const; + AST* cps(TEnv& tenv, AST* cont) const; + CVal compile(CEnv& cenv); +}; + + +/*************************************************************************** + * Parser: S-Expressions (SExp) -> AST Nodes (AST) * + ***************************************************************************/ + +/// Parse Time Environment (really just a symbol table) +struct PEnv : private map { + PEnv() : symID(0) {} + typedef AST* (*PF)(PEnv&, const AST*, void*); ///< Parse Function + typedef AST* (*MF)(PEnv&, const AST*); ///< Macro Function + struct Handler { Handler(PF f, void* a=0) : func(f), arg(a) {} PF func; void* arg; }; + map aHandlers; ///< Atom parse functions + map lHandlers; ///< List parse functions + map macros; ///< Macro functions + void reg(bool list, const string& s, const Handler& h) { + (list ? lHandlers : aHandlers).insert(make_pair(sym(s)->str(), h)); + } + const Handler* handler(bool list, const string& s) const { + const map& handlers = list ? lHandlers : aHandlers; + map::const_iterator i = handlers.find(s); + return (i != handlers.end()) ? &i->second : NULL; + } + void defmac(const string& s, const MF f) { + macros.insert(make_pair(s, f)); + } + MF mac(const AString& s) const { + map::const_iterator i = macros.find(s); + return (i != macros.end()) ? i->second : NULL; + } + string gensymstr(const char* s="_") { return (format("%s%d") % s % symID++).str(); } + ASymbol* gensym(const char* s="_") { return sym(gensymstr(s)); } + ASymbol* sym(const string& s, Cursor c=Cursor()) { + const const_iterator i = find(s); + if (i != end()) { + return i->second; + } else { + ASymbol* sym = new ASymbol(s, c); + insert(make_pair(s, sym)); + return sym; + } + } + ATuple* parseTuple(const ATuple* e) { + ATuple* ret = new ATuple(e->loc); + FOREACHP(ATuple::const_iterator, i, e) + ret->push_back(parse(*i)); + return ret; + } + AST* parse(const AST* exp) { + const ATuple* tup = exp->to(); + if (tup) { + if (tup->empty()) throw Error(exp->loc, "call to empty list"); + if (!tup->head()->to()) { + MF mf = mac(*tup->head()->to()); + const AST* expanded = (mf ? mf(*this, exp) : exp); + const ATuple* expanded_tup = expanded->to(); + const PEnv::Handler* h = handler(true, *expanded_tup->head()->to()); + if (h) + return h->func(*this, expanded, h->arg); + } + ATuple* parsed_tup = parseTuple(tup); + return new ACall(parsed_tup); // Parse as regular call + } + const AString* str = exp->to(); + assert(str); + if (isdigit((*str)[0])) { + const std::string& s = *str; + if (s.find('.') == string::npos) + return new ALiteral(strtol(s.c_str(), NULL, 10), exp->loc); + else + return new ALiteral(strtod(s.c_str(), NULL), exp->loc); + } else if ((*str)[0] == '\"') { + return new AString(exp->loc, str->substr(1, str->length() - 2)); + } else { + const PEnv::Handler* h = handler(false, *str); + if (h) + return h->func(*this, exp, h->arg); + } + return sym(*exp->to(), exp->loc); + } + unsigned symID; +}; + + +/*************************************************************************** + * Typing * + ***************************************************************************/ + +/// Type constraint +struct Constraint : public pair { + Constraint(AType* a, AType* b, Cursor c) : pair(a, b), loc(c) {} + Cursor loc; +}; + +/// Type constraint set +struct Constraints : public list { + void constrain(TEnv& tenv, const AST* o, AType* t); + void replace(AType* s, AType* t); +}; + +inline ostream& operator<<(ostream& out, const Constraints& c) { + for (Constraints::const_iterator i = c.begin(); i != c.end(); ++i) + out << i->first << " : " << i->second << endl; + return out; +} + +/// Type-Time Environment +struct TEnv : public Env { + TEnv(PEnv& p) + : penv(p) + , varID(1) + , Fn(new AType(penv.sym("Fn"))) + , Tup(new AType(penv.sym("Tup"))) + { + Object::pool.addRoot(Fn); + } + AType* fresh(const ASymbol* sym) { + return def(sym, new AType(sym->loc, varID++)); + } + AType* var(const AST* ast=0) { + if (!ast) + return new AType(Cursor(), varID++); + + const ASymbol* sym = ast->to(); + if (sym) + return *ref(sym); + + Vars::iterator v = vars.find(ast); + if (v != vars.end()) + return v->second; + + return (vars[ast] = new AType(ast->loc, varID++)); + } + AType* named(const string& name) { + return *ref(penv.sym(name)); + } + static Subst buildSubst(AType* fnT, const AType& argsT); + + typedef map Vars; + + Vars vars; + PEnv& penv; + unsigned varID; + + AType* Fn; + AType* Tup; +}; + +Subst unify(const Constraints& c); + + +/*************************************************************************** + * Code Generation * + ***************************************************************************/ + +/// Compiler backend +struct Engine { + virtual ~Engine() {} + + virtual CFunc startFunction( + CEnv& cenv, + const std::string& name, + const AType* retT, + const ATuple& argsT, + const vector argNames=vector()) = 0; + + virtual void finishFunction(CEnv& cenv, CFunc f, const AType* retT, CVal ret) = 0; + virtual void eraseFunction(CEnv& cenv, CFunc f) = 0; + virtual CFunc compileFunction(CEnv& cenv, AFn* fn, const AType& argsT) = 0; + virtual CVal compileTup(CEnv& cenv, const AType* t, const vector& f) = 0; + virtual CVal compileDot(CEnv& cenv, CVal tup, int32_t index) = 0; + virtual CVal compileLiteral(CEnv& cenv, AST* lit) = 0; + virtual CVal compileCall(CEnv& cenv, CFunc f, const vector& args) = 0; + virtual CVal compilePrimitive(CEnv& cenv, APrimitive* prim) = 0; + virtual CVal compileIf(CEnv& cenv, AIf* aif) = 0; + virtual CVal compileGlobal(CEnv& cenv, AType* t, const string& sym, CVal val) = 0; + virtual CVal getGlobal(CEnv& cenv, CVal val) = 0; + virtual void writeModule(CEnv& cenv, std::ostream& os) = 0; + + virtual const string call(CEnv& cenv, CFunc f, AType* retT) = 0; +}; + +Engine* resp_new_llvm_engine(); +Engine* resp_new_c_engine(); + +/// Compile-Time Environment +struct CEnv { + CEnv(PEnv& p, TEnv& t, Engine* e, ostream& os=std::cout, ostream& es=std::cerr) + : out(os), err(es), penv(p), tenv(t), _engine(e) + {} + + ~CEnv() { Object::pool.collect(GC::Roots()); } + + typedef Env Vals; + + Engine* engine() { return _engine; } + void push() { code.push(); tenv.push(); vals.push(); } + void pop() { code.pop(); tenv.pop(); vals.pop(); } + void lock(AST* ast) { Object::pool.addRoot(ast); Object::pool.addRoot(type(ast)); } + AType* type(AST* ast, const Subst& subst = Subst()) const { + ASymbol* sym = ast->to(); + if (sym) + return *tenv.ref(sym); + assert(tenv.vars[ast]); + return tsubst.apply(subst.apply(tenv.vars[ast]))->to(); + } + void def(const ASymbol* sym, AST* c, AType* t, CVal v) { + code.def(sym, c); + tenv.def(sym, t); + vals.def(sym, v); + } + AST* resolve(AST* ast) { + const ASymbol* sym = ast->to(); + AST** rec = code.ref(sym); + return rec ? *rec : ast; + } + + ostream& out; + ostream& err; + PEnv& penv; + TEnv& tenv; + Vals vals; + Subst tsubst; + + Env code; + + map args; + +private: + Engine* _engine; +}; + + +/*************************************************************************** + * EVAL/REPL/MAIN * + ***************************************************************************/ + +void pprint(std::ostream& out, const AST* ast); +void initLang(PEnv& penv, TEnv& tenv); +int eval(CEnv& cenv, const string& name, istream& is, bool execute); +int repl(CEnv& cenv); + +#endif // RESP_HPP diff --git a/src/resp_gc.cpp b/src/resp_gc.cpp new file mode 100644 index 0000000..4be07fb --- /dev/null +++ b/src/resp_gc.cpp @@ -0,0 +1,48 @@ +/* Resp: A programming language + * Copyright (C) 2008-2009 David Robillard + * + * Resp is free software: you can redistribute it and/or modify it under + * the terms of the GNU Affero General Public License as published by the + * Free Software Foundation, either version 3 of the License, or (at your + * option) any later version. + * + * Resp is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General + * Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with Resp. If not, see . + */ + +/** @file + * @brief Garbage collection shared library interface + */ + +#include "resp.hpp" +#include +#include +#include + +extern "C" { + +void* +resp_gc_allocate(unsigned size) +{ + static const size_t COLLECT_SIZE = 8 * 1024 * 1024; // 8 MiB + + static size_t allocated = 0; + allocated += size; + if (allocated > COLLECT_SIZE) { + Object::pool.collect(Object::pool.roots()); + allocated = 0; + } + + void* mem = Object::pool.alloc(size); + Object* obj = new (mem) Object(); + obj->tag(Object::OBJECT); + + return mem; +} + +} diff --git a/src/tuplr.cpp b/src/tuplr.cpp deleted file mode 100644 index 5f54480..0000000 --- a/src/tuplr.cpp +++ /dev/null @@ -1,149 +0,0 @@ -/* Tuplr: A programming language - * Copyright (C) 2008-2009 David Robillard - * - * Tuplr is free software: you can redistribute it and/or modify it under - * the terms of the GNU Affero General Public License as published by the - * Free Software Foundation, either version 3 of the License, or (at your - * option) any later version. - * - * Tuplr is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY - * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General - * Public License for more details. - * - * You should have received a copy of the GNU Affero General Public License - * along with Tuplr. If not, see . - */ - -/** @file - * @brief Main program - */ - -#include -#include -#include -#include "tuplr.hpp" - -using namespace std; - -GC Object::pool(8 * 1024 * 1024); - -int -print_usage(char* name, bool error) -{ - ostream& os = error ? cerr : cout; - os << "Usage: " << name << " [OPTION]... [FILE]..." << endl; - os << "Evaluate and/or compile Tuplr code" << endl; - os << endl; - os << " -h Display this help and exit" << endl; - os << " -r Enter REPL after evaluating files" << endl; - os << " -p Pretty-print input only" << endl; - os << " -b BACKEND Backend (llvm or c)" << endl; - os << " -g Debug (disable optimisation)" << endl; - os << " -d Dump assembly output" << endl; - os << " -e EXPRESSION Evaluate EXPRESSION" << endl; - os << " -o FILE Compile output to FILE (don't run)" << endl; - return error ? 1 : 0; -} - -int -main(int argc, char** argv) -{ - // Read command line arguments - map args; - list files; - for (int i = 1; i < argc; ++i) { - if (!strncmp(argv[i], "-h", 3)) { - return print_usage(argv[0], false); - } else if (argv[i][0] != '-') { - files.push_back(argv[i]); - } else if (!strncmp(argv[i], "-r", 3) - || !strncmp(argv[i], "-p", 3) - || !strncmp(argv[i], "-g", 3) - || !strncmp(argv[i], "-d", 3)) { - args.insert(make_pair(argv[i], "")); - } else if (i == argc-1 || argv[i+1][0] == '-') { - return print_usage(argv[0], true); - } else { - args.insert(make_pair(argv[i], argv[i+1])); - ++i; - } - } - - PEnv penv; - TEnv tenv(penv); - initLang(penv, tenv); - - Engine* engine = NULL; - - map::const_iterator a = args.find("-b"); - const string backend_name = (a != args.end() ? a->second : "llvm"); - - if (backend_name == "llvm") - engine = tuplr_new_llvm_engine(); - else if (backend_name == "c") - engine = tuplr_new_c_engine(); - - if (!engine) { - std::cerr << "Unable to open backend " << backend_name << std::endl; - return 1; - } - - CEnv* cenv = new CEnv(penv, tenv, engine); - cenv->args = args; - - Object::pool.lock(); - - int ret = 0; - - a = args.find("-o"); - bool batch = a != args.end(); - const string output = (a != args.end()) ? a->second : ""; - - if (args.find("-p") != args.end()) { - ifstream is(files.front().c_str()); - if (is.good()) { - Cursor loc; - AST* exp = readExpression(loc, is); - AST* ast = penv.parse(exp); - pprint(cout, ast); - } - return 0; - } - - a = args.find("-e"); - if (a != args.end()) { - istringstream is(a->second); - ret = eval(*cenv, "(command line)", is, !batch); - } - - for (list::iterator f = files.begin(); f != files.end(); ++f) { - ifstream is(f->c_str()); - if (is.good()) { - ret = ret | eval(*cenv, *f, is, !batch); - } else { - cerr << argv[0] << ": " << *f << ": " << strerror(errno) << endl; - ++ret; - } - is.close(); - } - - if (args.find("-r") != args.end() || (files.empty() && args.find("-e") == args.end())) - ret = repl(*cenv); - - if (output != "") { - ofstream os(output.c_str()); - if (os.good()) { - cenv->engine()->writeModule(*cenv, os); - } else { - cerr << argv[0] << ": " << a->second << ": " << strerror(errno) << endl; - ++ret; - } - os.close(); - } - - delete cenv; - delete engine; - - return ret; -} diff --git a/src/tuplr.hpp b/src/tuplr.hpp deleted file mode 100644 index 7cebaf4..0000000 --- a/src/tuplr.hpp +++ /dev/null @@ -1,727 +0,0 @@ -/* Tuplr: A programming language - * Copyright (C) 2008-2009 David Robillard - * - * Tuplr is free software: you can redistribute it and/or modify it under - * the terms of the GNU Affero General Public License as published by the - * Free Software Foundation, either version 3 of the License, or (at your - * option) any later version. - * - * Tuplr is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY - * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General - * Public License for more details. - * - * You should have received a copy of the GNU Affero General Public License - * along with Tuplr. If not, see . - */ - -/** @file - * @brief Interface and type definitions - */ - -#ifndef TUPLR_HPP -#define TUPLR_HPP - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#define FOREACH(IT, i, c) for (IT i = (c).begin(); i != (c).end(); ++i) -#define FOREACHP(IT, i, c) for (IT i = (c)->begin(); i != (c)->end(); ++i) -#define THROW_IF(cond, error, ...) { if (cond) throw Error(error, __VA_ARGS__); } - -using namespace std; -using boost::format; - - -/*************************************************************************** - * Basic Utility Classes * - ***************************************************************************/ - -/// Location in textual code -struct Cursor { - Cursor(const string& n="", unsigned l=1, unsigned c=0) : name(n), line(l), col(c) {} - operator bool() const { return !(line == 1 && col == 0); } - string str() const { return (format("%1%:%2%:%3%") % name % line % col).str(); } - string name; - unsigned line; - unsigned col; -}; - -/// Compiler error -struct Error { - Error(Cursor c, const string& m) : loc(c), msg(m) {} - const string what() const { return (loc ? loc.str() + ": " : "") + "error: " + msg; } - const Cursor loc; - const string msg; -}; - -/// Generic Lexical Environment -template -struct Env : public list< vector< pair > > { - typedef vector< pair > Frame; - Env() : list(1) {} - virtual ~Env() {} - virtual void push(Frame f=Frame()) { list::push_front(f); } - virtual void pop() { list::pop_front(); } - const V& def(const K& k, const V& v) { - for (typename Frame::iterator b = this->begin()->begin(); b != this->begin()->end(); ++b) - if (b->first == k) - return (b->second = v); - this->front().push_back(make_pair(k, v)); - return v; - } - V* ref(const K& key) { - for (typename Env::iterator f = this->begin(); f != this->end(); ++f) - for (typename Frame::iterator b = f->begin(); b != f->end(); ++b) - if (b->first == key) - return &b->second; - return NULL; - } - bool topLevel(const K& key) { - for (typename Frame::iterator b = this->back().begin(); b != this->back().end(); ++b) - if (b->first == key) - return true; - return false; - } -}; - -template -ostream& operator<<(ostream& out, const Env& env) { - out << "(Env" << endl; - for (typename Env::const_reverse_iterator f = env.rbegin(); f != env.rend(); ++f) { - out << " (" << endl; - for (typename Env::Frame::const_iterator b = f->begin(); b != f->end(); ++b) - cout << " " << b->first << " " << b->second << endl; - out << " )" << endl; - } - out << ")" << endl; - return out; -} - - -/*************************************************************************** - * Lexer: Text (istream) -> S-Expressions (SExp) * - ***************************************************************************/ - -class AST; -AST* readExpression(Cursor& cur, std::istream& in); - - -/*************************************************************************** - * Backend Types * - ***************************************************************************/ - -typedef void* CVal; ///< Compiled value (opaque) -typedef void* CFunc; ///< Compiled function (opaque) - - -/*************************************************************************** - * Garbage Collection * - ***************************************************************************/ - -struct Object; - -/// Garbage collector -struct GC { - typedef std::list Roots; - typedef std::list Heap; - GC(size_t pool_size); - ~GC(); - void* alloc(size_t size); - void collect(const Roots& roots); - void addRoot(const Object* obj) { assert(obj); _roots.push_back(obj); } - void lock() { _roots.insert(_roots.end(), _heap.begin(), _heap.end()); } - const Roots& roots() const { return _roots; } -private: - void* _pool; - Heap _heap; - Roots _roots; -}; - -/// Garbage collected object (including AST and runtime data) -struct Object { - enum Tag { OBJECT = 123, AST = 456 }; - - struct Header { - uint32_t mark; - uint32_t tag; - }; - - inline Tag tag() const { return (Tag)header()->tag; } - inline void tag(Tag t) { header()->tag = t; } - inline bool marked() const { return header()->mark != 0; } - inline void mark(bool b) const { header()->mark = (b ? 1 : 0); } - - static void* operator new(size_t size) { return pool.alloc(size); } - static void operator delete(void* ptr) {} - - // Memory used with placement new MUST always be allocated with pool.alloc! - static void* operator new(size_t size, void* ptr) { return ptr; } - - static GC pool; - -private: - /// Always allocated with pool.alloc, so this - sizeof(Header) is a valid Header*. - inline Header* header() const { return (Header*)((char*)this - sizeof(Header)); } -}; - - -/*************************************************************************** - * Abstract Syntax Tree * - ***************************************************************************/ - -struct TEnv; ///< Type-Time Environment -struct Constraints; ///< Type Constraints -struct Subst; ///< Type substitutions -struct CEnv; ///< Compile-Time Environment - -struct AST; -extern ostream& operator<<(ostream& out, const AST* ast); - -/// Base class for all AST nodes -struct AST : public Object { - AST(Cursor c=Cursor()) : loc(c) {} - virtual ~AST() {} - virtual bool value() const { return true; } - virtual bool operator==(const AST& o) const = 0; - virtual bool contains(const AST* child) const { return false; } - virtual void constrain(TEnv& tenv, Constraints& c) const {} - virtual AST* cps(TEnv& tenv, AST* cont); - virtual void lift(CEnv& cenv) {} - virtual CVal compile(CEnv& cenv) = 0; - string str() const { ostringstream ss; ss << this; return ss.str(); } - template T to() { return dynamic_cast(this); } - template T const to() const { return dynamic_cast(this); } - template T as() { - T t = dynamic_cast(this); - return t ? t : throw Error(loc, "internal error: bad cast"); - } - template T const as() const { - T const t = dynamic_cast(this); - return t ? t : throw Error(loc, "internal error: bad cast"); - } - Cursor loc; -}; - -template -static T* tup(Cursor c, AST* ast, ...) -{ - va_list args; - va_start(args, ast); - T* ret = new T(c, ast, args); - va_end(args); - return ret; -} - -/// Literal value -template -struct ALiteral : public AST { - ALiteral(T v, Cursor c) : AST(c), val(v) {} - bool operator==(const AST& rhs) const { - const ALiteral* r = rhs.to*>(); - return (r && (val == r->val)); - } - void constrain(TEnv& tenv, Constraints& c) const; - CVal compile(CEnv& cenv); - const T val; -}; - -/// String, e.g. ""a"" -struct AString : public AST, public std::string { - AString(Cursor c, const string& s) : AST(c), std::string(s) {} - bool operator==(const AST& rhs) const { return this == &rhs; } - void constrain(TEnv& tenv, Constraints& c) const; - CVal compile(CEnv& cenv) { return NULL; } -}; - -/// Symbol, e.g. "a" -struct ASymbol : public AST { - bool operator==(const AST& rhs) const { return this == &rhs; } - void constrain(TEnv& tenv, Constraints& c) const; - CVal compile(CEnv& cenv); - const string cppstr; -private: - friend class PEnv; - ASymbol(const string& s, Cursor c) : AST(c), cppstr(s) {} -}; - -/// Tuple (heterogeneous sequence of fixed length), e.g. "(a b c)" -struct ATuple : public AST { - ATuple(Cursor c) : AST(c), _len(0), _vec(0) {} - ATuple(const ATuple& exp) : AST(exp.loc), _len(exp._len) { - _vec = (AST**)malloc(sizeof(AST*) * _len); - memcpy(_vec, exp._vec, sizeof(AST*) * _len); - } - ATuple(Cursor c, AST* ast, va_list args) : AST(c), _len(0), _vec(0) { - if (!ast) return; - push_back(ast); - for (AST* a = va_arg(args, AST*); a; a = va_arg(args, AST*)) - push_back(a); - } - ~ATuple() { free(_vec); } - void push_back(AST* ast) { - AST** newvec = (AST**)realloc(_vec, sizeof(AST*) * (_len + 1)); - newvec[_len++] = ast; - _vec = newvec; - } - const AST* head() const { assert(_len > 0); return _vec[0]; } - AST* head() { assert(_len > 0); return _vec[0]; } - const AST* last() const { return _vec[_len - 1]; } - AST* last() { return _vec[_len - 1]; } - size_t size() const { return _len; } - bool empty() const { return _len == 0; } - - typedef AST** iterator; - typedef AST* const* const_iterator; - const_iterator begin() const { return _vec; } - iterator begin() { return _vec; } - const_iterator end() const { return _vec + _len; } - iterator end() { return _vec + _len; } - - bool value() const { return false; } - bool operator==(const AST& rhs) const { - const ATuple* rt = rhs.to(); - if (!rt || rt->size() != size()) return false; - const_iterator l = begin(); - FOREACHP(const_iterator, r, rt) - if (!(*(*l++) == *(*r))) - return false; - return true; - } - bool contains(AST* child) const { - if (*this == *child) return true; - FOREACHP(const_iterator, p, this) - if (**p == *child || (*p)->contains(child)) - return true; - return false; - } - void constrain(TEnv& tenv, Constraints& c) const; - void lift(CEnv& cenv) { FOREACHP(iterator, t, this) (*t)->lift(cenv); } - - CVal compile(CEnv& cenv) { throw Error(loc, "tuple compiled"); } - -private: - size_t _len; - AST** _vec; -}; - -/// Type Expression, e.g. "Int", "(Fn (Int Int) Float)" -struct AType : public ATuple { - enum Kind { VAR, PRIM, EXPR, DOTS }; - AType(ASymbol* s) : ATuple(s->loc), kind(PRIM), id(0) { push_back(s); } - AType(Cursor c, unsigned i) : ATuple(c), kind(VAR), id(i) {} - AType(Cursor c, Kind k=EXPR) : ATuple(c), kind(k), id(0) {} - AType(Cursor c, AST* ast, va_list args) : ATuple(c, ast, args), kind(EXPR), id(0) {} - AType(const AType& copy) : ATuple(copy), kind(copy.kind), id(copy.id) {} - CVal compile(CEnv& cenv) { return NULL; } - const ATuple* prot() const { assert(kind == EXPR); return (*(begin() + 1))->to(); } - ATuple* prot() { assert(kind == EXPR); return (*(begin() + 1))->to(); } - bool concrete() const { - switch (kind) { - case VAR: return false; - case PRIM: return head()->str() != "Nothing"; - case EXPR: - FOREACHP(const_iterator, t, this) { - AType* kid = (*t)->to(); - if (kid && !kid->concrete()) - return false; - } - } - return true; - } - bool operator==(const AST& rhs) const { - const AType* rt = rhs.to(); - if (!rt || kind != rt->kind) - return false; - else - switch (kind) { - case VAR: return id == rt->id; - case PRIM: return head()->str() == rt->head()->str(); - case EXPR: return ATuple::operator==(rhs); - } - return false; // never reached - } - Kind kind; - unsigned id; -}; - -/// Type substitution -struct Subst : public list< pair > { - Subst(AType* s=0, AType* t=0) { if (s && t) { assert(s != t); push_back(make_pair(s, t)); } } - static Subst compose(const Subst& delta, const Subst& gamma); - void add(const AType* from, AType* to) { push_back(make_pair(from, to)); } - const_iterator find(const AType* t) const { - for (const_iterator j = begin(); j != end(); ++j) - if (*j->first == *t) - return j; - return end(); - } - AType* apply(const AType* in) const { - if (in->kind == AType::EXPR) { - AType* out = tup(in->loc, NULL); - for (ATuple::const_iterator i = in->begin(); i != in->end(); ++i) - out->push_back(apply((*i)->as())); - return out; - } else { - const_iterator i = find(in); - if (i != end()) { - AType* out = i->second->as(); - if (out->kind == AType::EXPR && !out->concrete()) - out = apply(out->as()); - return out; - } else { - return new AType(*in); - } - } - } -}; - -inline ostream& operator<<(ostream& out, const Subst& s) { - for (Subst::const_iterator i = s.begin(); i != s.end(); ++i) - out << i->first << " => " << i->second << endl; - return out; -} - -/// Fn (first-class function with captured lexical bindings) -struct AFn : public ATuple { - AFn(Cursor c, AST* ast, va_list args) : ATuple(c, ast, args) {} - bool operator==(const AST& rhs) const { return this == &rhs; } - void constrain(TEnv& tenv, Constraints& c) const; - AST* cps(TEnv& tenv, AST* cont); - void lift(CEnv& cenv); - CVal compile(CEnv& cenv); - const ATuple* prot() const { return (*(begin() + 1))->to(); } - ATuple* prot() { return (*(begin() + 1))->to(); } - /// System level implementations of this (polymorphic) fn - struct Impls : public list< pair > { - CFunc find(AType* type) const { - for (const_iterator f = begin(); f != end(); ++f) - if (*f->first == *type) - return f->second; - return NULL; - } - }; - Impls impls; - string name; -}; - -/// Function call/application, e.g. "(func arg1 arg2)" -struct ACall : public ATuple { - ACall(const ATuple* exp) : ATuple(*exp) {} - ACall(Cursor c, AST* ast, va_list args) : ATuple(c, ast, args) {} - void constrain(TEnv& tenv, Constraints& c) const; - AST* cps(TEnv& tenv, AST* cont); - void lift(CEnv& cenv); - CVal compile(CEnv& cenv); -}; - -/// Definition special form, e.g. "(def x 2)" -struct ADef : public ACall { - ADef(const ATuple* exp) : ACall(exp) {} - ADef(Cursor c, AST* ast, va_list args) : ACall(c, ast, args) {} - const ASymbol* sym() const { - const AST* name = *(begin() + 1); - const ASymbol* sym = name->to(); - if (!sym) { - const ATuple* tup = name->to(); - if (tup && !tup->empty()) - return tup->head()->to(); - } - return sym; - } - const AST* body() const { return *(begin() + 2); } - AST* body() { return *(begin() + 2); } - void constrain(TEnv& tenv, Constraints& c) const; - AST* cps(TEnv& tenv, AST* cont); - void lift(CEnv& cenv); - CVal compile(CEnv& cenv); -}; - -/// Conditional special form, e.g. "(if cond thenexp elseexp)" -struct AIf : public ACall { - AIf(const ATuple* exp) : ACall(exp) {} - AIf(Cursor c, AST* ast, va_list args) : ACall(c, ast, args) {} - void constrain(TEnv& tenv, Constraints& c) const; - AST* cps(TEnv& tenv, AST* cont); - CVal compile(CEnv& cenv); -}; - -struct ACons : public ACall { - ACons(const ATuple* exp) : ACall(exp) {} - void constrain(TEnv& tenv, Constraints& c) const; - CVal compile(CEnv& cenv); -}; - -struct ADot : public ACall { - ADot(const ATuple* exp) : ACall(exp) {} - void constrain(TEnv& tenv, Constraints& c) const; - void lift(CEnv& cenv); - CVal compile(CEnv& cenv); -}; - -/// Primitive (builtin arithmetic function), e.g. "(+ 2 3)" -struct APrimitive : public ACall { - APrimitive(const ATuple* exp) : ACall(exp) {} - bool value() const { - ATuple::const_iterator i = begin(); - for (++i; i != end(); ++i) - if (!(*i)->value()) - return false;; - return true; - } - void constrain(TEnv& tenv, Constraints& c) const; - AST* cps(TEnv& tenv, AST* cont); - CVal compile(CEnv& cenv); -}; - - -/*************************************************************************** - * Parser: S-Expressions (SExp) -> AST Nodes (AST) * - ***************************************************************************/ - -/// Parse Time Environment (really just a symbol table) -struct PEnv : private map { - PEnv() : symID(0) {} - typedef AST* (*PF)(PEnv&, const AST*, void*); ///< Parse Function - typedef AST* (*MF)(PEnv&, const AST*); ///< Macro Function - struct Handler { Handler(PF f, void* a=0) : func(f), arg(a) {} PF func; void* arg; }; - map aHandlers; ///< Atom parse functions - map lHandlers; ///< List parse functions - map macros; ///< Macro functions - void reg(bool list, const string& s, const Handler& h) { - (list ? lHandlers : aHandlers).insert(make_pair(sym(s)->str(), h)); - } - const Handler* handler(bool list, const string& s) const { - const map& handlers = list ? lHandlers : aHandlers; - map::const_iterator i = handlers.find(s); - return (i != handlers.end()) ? &i->second : NULL; - } - void defmac(const string& s, const MF f) { - macros.insert(make_pair(s, f)); - } - MF mac(const AString& s) const { - map::const_iterator i = macros.find(s); - return (i != macros.end()) ? i->second : NULL; - } - string gensymstr(const char* s="_") { return (format("%s%d") % s % symID++).str(); } - ASymbol* gensym(const char* s="_") { return sym(gensymstr(s)); } - ASymbol* sym(const string& s, Cursor c=Cursor()) { - const const_iterator i = find(s); - if (i != end()) { - return i->second; - } else { - ASymbol* sym = new ASymbol(s, c); - insert(make_pair(s, sym)); - return sym; - } - } - ATuple* parseTuple(const ATuple* e) { - ATuple* ret = new ATuple(e->loc); - FOREACHP(ATuple::const_iterator, i, e) - ret->push_back(parse(*i)); - return ret; - } - AST* parse(const AST* exp) { - const ATuple* tup = exp->to(); - if (tup) { - if (tup->empty()) throw Error(exp->loc, "call to empty list"); - if (!tup->head()->to()) { - MF mf = mac(*tup->head()->to()); - const AST* expanded = (mf ? mf(*this, exp) : exp); - const ATuple* expanded_tup = expanded->to(); - const PEnv::Handler* h = handler(true, *expanded_tup->head()->to()); - if (h) - return h->func(*this, expanded, h->arg); - } - ATuple* parsed_tup = parseTuple(tup); - return new ACall(parsed_tup); // Parse as regular call - } - const AString* str = exp->to(); - assert(str); - if (isdigit((*str)[0])) { - const std::string& s = *str; - if (s.find('.') == string::npos) - return new ALiteral(strtol(s.c_str(), NULL, 10), exp->loc); - else - return new ALiteral(strtod(s.c_str(), NULL), exp->loc); - } else if ((*str)[0] == '\"') { - return new AString(exp->loc, str->substr(1, str->length() - 2)); - } else { - const PEnv::Handler* h = handler(false, *str); - if (h) - return h->func(*this, exp, h->arg); - } - return sym(*exp->to(), exp->loc); - } - unsigned symID; -}; - - -/*************************************************************************** - * Typing * - ***************************************************************************/ - -/// Type constraint -struct Constraint : public pair { - Constraint(AType* a, AType* b, Cursor c) : pair(a, b), loc(c) {} - Cursor loc; -}; - -/// Type constraint set -struct Constraints : public list { - void constrain(TEnv& tenv, const AST* o, AType* t); - void replace(AType* s, AType* t); -}; - -inline ostream& operator<<(ostream& out, const Constraints& c) { - for (Constraints::const_iterator i = c.begin(); i != c.end(); ++i) - out << i->first << " : " << i->second << endl; - return out; -} - -/// Type-Time Environment -struct TEnv : public Env { - TEnv(PEnv& p) - : penv(p) - , varID(1) - , Fn(new AType(penv.sym("Fn"))) - , Tup(new AType(penv.sym("Tup"))) - { - Object::pool.addRoot(Fn); - } - AType* fresh(const ASymbol* sym) { - return def(sym, new AType(sym->loc, varID++)); - } - AType* var(const AST* ast=0) { - if (!ast) - return new AType(Cursor(), varID++); - - const ASymbol* sym = ast->to(); - if (sym) - return *ref(sym); - - Vars::iterator v = vars.find(ast); - if (v != vars.end()) - return v->second; - - return (vars[ast] = new AType(ast->loc, varID++)); - } - AType* named(const string& name) { - return *ref(penv.sym(name)); - } - static Subst buildSubst(AType* fnT, const AType& argsT); - - typedef map Vars; - - Vars vars; - PEnv& penv; - unsigned varID; - - AType* Fn; - AType* Tup; -}; - -Subst unify(const Constraints& c); - - -/*************************************************************************** - * Code Generation * - ***************************************************************************/ - -/// Compiler backend -struct Engine { - virtual ~Engine() {} - - virtual CFunc startFunction( - CEnv& cenv, - const std::string& name, - const AType* retT, - const ATuple& argsT, - const vector argNames=vector()) = 0; - - virtual void finishFunction(CEnv& cenv, CFunc f, const AType* retT, CVal ret) = 0; - virtual void eraseFunction(CEnv& cenv, CFunc f) = 0; - virtual CFunc compileFunction(CEnv& cenv, AFn* fn, const AType& argsT) = 0; - virtual CVal compileTup(CEnv& cenv, const AType* t, const vector& f) = 0; - virtual CVal compileDot(CEnv& cenv, CVal tup, int32_t index) = 0; - virtual CVal compileLiteral(CEnv& cenv, AST* lit) = 0; - virtual CVal compileCall(CEnv& cenv, CFunc f, const vector& args) = 0; - virtual CVal compilePrimitive(CEnv& cenv, APrimitive* prim) = 0; - virtual CVal compileIf(CEnv& cenv, AIf* aif) = 0; - virtual CVal compileGlobal(CEnv& cenv, AType* t, const string& sym, CVal val) = 0; - virtual CVal getGlobal(CEnv& cenv, CVal val) = 0; - virtual void writeModule(CEnv& cenv, std::ostream& os) = 0; - - virtual const string call(CEnv& cenv, CFunc f, AType* retT) = 0; -}; - -Engine* tuplr_new_llvm_engine(); -Engine* tuplr_new_c_engine(); - -/// Compile-Time Environment -struct CEnv { - CEnv(PEnv& p, TEnv& t, Engine* e, ostream& os=std::cout, ostream& es=std::cerr) - : out(os), err(es), penv(p), tenv(t), _engine(e) - {} - - ~CEnv() { Object::pool.collect(GC::Roots()); } - - typedef Env Vals; - - Engine* engine() { return _engine; } - void push() { code.push(); tenv.push(); vals.push(); } - void pop() { code.pop(); tenv.pop(); vals.pop(); } - void lock(AST* ast) { Object::pool.addRoot(ast); Object::pool.addRoot(type(ast)); } - AType* type(AST* ast, const Subst& subst = Subst()) const { - ASymbol* sym = ast->to(); - if (sym) - return *tenv.ref(sym); - assert(tenv.vars[ast]); - return tsubst.apply(subst.apply(tenv.vars[ast]))->to(); - } - void def(const ASymbol* sym, AST* c, AType* t, CVal v) { - code.def(sym, c); - tenv.def(sym, t); - vals.def(sym, v); - } - AST* resolve(AST* ast) { - const ASymbol* sym = ast->to(); - AST** rec = code.ref(sym); - return rec ? *rec : ast; - } - - ostream& out; - ostream& err; - PEnv& penv; - TEnv& tenv; - Vals vals; - Subst tsubst; - - Env code; - - map args; - -private: - Engine* _engine; -}; - - -/*************************************************************************** - * EVAL/REPL/MAIN * - ***************************************************************************/ - -void pprint(std::ostream& out, const AST* ast); -void initLang(PEnv& penv, TEnv& tenv); -int eval(CEnv& cenv, const string& name, istream& is, bool execute); -int repl(CEnv& cenv); - -#endif // TUPLR_HPP diff --git a/src/tuplr_gc.cpp b/src/tuplr_gc.cpp deleted file mode 100644 index 7bd35a4..0000000 --- a/src/tuplr_gc.cpp +++ /dev/null @@ -1,48 +0,0 @@ -/* Tuplr: A programming language - * Copyright (C) 2008-2009 David Robillard - * - * Tuplr is free software: you can redistribute it and/or modify it under - * the terms of the GNU Affero General Public License as published by the - * Free Software Foundation, either version 3 of the License, or (at your - * option) any later version. - * - * Tuplr is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY - * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General - * Public License for more details. - * - * You should have received a copy of the GNU Affero General Public License - * along with Tuplr. If not, see . - */ - -/** @file - * @brief Garbage collection shared library interface - */ - -#include "tuplr.hpp" -#include -#include -#include - -extern "C" { - -void* -tuplr_gc_allocate(unsigned size) -{ - static const size_t COLLECT_SIZE = 8 * 1024 * 1024; // 8 MiB - - static size_t allocated = 0; - allocated += size; - if (allocated > COLLECT_SIZE) { - Object::pool.collect(Object::pool.roots()); - allocated = 0; - } - - void* mem = Object::pool.alloc(size); - Object* obj = new (mem) Object(); - obj->tag(Object::OBJECT); - - return mem; -} - -} diff --git a/src/unify.cpp b/src/unify.cpp index dbc938f..3f06868 100644 --- a/src/unify.cpp +++ b/src/unify.cpp @@ -1,18 +1,18 @@ -/* Tuplr Unification +/* Resp Unification * Copyright (C) 2008-2009 David Robillard * - * Tuplr is free software: you can redistribute it and/or modify it under + * Resp is free software: you can redistribute it and/or modify it under * the terms of the GNU Affero General Public License as published by the * Free Software Foundation, either version 3 of the License, or (at your * option) any later version. * - * Tuplr is distributed in the hope that it will be useful, but WITHOUT + * Resp is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General * Public License for more details. * * You should have received a copy of the GNU Affero General Public License - * along with Tuplr. If not, see . + * along with Resp. If not, see . */ /** @file @@ -20,7 +20,7 @@ */ #include -#include "tuplr.hpp" +#include "resp.hpp" /** Build a type substitution for calling a generic function type * with a specific set of argument types diff --git a/test.sh b/test.sh index d7e4043..bc54159 100755 --- a/test.sh +++ b/test.sh @@ -3,7 +3,7 @@ run() { prog=$1 desired=$2 - out=`./build/tuplr $prog` + out=`./build/resp $prog` if [ "$out" != "$desired" ]; then echo "FAIL: $prog"; echo " Expected: \"$desired\""; @@ -13,9 +13,9 @@ run() { fi } -run './test/ack.tpr' '8189 : Int' -run './test/def.tpr' '3 : Int' -run './test/fac.tpr' '720 : Int' -run './test/poly.tpr' '#t : Bool' -run './test/nest.tpr' '6 : Int' -run './test/tup.tpr' '5 : Int' +run './test/ack.resp' '8189 : Int' +run './test/def.resp' '3 : Int' +run './test/fac.resp' '720 : Int' +run './test/poly.resp' '#t : Bool' +run './test/nest.resp' '6 : Int' +run './test/tup.resp' '5 : Int' diff --git a/test/ack.resp b/test/ack.resp new file mode 100644 index 0000000..76fb397 --- /dev/null +++ b/test/ack.resp @@ -0,0 +1,7 @@ +(def (ack m n) + (if (= 0 m) (+ n 1) + (= 0 n) (ack (- m 1) 1) + (ack (- m 1) (ack m (- n 1))))) + +(ack 3 10) + diff --git a/test/ack.tpr b/test/ack.tpr deleted file mode 100644 index 76fb397..0000000 --- a/test/ack.tpr +++ /dev/null @@ -1,7 +0,0 @@ -(def (ack m n) - (if (= 0 m) (+ n 1) - (= 0 n) (ack (- m 1) 1) - (ack (- m 1) (ack m (- n 1))))) - -(ack 3 10) - diff --git a/test/def.resp b/test/def.resp new file mode 100644 index 0000000..dd9a0c8 --- /dev/null +++ b/test/def.resp @@ -0,0 +1,8 @@ +(def foo + (fn (x) + (def y 2) + (def z 3) + z)) + +(foo 3) + diff --git a/test/def.tpr b/test/def.tpr deleted file mode 100644 index dd9a0c8..0000000 --- a/test/def.tpr +++ /dev/null @@ -1,8 +0,0 @@ -(def foo - (fn (x) - (def y 2) - (def z 3) - z)) - -(foo 3) - diff --git a/test/fac.resp b/test/fac.resp new file mode 100644 index 0000000..0fb687c --- /dev/null +++ b/test/fac.resp @@ -0,0 +1,7 @@ +; Factorial +(def (fac n) + (if (= 0 n) 1 + (* n (fac (- n 1))))) + +(fac 6) + diff --git a/test/fac.tpr b/test/fac.tpr deleted file mode 100644 index 0fb687c..0000000 --- a/test/fac.tpr +++ /dev/null @@ -1,7 +0,0 @@ -; Factorial -(def (fac n) - (if (= 0 n) 1 - (* n (fac (- n 1))))) - -(fac 6) - diff --git a/test/intro.resp b/test/intro.resp new file mode 100644 index 0000000..bf8d8c8 --- /dev/null +++ b/test/intro.resp @@ -0,0 +1,148 @@ +;;; NOTE: This document is just a draft idea sketch pad + +;;; Data types + +; Resp uses algebraic datatypes which can also be used in an +; object based style with more flexibility than typical of +; languages with algebraic datatypes +; +; There is a single way of defining a type (the 'type' form) which +; encompasses unions, records, objects, etc. + +; A type is a discriminated union ("or") of types. +; Type names (including variables) always start with an uppercase letter. + +; There are many equivalent terms for kinds of types. We uniformly use: +; "Union" : "and", sum type +; "Record" : "or", product type, object, struct + +; Example: A Tree is a Node with a value and left/right children, or Nothing +; "Nothing" and "Node" are called constructors. In this case both are Records +(type (Tree T) + (Nothing) + (Node value :T + left :(Tree T) + right :(Tree T))) + +; Constructors have one of two forms: +; Union constructors have parameters enclosed in parenthesis, e.g. +; (Maybe (Nothing) (Just x)) +; Record constructors do not, e.g. +; (Point x y) +; +; Thus, types can be arbitrarily combined/nested, e.g +(type (Collection T) + (Tree + (Nothing) + (Node value :T + left :(Tree T) + right :(Tree T))) + (List + (Nothing) + (Node value :T + next :(List T)))) + +; Tree height (functional pattern matching style) +(def (height t) + (match t:Tree + (Empty) 0 + (Node v l r) (+ 1 (max (height l) (height r))))) + +; equivalently +(def (height t) + (match t + (Tree.Empty) 0 + (Tree.Node v l r) (+ 1 (max (height l) (height r))))) + +; GADTs +; The return type of a constructor can be specified explicitly +; e.g. a well-typed evaluator (this is not possible without GADTs): +; (http://www.haskell.org/ghc/docs/latest/html/users_guide/data-type-extensions.html#gadt) +(type (Term T) + (Lit i :Int) :(Term Int) + (Succ t :Int) :(Term Int) + (IsZero t :Int) :(Term Bool) + (If c :Bool + t :(Term T) + e :(Term T)) :(Term T) + (Pair a :(Term T) + b :(Term T)) :(Term T)) + +; Objects +; A type with a single product constructor is simply that product type +; (i.e. sum types with a single element do not exist by definition) +; This can be used to create "record" or "object" types without any special +; language facilities: +(type (Person) + (Person + name :String + age :Number)) + +; The '.' ("dot") operator can be used to inspect product types + +(def dave (Person 'name "Dave" 'age 27)) + +(. dave name) ; => "Dave" +(. dave age) ; => 27 + + +;; Everything Is A ... + +; Everything in Resp is a closure. Records are simply closures with some +; internal definitions exposed (much like modules). + +; Objects can be created with their constructors: +(def steve (Person "Steve" 24)) + +; Equivalently (aside from type) with the generic Object constructor: +(def steve2 (Object 'name "Steve" 'age 24)) + +; Equivalently (aside from type) manually: +(def steve2 + (fn () + (def name "Steve") + (def age 24) + (export name age))) + +;; RDF style objects + +; A class is just an object (closure) with some required properties (ala OWL) +; All object fields have a URI. If a prefix is not explicitly given, the URI +; is the base URI of the document, followed by the Class, a dot, then the name. +; e.g. if the base URI of this document is "foo://bar/" the URI of "age" below is: +; foo://bar/Person.age + +(ns foaf "http://xmlns.com/foaf/0.1/") +(ns geom "http://www.charlestoncore.org/ontology/2005/08/geometry") + +(def (Point T) + (Point + geom.x :T + geom.y :T)) + +(type (Person) + foaf.name :String + age :Number) + +(type (Cat) + foaf.name :String + age :Number) + +; A 'constructor' (nothing special, just a function that returns a closure) +(def (newborn name) + (fn () + (def type Person) ; special, compiler will check required properties exist + (def foaf.name name) + (def age 1))) + +; Equivalently, +(def (newborn name) + (Person + foaf.name name + age 1)) + +(def stewie (newborn "Stewie")) +(def stewies-age (. stewie age)) + + + diff --git a/test/intro.tpr b/test/intro.tpr deleted file mode 100644 index 73a21bb..0000000 --- a/test/intro.tpr +++ /dev/null @@ -1,148 +0,0 @@ -;;; NOTE: This document is just a draft idea sketch pad - -;;; Data types - -; Tuplr uses algebraic datatypes which can also be used in an -; object based style with more flexibility than typical of -; languages with algebraic datatypes -; -; There is a single way of defining a type (the 'type' form) which -; encompasses unions, records, objects, etc. - -; A type is a discriminated union ("or") of types. -; Type names (including variables) always start with an uppercase letter. - -; There are many equivalent terms for kinds of types. We uniformly use: -; "Union" : "and", sum type -; "Record" : "or", product type, object, struct - -; Example: A Tree is a Node with a value and left/right children, or Nothing -; "Nothing" and "Node" are called constructors. In this case both are Records -(type (Tree T) - (Nothing) - (Node value :T - left :(Tree T) - right :(Tree T))) - -; Constructors have one of two forms: -; Union constructors have parameters enclosed in parenthesis, e.g. -; (Maybe (Nothing) (Just x)) -; Record constructors do not, e.g. -; (Point x y) -; -; Thus, types can be arbitrarily combined/nested, e.g -(type (Collection T) - (Tree - (Nothing) - (Node value :T - left :(Tree T) - right :(Tree T))) - (List - (Nothing) - (Node value :T - next :(List T)))) - -; Tree height (functional pattern matching style) -(def (height t) - (match t:Tree - (Empty) 0 - (Node v l r) (+ 1 (max (height l) (height r))))) - -; equivalently -(def (height t) - (match t - (Tree.Empty) 0 - (Tree.Node v l r) (+ 1 (max (height l) (height r))))) - -; GADTs -; The return type of a constructor can be specified explicitly -; e.g. a well-typed evaluator (this is not possible without GADTs): -; (http://www.haskell.org/ghc/docs/latest/html/users_guide/data-type-extensions.html#gadt) -(type (Term T) - (Lit i :Int) :(Term Int) - (Succ t :Int) :(Term Int) - (IsZero t :Int) :(Term Bool) - (If c :Bool - t :(Term T) - e :(Term T)) :(Term T) - (Pair a :(Term T) - b :(Term T)) :(Term T)) - -; Objects -; A type with a single product constructor is simply that product type -; (i.e. sum types with a single element do not exist by definition) -; This can be used to create "record" or "object" types without any special -; language facilities: -(type (Person) - (Person - name :String - age :Number)) - -; The '.' ("dot") operator can be used to inspect product types - -(def dave (Person 'name "Dave" 'age 27)) - -(. dave name) ; => "Dave" -(. dave age) ; => 27 - - -;; Everything Is A ... - -; Everything in Tuplr is a closure. Records are simply closures with some -; internal definitions exposed (much like modules). - -; Objects can be created with their constructors: -(def steve (Person "Steve" 24)) - -; Equivalently (aside from type) with the generic Object constructor: -(def steve2 (Object 'name "Steve" 'age 24)) - -; Equivalently (aside from type) manually: -(def steve2 - (fn () - (def name "Steve") - (def age 24) - (export name age))) - -;; RDF style objects - -; A class is just an object (closure) with some required properties (ala OWL) -; All object fields have a URI. If a prefix is not explicitly given, the URI -; is the base URI of the document, followed by the Class, a dot, then the name. -; e.g. if the base URI of this document is "foo://bar/" the URI of "age" below is: -; foo://bar/Person.age - -(ns foaf "http://xmlns.com/foaf/0.1/") -(ns geom "http://www.charlestoncore.org/ontology/2005/08/geometry") - -(def (Point T) - (Point - geom.x :T - geom.y :T)) - -(type (Person) - foaf.name :String - age :Number) - -(type (Cat) - foaf.name :String - age :Number) - -; A 'constructor' (nothing special, just a function that returns a closure) -(def (newborn name) - (fn () - (def type Person) ; special, compiler will check required properties exist - (def foaf.name name) - (def age 1))) - -; Equivalently, -(def (newborn name) - (Person - foaf.name name - age 1)) - -(def stewie (newborn "Stewie")) -(def stewies-age (. stewie age)) - - - diff --git a/test/nest.resp b/test/nest.resp new file mode 100644 index 0000000..3085737 --- /dev/null +++ b/test/nest.resp @@ -0,0 +1,6 @@ +(def (f x) + (def (g y) + (* y 2)) + (g x)) + +(f 3) diff --git a/test/nest.tpr b/test/nest.tpr deleted file mode 100644 index 3085737..0000000 --- a/test/nest.tpr +++ /dev/null @@ -1,6 +0,0 @@ -(def (f x) - (def (g y) - (* y 2)) - (g x)) - -(f 3) diff --git a/test/poly.resp b/test/poly.resp new file mode 100644 index 0000000..33922e3 --- /dev/null +++ b/test/poly.resp @@ -0,0 +1,6 @@ +(def eq (fn (x y) (= x y))) + +(eq 1 2) +(eq 1 1) +(eq 10.0 20.0) +(eq 10.0 10.0) diff --git a/test/poly.tpr b/test/poly.tpr deleted file mode 100644 index 33922e3..0000000 --- a/test/poly.tpr +++ /dev/null @@ -1,6 +0,0 @@ -(def eq (fn (x y) (= x y))) - -(eq 1 2) -(eq 1 1) -(eq 10.0 20.0) -(eq 10.0 10.0) diff --git a/test/tup.resp b/test/tup.resp new file mode 100644 index 0000000..17d59cb --- /dev/null +++ b/test/tup.resp @@ -0,0 +1,6 @@ +(def t (cons 1 2 3 4 5)) +(. t 0) +(. t 1) +(. t 2) +(. t 3) +(. t 4) diff --git a/test/tup.tpr b/test/tup.tpr deleted file mode 100644 index 17d59cb..0000000 --- a/test/tup.tpr +++ /dev/null @@ -1,6 +0,0 @@ -(def t (cons 1 2 3 4 5)) -(. t 0) -(. t 1) -(. t 2) -(. t 3) -(. t 4) diff --git a/tuplr.dox b/tuplr.dox deleted file mode 100644 index 42ff6ce..0000000 --- a/tuplr.dox +++ /dev/null @@ -1,1523 +0,0 @@ -# Doxyfile 1.5.8 - -# This file describes the settings to be used by the documentation system -# doxygen (www.doxygen.org) for a project -# -# All text after a hash (#) is considered a comment and will be ignored -# The format is: -# TAG = value [value, ...] -# For lists items can also be appended using: -# TAG += value [value, ...] -# Values that contain spaces should be placed between quotes (" ") - -#--------------------------------------------------------------------------- -# Project related configuration options -#--------------------------------------------------------------------------- - -# This tag specifies the encoding used for all characters in the config file -# that follow. The default is UTF-8 which is also the encoding used for all -# text before the first occurrence of this tag. Doxygen uses libiconv (or the -# iconv built into libc) for the transcoding. See -# http://www.gnu.org/software/libiconv for the list of possible encodings. - -DOXYFILE_ENCODING = UTF-8 - -# The PROJECT_NAME tag is a single word (or a sequence of words surrounded -# by quotes) that should identify the project. - -PROJECT_NAME = Tuplr - -# The PROJECT_NUMBER tag can be used to enter a project or revision number. -# This could be handy for archiving the generated documentation or -# if some version control system is used. - -PROJECT_NUMBER = 0.0 - -# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) -# base path where the generated documentation will be put. -# If a relative path is entered, it will be relative to the location -# where doxygen was started. If left blank the current directory will be used. - -OUTPUT_DIRECTORY = build/doc - -# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create -# 4096 sub-directories (in 2 levels) under the output directory of each output -# format and will distribute the generated files over these directories. -# Enabling this option can be useful when feeding doxygen a huge amount of -# source files, where putting all generated files in the same directory would -# otherwise cause performance problems for the file system. - -CREATE_SUBDIRS = NO - -# The OUTPUT_LANGUAGE tag is used to specify the language in which all -# documentation generated by doxygen is written. Doxygen will use this -# information to generate all constant output in the proper language. -# The default language is English, other supported languages are: -# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional, -# Croatian, Czech, Danish, Dutch, Farsi, Finnish, French, German, Greek, -# Hungarian, Italian, Japanese, Japanese-en (Japanese with English messages), -# Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian, Polish, -# Portuguese, Romanian, Russian, Serbian, Serbian-Cyrilic, Slovak, Slovene, -# Spanish, Swedish, and Ukrainian. - -OUTPUT_LANGUAGE = English - -# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will -# include brief member descriptions after the members that are listed in -# the file and class documentation (similar to JavaDoc). -# Set to NO to disable this. - -BRIEF_MEMBER_DESC = NO - -# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend -# the brief description of a member or function before the detailed description. -# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the -# brief descriptions will be completely suppressed. - -REPEAT_BRIEF = NO - -# This tag implements a quasi-intelligent brief description abbreviator -# that is used to form the text in various listings. Each string -# in this list, if found as the leading text of the brief description, will be -# stripped from the text and the result after processing the whole list, is -# used as the annotated text. Otherwise, the brief description is used as-is. -# If left blank, the following values are used ("$name" is automatically -# replaced with the name of the entity): "The $name class" "The $name widget" -# "The $name file" "is" "provides" "specifies" "contains" -# "represents" "a" "an" "the" - -ABBREVIATE_BRIEF = - -# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then -# Doxygen will generate a detailed section even if there is only a brief -# description. - -ALWAYS_DETAILED_SEC = NO - -# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all -# inherited members of a class in the documentation of that class as if those -# members were ordinary class members. Constructors, destructors and assignment -# operators of the base classes will not be shown. - -INLINE_INHERITED_MEMB = NO - -# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full -# path before files name in the file list and in the header files. If set -# to NO the shortest path that makes the file name unique will be used. - -FULL_PATH_NAMES = NO - -# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag -# can be used to strip a user-defined part of the path. Stripping is -# only done if one of the specified strings matches the left-hand part of -# the path. The tag can be used to show relative paths in the file list. -# If left blank the directory from which doxygen is run is used as the -# path to strip. - -STRIP_FROM_PATH = - -# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of -# the path mentioned in the documentation of a class, which tells -# the reader which header file to include in order to use a class. -# If left blank only the name of the header file containing the class -# definition is used. Otherwise one should specify the include paths that -# are normally passed to the compiler using the -I flag. - -STRIP_FROM_INC_PATH = - -# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter -# (but less readable) file names. This can be useful is your file systems -# doesn't support long names like on DOS, Mac, or CD-ROM. - -SHORT_NAMES = NO - -# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen -# will interpret the first line (until the first dot) of a JavaDoc-style -# comment as the brief description. If set to NO, the JavaDoc -# comments will behave just like regular Qt-style comments -# (thus requiring an explicit @brief command for a brief description.) - -JAVADOC_AUTOBRIEF = YES - -# If the QT_AUTOBRIEF tag is set to YES then Doxygen will -# interpret the first line (until the first dot) of a Qt-style -# comment as the brief description. If set to NO, the comments -# will behave just like regular Qt-style comments (thus requiring -# an explicit \brief command for a brief description.) - -QT_AUTOBRIEF = NO - -# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen -# treat a multi-line C++ special comment block (i.e. a block of //! or /// -# comments) as a brief description. This used to be the default behaviour. -# The new default is to treat a multi-line C++ comment block as a detailed -# description. Set this tag to YES if you prefer the old behaviour instead. - -MULTILINE_CPP_IS_BRIEF = NO - -# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented -# member inherits the documentation from any documented member that it -# re-implements. - -INHERIT_DOCS = YES - -# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce -# a new page for each member. If set to NO, the documentation of a member will -# be part of the file/class/namespace that contains it. - -SEPARATE_MEMBER_PAGES = NO - -# The TAB_SIZE tag can be used to set the number of spaces in a tab. -# Doxygen uses this value to replace tabs by spaces in code fragments. - -TAB_SIZE = 4 - -# This tag can be used to specify a number of aliases that acts -# as commands in the documentation. An alias has the form "name=value". -# For example adding "sideeffect=\par Side Effects:\n" will allow you to -# put the command \sideeffect (or @sideeffect) in the documentation, which -# will result in a user-defined paragraph with heading "Side Effects:". -# You can put \n's in the value part of an alias to insert newlines. - -ALIASES = - -# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C -# sources only. Doxygen will then generate output that is more tailored for C. -# For instance, some of the names that are used will be different. The list -# of all members will be omitted, etc. - -OPTIMIZE_OUTPUT_FOR_C = NO - -# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java -# sources only. Doxygen will then generate output that is more tailored for -# Java. For instance, namespaces will be presented as packages, qualified -# scopes will look different, etc. - -OPTIMIZE_OUTPUT_JAVA = NO - -# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran -# sources only. Doxygen will then generate output that is more tailored for -# Fortran. - -OPTIMIZE_FOR_FORTRAN = NO - -# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL -# sources. Doxygen will then generate output that is tailored for -# VHDL. - -OPTIMIZE_OUTPUT_VHDL = NO - -# Doxygen selects the parser to use depending on the extension of the files it parses. -# With this tag you can assign which parser to use for a given extension. -# Doxygen has a built-in mapping, but you can override or extend it using this tag. -# The format is ext=language, where ext is a file extension, and language is one of -# the parsers supported by doxygen: IDL, Java, Javascript, C#, C, C++, D, PHP, -# Objective-C, Python, Fortran, VHDL, C, C++. For instance to make doxygen treat -# .inc files as Fortran files (default is PHP), and .f files as C (default is Fortran), -# use: inc=Fortran f=C - -EXTENSION_MAPPING = - -# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want -# to include (a tag file for) the STL sources as input, then you should -# set this tag to YES in order to let doxygen match functions declarations and -# definitions whose arguments contain STL classes (e.g. func(std::string); v.s. -# func(std::string) {}). This also make the inheritance and collaboration -# diagrams that involve STL classes more complete and accurate. - -BUILTIN_STL_SUPPORT = YES - -# If you use Microsoft's C++/CLI language, you should set this option to YES to -# enable parsing support. - -CPP_CLI_SUPPORT = NO - -# Set the SIP_SUPPORT tag to YES if your project consists of sip sources only. -# Doxygen will parse them like normal C++ but will assume all classes use public -# instead of private inheritance when no explicit protection keyword is present. - -SIP_SUPPORT = NO - -# For Microsoft's IDL there are propget and propput attributes to indicate getter -# and setter methods for a property. Setting this option to YES (the default) -# will make doxygen to replace the get and set methods by a property in the -# documentation. This will only work if the methods are indeed getting or -# setting a simple type. If this is not the case, or you want to show the -# methods anyway, you should set this option to NO. - -IDL_PROPERTY_SUPPORT = YES - -# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC -# tag is set to YES, then doxygen will reuse the documentation of the first -# member in the group (if any) for the other members of the group. By default -# all members of a group must be documented explicitly. - -DISTRIBUTE_GROUP_DOC = NO - -# Set the SUBGROUPING tag to YES (the default) to allow class member groups of -# the same type (for instance a group of public functions) to be put as a -# subgroup of that type (e.g. under the Public Functions section). Set it to -# NO to prevent subgrouping. Alternatively, this can be done per class using -# the \nosubgrouping command. - -SUBGROUPING = YES - -# When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum -# is documented as struct, union, or enum with the name of the typedef. So -# typedef struct TypeS {} TypeT, will appear in the documentation as a struct -# with name TypeT. When disabled the typedef will appear as a member of a file, -# namespace, or class. And the struct will be named TypeS. This can typically -# be useful for C code in case the coding convention dictates that all compound -# types are typedef'ed and only the typedef is referenced, never the tag name. - -TYPEDEF_HIDES_STRUCT = NO - -# The SYMBOL_CACHE_SIZE determines the size of the internal cache use to -# determine which symbols to keep in memory and which to flush to disk. -# When the cache is full, less often used symbols will be written to disk. -# For small to medium size projects (<1000 input files) the default value is -# probably good enough. For larger projects a too small cache size can cause -# doxygen to be busy swapping symbols to and from disk most of the time -# causing a significant performance penality. -# If the system has enough physical memory increasing the cache will improve the -# performance by keeping more symbols in memory. Note that the value works on -# a logarithmic scale so increasing the size by one will rougly double the -# memory usage. The cache size is given by this formula: -# 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0, -# corresponding to a cache size of 2^16 = 65536 symbols - -SYMBOL_CACHE_SIZE = 0 - -#--------------------------------------------------------------------------- -# Build related configuration options -#--------------------------------------------------------------------------- - -# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in -# documentation are documented, even if no documentation was available. -# Private class members and static file members will be hidden unless -# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES - -EXTRACT_ALL = YES - -# If the EXTRACT_PRIVATE tag is set to YES all private members of a class -# will be included in the documentation. - -EXTRACT_PRIVATE = NO - -# If the EXTRACT_STATIC tag is set to YES all static members of a file -# will be included in the documentation. - -EXTRACT_STATIC = NO - -# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) -# defined locally in source files will be included in the documentation. -# If set to NO only classes defined in header files are included. - -EXTRACT_LOCAL_CLASSES = NO - -# This flag is only useful for Objective-C code. When set to YES local -# methods, which are defined in the implementation section but not in -# the interface are included in the documentation. -# If set to NO (the default) only methods in the interface are included. - -EXTRACT_LOCAL_METHODS = NO - -# If this flag is set to YES, the members of anonymous namespaces will be -# extracted and appear in the documentation as a namespace called -# 'anonymous_namespace{file}', where file will be replaced with the base -# name of the file that contains the anonymous namespace. By default -# anonymous namespace are hidden. - -EXTRACT_ANON_NSPACES = NO - -# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all -# undocumented members of documented classes, files or namespaces. -# If set to NO (the default) these members will be included in the -# various overviews, but no documentation section is generated. -# This option has no effect if EXTRACT_ALL is enabled. - -HIDE_UNDOC_MEMBERS = YES - -# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all -# undocumented classes that are normally visible in the class hierarchy. -# If set to NO (the default) these classes will be included in the various -# overviews. This option has no effect if EXTRACT_ALL is enabled. - -HIDE_UNDOC_CLASSES = YES - -# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all -# friend (class|struct|union) declarations. -# If set to NO (the default) these declarations will be included in the -# documentation. - -HIDE_FRIEND_COMPOUNDS = NO - -# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any -# documentation blocks found inside the body of a function. -# If set to NO (the default) these blocks will be appended to the -# function's detailed documentation block. - -HIDE_IN_BODY_DOCS = YES - -# The INTERNAL_DOCS tag determines if documentation -# that is typed after a \internal command is included. If the tag is set -# to NO (the default) then the documentation will be excluded. -# Set it to YES to include the internal documentation. - -INTERNAL_DOCS = NO - -# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate -# file names in lower-case letters. If set to YES upper-case letters are also -# allowed. This is useful if you have classes or files whose names only differ -# in case and if your file system supports case sensitive file names. Windows -# and Mac users are advised to set this option to NO. - -CASE_SENSE_NAMES = YES - -# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen -# will show members with their full class and namespace scopes in the -# documentation. If set to YES the scope will be hidden. - -HIDE_SCOPE_NAMES = NO - -# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen -# will put a list of the files that are included by a file in the documentation -# of that file. - -SHOW_INCLUDE_FILES = YES - -# If the INLINE_INFO tag is set to YES (the default) then a tag [inline] -# is inserted in the documentation for inline members. - -INLINE_INFO = YES - -# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen -# will sort the (detailed) documentation of file and class members -# alphabetically by member name. If set to NO the members will appear in -# declaration order. - -SORT_MEMBER_DOCS = NO - -# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the -# brief documentation of file, namespace and class members alphabetically -# by member name. If set to NO (the default) the members will appear in -# declaration order. - -SORT_BRIEF_DOCS = NO - -# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the -# hierarchy of group names into alphabetical order. If set to NO (the default) -# the group names will appear in their defined order. - -SORT_GROUP_NAMES = NO - -# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be -# sorted by fully-qualified names, including namespaces. If set to -# NO (the default), the class list will be sorted only by class name, -# not including the namespace part. -# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. -# Note: This option applies only to the class list, not to the -# alphabetical list. - -SORT_BY_SCOPE_NAME = YES - -# The GENERATE_TODOLIST tag can be used to enable (YES) or -# disable (NO) the todo list. This list is created by putting \todo -# commands in the documentation. - -GENERATE_TODOLIST = NO - -# The GENERATE_TESTLIST tag can be used to enable (YES) or -# disable (NO) the test list. This list is created by putting \test -# commands in the documentation. - -GENERATE_TESTLIST = NO - -# The GENERATE_BUGLIST tag can be used to enable (YES) or -# disable (NO) the bug list. This list is created by putting \bug -# commands in the documentation. - -GENERATE_BUGLIST = NO - -# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or -# disable (NO) the deprecated list. This list is created by putting -# \deprecated commands in the documentation. - -GENERATE_DEPRECATEDLIST= YES - -# The ENABLED_SECTIONS tag can be used to enable conditional -# documentation sections, marked by \if sectionname ... \endif. - -ENABLED_SECTIONS = - -# The MAX_INITIALIZER_LINES tag determines the maximum number of lines -# the initial value of a variable or define consists of for it to appear in -# the documentation. If the initializer consists of more lines than specified -# here it will be hidden. Use a value of 0 to hide initializers completely. -# The appearance of the initializer of individual variables and defines in the -# documentation can be controlled using \showinitializer or \hideinitializer -# command in the documentation regardless of this setting. - -MAX_INITIALIZER_LINES = 30 - -# Set the SHOW_USED_FILES tag to NO to disable the list of files generated -# at the bottom of the documentation of classes and structs. If set to YES the -# list will mention the files that were used to generate the documentation. - -SHOW_USED_FILES = YES - -# If the sources in your project are distributed over multiple directories -# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy -# in the documentation. The default is NO. - -SHOW_DIRECTORIES = NO - -# Set the SHOW_FILES tag to NO to disable the generation of the Files page. -# This will remove the Files entry from the Quick Index and from the -# Folder Tree View (if specified). The default is YES. - -SHOW_FILES = YES - -# Set the SHOW_NAMESPACES tag to NO to disable the generation of the -# Namespaces page. -# This will remove the Namespaces entry from the Quick Index -# and from the Folder Tree View (if specified). The default is YES. - -SHOW_NAMESPACES = YES - -# The FILE_VERSION_FILTER tag can be used to specify a program or script that -# doxygen should invoke to get the current version for each file (typically from -# the version control system). Doxygen will invoke the program by executing (via -# popen()) the command , where is the value of -# the FILE_VERSION_FILTER tag, and is the name of an input file -# provided by doxygen. Whatever the program writes to standard output -# is used as the file version. See the manual for examples. - -FILE_VERSION_FILTER = - -# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed by -# doxygen. The layout file controls the global structure of the generated output files -# in an output format independent way. The create the layout file that represents -# doxygen's defaults, run doxygen with the -l option. You can optionally specify a -# file name after the option, if omitted DoxygenLayout.xml will be used as the name -# of the layout file. - -LAYOUT_FILE = - -#--------------------------------------------------------------------------- -# configuration options related to warning and progress messages -#--------------------------------------------------------------------------- - -# The QUIET tag can be used to turn on/off the messages that are generated -# by doxygen. Possible values are YES and NO. If left blank NO is used. - -QUIET = YES - -# The WARNINGS tag can be used to turn on/off the warning messages that are -# generated by doxygen. Possible values are YES and NO. If left blank -# NO is used. - -WARNINGS = YES - -# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings -# for undocumented members. If EXTRACT_ALL is set to YES then this flag will -# automatically be disabled. - -WARN_IF_UNDOCUMENTED = NO - -# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for -# potential errors in the documentation, such as not documenting some -# parameters in a documented function, or documenting parameters that -# don't exist or using markup commands wrongly. - -WARN_IF_DOC_ERROR = YES - -# This WARN_NO_PARAMDOC option can be abled to get warnings for -# functions that are documented, but have no documentation for their parameters -# or return value. If set to NO (the default) doxygen will only warn about -# wrong or incomplete parameter documentation, but not about the absence of -# documentation. - -WARN_NO_PARAMDOC = NO - -# The WARN_FORMAT tag determines the format of the warning messages that -# doxygen can produce. The string should contain the $file, $line, and $text -# tags, which will be replaced by the file and line number from which the -# warning originated and the warning text. Optionally the format may contain -# $version, which will be replaced by the version of the file (if it could -# be obtained via FILE_VERSION_FILTER) - -WARN_FORMAT = "$file:$line: $text" - -# The WARN_LOGFILE tag can be used to specify a file to which warning -# and error messages should be written. If left blank the output is written -# to stderr. - -WARN_LOGFILE = - -#--------------------------------------------------------------------------- -# configuration options related to the input files -#--------------------------------------------------------------------------- - -# The INPUT tag can be used to specify the files and/or directories that contain -# documented source files. You may enter file names like "myfile.cpp" or -# directories like "/usr/src/myproject". Separate the files or directories -# with spaces. - -INPUT = \ - src/constrain.cpp \ - src/cps.cpp \ - src/gc.cpp \ - src/lex.cpp \ - src/llvm.cpp \ - src/parse.cpp \ - src/pprint.cpp \ - src/repl.cpp \ - src/tuplr.cpp \ - src/tuplr.hpp \ - src/tuplr_gc.cpp \ - src/unify.cpp - -# This tag can be used to specify the character encoding of the source files -# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is -# also the default input encoding. Doxygen uses libiconv (or the iconv built -# into libc) for the transcoding. See http://www.gnu.org/software/libiconv for -# the list of possible encodings. - -INPUT_ENCODING = UTF-8 - -# If the value of the INPUT tag contains directories, you can use the -# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp -# and *.h) to filter out the source-files in the directories. If left -# blank the following patterns are tested: -# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx -# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py *.f90 - -FILE_PATTERNS = - -# The RECURSIVE tag can be used to turn specify whether or not subdirectories -# should be searched for input files as well. Possible values are YES and NO. -# If left blank NO is used. - -RECURSIVE = NO - -# The EXCLUDE tag can be used to specify files and/or directories that should -# excluded from the INPUT source files. This way you can easily exclude a -# subdirectory from a directory tree whose root is specified with the INPUT tag. - -EXCLUDE = - -# The EXCLUDE_SYMLINKS tag can be used select whether or not files or -# directories that are symbolic links (a Unix filesystem feature) are excluded -# from the input. - -EXCLUDE_SYMLINKS = NO - -# If the value of the INPUT tag contains directories, you can use the -# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude -# certain files from those directories. Note that the wildcards are matched -# against the file with absolute path, so to exclude all test directories -# for example use the pattern */test/* - -EXCLUDE_PATTERNS = - -# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names -# (namespaces, classes, functions, etc.) that should be excluded from the -# output. The symbol name can be a fully qualified name, a word, or if the -# wildcard * is used, a substring. Examples: ANamespace, AClass, -# AClass::ANamespace, ANamespace::*Test - -EXCLUDE_SYMBOLS = - -# The EXAMPLE_PATH tag can be used to specify one or more files or -# directories that contain example code fragments that are included (see -# the \include command). - -EXAMPLE_PATH = - -# If the value of the EXAMPLE_PATH tag contains directories, you can use the -# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp -# and *.h) to filter out the source-files in the directories. If left -# blank all files are included. - -EXAMPLE_PATTERNS = *.c - -# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be -# searched for input files to be used with the \include or \dontinclude -# commands irrespective of the value of the RECURSIVE tag. -# Possible values are YES and NO. If left blank NO is used. - -EXAMPLE_RECURSIVE = NO - -# The IMAGE_PATH tag can be used to specify one or more files or -# directories that contain image that are included in the documentation (see -# the \image command). - -IMAGE_PATH = - -# The INPUT_FILTER tag can be used to specify a program that doxygen should -# invoke to filter for each input file. Doxygen will invoke the filter program -# by executing (via popen()) the command , where -# is the value of the INPUT_FILTER tag, and is the name of an -# input file. Doxygen will then use the output that the filter program writes -# to standard output. -# If FILTER_PATTERNS is specified, this tag will be -# ignored. - -INPUT_FILTER = - -# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern -# basis. -# Doxygen will compare the file name with each pattern and apply the -# filter if there is a match. -# The filters are a list of the form: -# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further -# info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER -# is applied to all files. - -FILTER_PATTERNS = - -# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using -# INPUT_FILTER) will be used to filter the input files when producing source -# files to browse (i.e. when SOURCE_BROWSER is set to YES). - -FILTER_SOURCE_FILES = NO - -#--------------------------------------------------------------------------- -# configuration options related to source browsing -#--------------------------------------------------------------------------- - -# If the SOURCE_BROWSER tag is set to YES then a list of source files will -# be generated. Documented entities will be cross-referenced with these sources. -# Note: To get rid of all source code in the generated output, make sure also -# VERBATIM_HEADERS is set to NO. - -SOURCE_BROWSER = NO - -# Setting the INLINE_SOURCES tag to YES will include the body -# of functions and classes directly in the documentation. - -INLINE_SOURCES = NO - -# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct -# doxygen to hide any special comment blocks from generated source code -# fragments. Normal C and C++ comments will always remain visible. - -STRIP_CODE_COMMENTS = YES - -# If the REFERENCED_BY_RELATION tag is set to YES -# then for each documented function all documented -# functions referencing it will be listed. - -REFERENCED_BY_RELATION = YES - -# If the REFERENCES_RELATION tag is set to YES -# then for each documented function all documented entities -# called/used by that function will be listed. - -REFERENCES_RELATION = YES - -# If the REFERENCES_LINK_SOURCE tag is set to YES (the default) -# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from -# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will -# link to the source code. -# Otherwise they will link to the documentation. - -REFERENCES_LINK_SOURCE = YES - -# If the USE_HTAGS tag is set to YES then the references to source code -# will point to the HTML generated by the htags(1) tool instead of doxygen -# built-in source browser. The htags tool is part of GNU's global source -# tagging system (see http://www.gnu.org/software/global/global.html). You -# will need version 4.8.6 or higher. - -USE_HTAGS = NO - -# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen -# will generate a verbatim copy of the header file for each class for -# which an include is specified. Set to NO to disable this. - -VERBATIM_HEADERS = YES - -#--------------------------------------------------------------------------- -# configuration options related to the alphabetical class index -#--------------------------------------------------------------------------- - -# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index -# of all compounds will be generated. Enable this if the project -# contains a lot of classes, structs, unions or interfaces. - -ALPHABETICAL_INDEX = NO - -# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then -# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns -# in which this list will be split (can be a number in the range [1..20]) - -COLS_IN_ALPHA_INDEX = 5 - -# In case all classes in a project start with a common prefix, all -# classes will be put under the same header in the alphabetical index. -# The IGNORE_PREFIX tag can be used to specify one or more prefixes that -# should be ignored while generating the index headers. - -IGNORE_PREFIX = - -#--------------------------------------------------------------------------- -# configuration options related to the HTML output -#--------------------------------------------------------------------------- - -# If the GENERATE_HTML tag is set to YES (the default) Doxygen will -# generate HTML output. - -GENERATE_HTML = YES - -# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. -# If a relative path is entered the value of OUTPUT_DIRECTORY will be -# put in front of it. If left blank `html' will be used as the default path. - -HTML_OUTPUT = html - -# The HTML_FILE_EXTENSION tag can be used to specify the file extension for -# each generated HTML page (for example: .htm,.php,.asp). If it is left blank -# doxygen will generate files with .html extension. - -HTML_FILE_EXTENSION = .html - -# The HTML_HEADER tag can be used to specify a personal HTML header for -# each generated HTML page. If it is left blank doxygen will generate a -# standard header. - -HTML_HEADER = - -# The HTML_FOOTER tag can be used to specify a personal HTML footer for -# each generated HTML page. If it is left blank doxygen will generate a -# standard footer. - -HTML_FOOTER = - -# The HTML_STYLESHEET tag can be used to specify a user-defined cascading -# style sheet that is used by each HTML page. It can be used to -# fine-tune the look of the HTML output. If the tag is left blank doxygen -# will generate a default style sheet. Note that doxygen will try to copy -# the style sheet file to the HTML output directory, so don't put your own -# stylesheet in the HTML output directory as well, or it will be erased! - -HTML_STYLESHEET = - -# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, -# files or namespaces will be aligned in HTML using tables. If set to -# NO a bullet list will be used. - -HTML_ALIGN_MEMBERS = YES - -# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML -# documentation will contain sections that can be hidden and shown after the -# page has loaded. For this to work a browser that supports -# JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox -# Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari). - -HTML_DYNAMIC_SECTIONS = NO - -# If the GENERATE_DOCSET tag is set to YES, additional index files -# will be generated that can be used as input for Apple's Xcode 3 -# integrated development environment, introduced with OSX 10.5 (Leopard). -# To create a documentation set, doxygen will generate a Makefile in the -# HTML output directory. Running make will produce the docset in that -# directory and running "make install" will install the docset in -# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find -# it at startup. -# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html for more information. - -GENERATE_DOCSET = NO - -# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the -# feed. A documentation feed provides an umbrella under which multiple -# documentation sets from a single provider (such as a company or product suite) -# can be grouped. - -DOCSET_FEEDNAME = "Doxygen generated docs" - -# When GENERATE_DOCSET tag is set to YES, this tag specifies a string that -# should uniquely identify the documentation set bundle. This should be a -# reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen -# will append .docset to the name. - -DOCSET_BUNDLE_ID = org.doxygen.Project - -# If the GENERATE_HTMLHELP tag is set to YES, additional index files -# will be generated that can be used as input for tools like the -# Microsoft HTML help workshop to generate a compiled HTML help file (.chm) -# of the generated HTML documentation. - -GENERATE_HTMLHELP = NO - -# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can -# be used to specify the file name of the resulting .chm file. You -# can add a path in front of the file if the result should not be -# written to the html output directory. - -CHM_FILE = - -# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can -# be used to specify the location (absolute path including file name) of -# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run -# the HTML help compiler on the generated index.hhp. - -HHC_LOCATION = - -# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag -# controls if a separate .chi index file is generated (YES) or that -# it should be included in the master .chm file (NO). - -GENERATE_CHI = NO - -# If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING -# is used to encode HtmlHelp index (hhk), content (hhc) and project file -# content. - -CHM_INDEX_ENCODING = - -# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag -# controls whether a binary table of contents is generated (YES) or a -# normal table of contents (NO) in the .chm file. - -BINARY_TOC = NO - -# The TOC_EXPAND flag can be set to YES to add extra items for group members -# to the contents of the HTML help documentation and to the tree view. - -TOC_EXPAND = NO - -# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and QHP_VIRTUAL_FOLDER -# are set, an additional index file will be generated that can be used as input for -# Qt's qhelpgenerator to generate a Qt Compressed Help (.qch) of the generated -# HTML documentation. - -GENERATE_QHP = NO - -# If the QHG_LOCATION tag is specified, the QCH_FILE tag can -# be used to specify the file name of the resulting .qch file. -# The path specified is relative to the HTML output folder. - -QCH_FILE = - -# The QHP_NAMESPACE tag specifies the namespace to use when generating -# Qt Help Project output. For more information please see -# http://doc.trolltech.com/qthelpproject.html#namespace - -QHP_NAMESPACE = - -# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating -# Qt Help Project output. For more information please see -# http://doc.trolltech.com/qthelpproject.html#virtual-folders - -QHP_VIRTUAL_FOLDER = doc - -# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to add. -# For more information please see -# http://doc.trolltech.com/qthelpproject.html#custom-filters - -QHP_CUST_FILTER_NAME = - -# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the custom filter to add.For more information please see -# Qt Help Project / Custom Filters. - -QHP_CUST_FILTER_ATTRS = - -# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this project's -# filter section matches. -# Qt Help Project / Filter Attributes. - -QHP_SECT_FILTER_ATTRS = - -# If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can -# be used to specify the location of Qt's qhelpgenerator. -# If non-empty doxygen will try to run qhelpgenerator on the generated -# .qhp file. - -QHG_LOCATION = - -# The DISABLE_INDEX tag can be used to turn on/off the condensed index at -# top of each HTML page. The value NO (the default) enables the index and -# the value YES disables it. - -DISABLE_INDEX = NO - -# This tag can be used to set the number of enum values (range [1..20]) -# that doxygen will group on one line in the generated HTML documentation. - -ENUM_VALUES_PER_LINE = 4 - -# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index -# structure should be generated to display hierarchical information. -# If the tag value is set to FRAME, a side panel will be generated -# containing a tree-like index structure (just like the one that -# is generated for HTML Help). For this to work a browser that supports -# JavaScript, DHTML, CSS and frames is required (for instance Mozilla 1.0+, -# Netscape 6.0+, Internet explorer 5.0+, or Konqueror). Windows users are -# probably better off using the HTML help feature. Other possible values -# for this tag are: HIERARCHIES, which will generate the Groups, Directories, -# and Class Hierarchy pages using a tree view instead of an ordered list; -# ALL, which combines the behavior of FRAME and HIERARCHIES; and NONE, which -# disables this behavior completely. For backwards compatibility with previous -# releases of Doxygen, the values YES and NO are equivalent to FRAME and NONE -# respectively. - -GENERATE_TREEVIEW = NO - -# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be -# used to set the initial width (in pixels) of the frame in which the tree -# is shown. - -TREEVIEW_WIDTH = 250 - -# Use this tag to change the font size of Latex formulas included -# as images in the HTML documentation. The default is 10. Note that -# when you change the font size after a successful doxygen run you need -# to manually remove any form_*.png images from the HTML output directory -# to force them to be regenerated. - -FORMULA_FONTSIZE = 10 - -#--------------------------------------------------------------------------- -# configuration options related to the LaTeX output -#--------------------------------------------------------------------------- - -# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will -# generate Latex output. - -GENERATE_LATEX = NO - -# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. -# If a relative path is entered the value of OUTPUT_DIRECTORY will be -# put in front of it. If left blank `latex' will be used as the default path. - -LATEX_OUTPUT = latex - -# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be -# invoked. If left blank `latex' will be used as the default command name. - -LATEX_CMD_NAME = pdflatex - -# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to -# generate index for LaTeX. If left blank `makeindex' will be used as the -# default command name. - -MAKEINDEX_CMD_NAME = makeindex - -# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact -# LaTeX documents. This may be useful for small projects and may help to -# save some trees in general. - -COMPACT_LATEX = YES - -# The PAPER_TYPE tag can be used to set the paper type that is used -# by the printer. Possible values are: a4, a4wide, letter, legal and -# executive. If left blank a4wide will be used. - -PAPER_TYPE = a4wide - -# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX -# packages that should be included in the LaTeX output. - -EXTRA_PACKAGES = - -# The LATEX_HEADER tag can be used to specify a personal LaTeX header for -# the generated latex document. The header should contain everything until -# the first chapter. If it is left blank doxygen will generate a -# standard header. Notice: only use this tag if you know what you are doing! - -LATEX_HEADER = - -# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated -# is prepared for conversion to pdf (using ps2pdf). The pdf file will -# contain links (just like the HTML output) instead of page references -# This makes the output suitable for online browsing using a pdf viewer. - -PDF_HYPERLINKS = YES - -# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of -# plain latex in the generated Makefile. Set this option to YES to get a -# higher quality PDF documentation. - -USE_PDFLATEX = YES - -# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. -# command to the generated LaTeX files. This will instruct LaTeX to keep -# running if errors occur, instead of asking the user for help. -# This option is also used when generating formulas in HTML. - -LATEX_BATCHMODE = NO - -# If LATEX_HIDE_INDICES is set to YES then doxygen will not -# include the index chapters (such as File Index, Compound Index, etc.) -# in the output. - -LATEX_HIDE_INDICES = NO - -#--------------------------------------------------------------------------- -# configuration options related to the RTF output -#--------------------------------------------------------------------------- - -# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output -# The RTF output is optimized for Word 97 and may not look very pretty with -# other RTF readers or editors. - -GENERATE_RTF = NO - -# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. -# If a relative path is entered the value of OUTPUT_DIRECTORY will be -# put in front of it. If left blank `rtf' will be used as the default path. - -RTF_OUTPUT = rtf - -# If the COMPACT_RTF tag is set to YES Doxygen generates more compact -# RTF documents. This may be useful for small projects and may help to -# save some trees in general. - -COMPACT_RTF = NO - -# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated -# will contain hyperlink fields. The RTF file will -# contain links (just like the HTML output) instead of page references. -# This makes the output suitable for online browsing using WORD or other -# programs which support those fields. -# Note: wordpad (write) and others do not support links. - -RTF_HYPERLINKS = NO - -# Load stylesheet definitions from file. Syntax is similar to doxygen's -# config file, i.e. a series of assignments. You only have to provide -# replacements, missing definitions are set to their default value. - -RTF_STYLESHEET_FILE = - -# Set optional variables used in the generation of an rtf document. -# Syntax is similar to doxygen's config file. - -RTF_EXTENSIONS_FILE = - -#--------------------------------------------------------------------------- -# configuration options related to the man page output -#--------------------------------------------------------------------------- - -# If the GENERATE_MAN tag is set to YES (the default) Doxygen will -# generate man pages - -GENERATE_MAN = NO - -# The MAN_OUTPUT tag is used to specify where the man pages will be put. -# If a relative path is entered the value of OUTPUT_DIRECTORY will be -# put in front of it. If left blank `man' will be used as the default path. - -MAN_OUTPUT = man - -# The MAN_EXTENSION tag determines the extension that is added to -# the generated man pages (default is the subroutine's section .3) - -MAN_EXTENSION = .3 - -# If the MAN_LINKS tag is set to YES and Doxygen generates man output, -# then it will generate one additional man file for each entity -# documented in the real man page(s). These additional files -# only source the real man page, but without them the man command -# would be unable to find the correct page. The default is NO. - -MAN_LINKS = NO - -#--------------------------------------------------------------------------- -# configuration options related to the XML output -#--------------------------------------------------------------------------- - -# If the GENERATE_XML tag is set to YES Doxygen will -# generate an XML file that captures the structure of -# the code including all documentation. - -GENERATE_XML = NO - -# The XML_OUTPUT tag is used to specify where the XML pages will be put. -# If a relative path is entered the value of OUTPUT_DIRECTORY will be -# put in front of it. If left blank `xml' will be used as the default path. - -XML_OUTPUT = xml - -# The XML_SCHEMA tag can be used to specify an XML schema, -# which can be used by a validating XML parser to check the -# syntax of the XML files. - -XML_SCHEMA = - -# The XML_DTD tag can be used to specify an XML DTD, -# which can be used by a validating XML parser to check the -# syntax of the XML files. - -XML_DTD = - -# If the XML_PROGRAMLISTING tag is set to YES Doxygen will -# dump the program listings (including syntax highlighting -# and cross-referencing information) to the XML output. Note that -# enabling this will significantly increase the size of the XML output. - -XML_PROGRAMLISTING = YES - -#--------------------------------------------------------------------------- -# configuration options for the AutoGen Definitions output -#--------------------------------------------------------------------------- - -# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will -# generate an AutoGen Definitions (see autogen.sf.net) file -# that captures the structure of the code including all -# documentation. Note that this feature is still experimental -# and incomplete at the moment. - -GENERATE_AUTOGEN_DEF = NO - -#--------------------------------------------------------------------------- -# configuration options related to the Perl module output -#--------------------------------------------------------------------------- - -# If the GENERATE_PERLMOD tag is set to YES Doxygen will -# generate a Perl module file that captures the structure of -# the code including all documentation. Note that this -# feature is still experimental and incomplete at the -# moment. - -GENERATE_PERLMOD = NO - -# If the PERLMOD_LATEX tag is set to YES Doxygen will generate -# the necessary Makefile rules, Perl scripts and LaTeX code to be able -# to generate PDF and DVI output from the Perl module output. - -PERLMOD_LATEX = NO - -# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be -# nicely formatted so it can be parsed by a human reader. -# This is useful -# if you want to understand what is going on. -# On the other hand, if this -# tag is set to NO the size of the Perl module output will be much smaller -# and Perl will parse it just the same. - -PERLMOD_PRETTY = YES - -# The names of the make variables in the generated doxyrules.make file -# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. -# This is useful so different doxyrules.make files included by the same -# Makefile don't overwrite each other's variables. - -PERLMOD_MAKEVAR_PREFIX = - -#--------------------------------------------------------------------------- -# Configuration options related to the preprocessor -#--------------------------------------------------------------------------- - -# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will -# evaluate all C-preprocessor directives found in the sources and include -# files. - -ENABLE_PREPROCESSING = YES - -# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro -# names in the source code. If set to NO (the default) only conditional -# compilation will be performed. Macro expansion can be done in a controlled -# way by setting EXPAND_ONLY_PREDEF to YES. - -MACRO_EXPANSION = NO - -# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES -# then the macro expansion is limited to the macros specified with the -# PREDEFINED and EXPAND_AS_DEFINED tags. - -EXPAND_ONLY_PREDEF = NO - -# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files -# in the INCLUDE_PATH (see below) will be search if a #include is found. - -SEARCH_INCLUDES = YES - -# The INCLUDE_PATH tag can be used to specify one or more directories that -# contain include files that are not input files but should be processed by -# the preprocessor. - -INCLUDE_PATH = - -# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard -# patterns (like *.h and *.hpp) to filter out the header-files in the -# directories. If left blank, the patterns specified with FILE_PATTERNS will -# be used. - -INCLUDE_FILE_PATTERNS = - -# The PREDEFINED tag can be used to specify one or more macro names that -# are defined before the preprocessor is started (similar to the -D option of -# gcc). The argument of the tag is a list of macros of the form: name -# or name=definition (no spaces). If the definition and the = are -# omitted =1 is assumed. To prevent a macro definition from being -# undefined via #undef or recursively expanded use the := operator -# instead of the = operator. - -PREDEFINED = - -# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then -# this tag can be used to specify a list of macro names that should be expanded. -# The macro definition that is found in the sources will be used. -# Use the PREDEFINED tag if you want to use a different macro definition. - -EXPAND_AS_DEFINED = - -# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then -# doxygen's preprocessor will remove all function-like macros that are alone -# on a line, have an all uppercase name, and do not end with a semicolon. Such -# function macros are typically used for boiler-plate code, and will confuse -# the parser if not removed. - -SKIP_FUNCTION_MACROS = YES - -#--------------------------------------------------------------------------- -# Configuration::additions related to external references -#--------------------------------------------------------------------------- - -# The TAGFILES option can be used to specify one or more tagfiles. -# Optionally an initial location of the external documentation -# can be added for each tagfile. The format of a tag file without -# this location is as follows: -# -# TAGFILES = file1 file2 ... -# Adding location for the tag files is done as follows: -# -# TAGFILES = file1=loc1 "file2 = loc2" ... -# where "loc1" and "loc2" can be relative or absolute paths or -# URLs. If a location is present for each tag, the installdox tool -# does not have to be run to correct the links. -# Note that each tag file must have a unique name -# (where the name does NOT include the path) -# If a tag file is not located in the directory in which doxygen -# is run, you must also specify the path to the tagfile here. - -TAGFILES = - -# When a file name is specified after GENERATE_TAGFILE, doxygen will create -# a tag file that is based on the input files it reads. - -GENERATE_TAGFILE = - -# If the ALLEXTERNALS tag is set to YES all external classes will be listed -# in the class index. If set to NO only the inherited external classes -# will be listed. - -ALLEXTERNALS = NO - -# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed -# in the modules index. If set to NO, only the current project's groups will -# be listed. - -EXTERNAL_GROUPS = YES - -# The PERL_PATH should be the absolute path and name of the perl script -# interpreter (i.e. the result of `which perl'). - -PERL_PATH = /usr/bin/perl - -#--------------------------------------------------------------------------- -# Configuration options related to the dot tool -#--------------------------------------------------------------------------- - -# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will -# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base -# or super classes. Setting the tag to NO turns the diagrams off. Note that -# this option is superseded by the HAVE_DOT option below. This is only a -# fallback. It is recommended to install and use dot, since it yields more -# powerful graphs. - -CLASS_DIAGRAMS = YES - -# You can define message sequence charts within doxygen comments using the \msc -# command. Doxygen will then run the mscgen tool (see -# http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the -# documentation. The MSCGEN_PATH tag allows you to specify the directory where -# the mscgen tool resides. If left empty the tool is assumed to be found in the -# default search path. - -MSCGEN_PATH = - -# If set to YES, the inheritance and collaboration graphs will hide -# inheritance and usage relations if the target is undocumented -# or is not a class. - -HIDE_UNDOC_RELATIONS = YES - -# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is -# available from the path. This tool is part of Graphviz, a graph visualization -# toolkit from AT&T and Lucent Bell Labs. The other options in this section -# have no effect if this option is set to NO (the default) - -HAVE_DOT = YES - -# By default doxygen will write a font called FreeSans.ttf to the output -# directory and reference it in all dot files that doxygen generates. This -# font does not include all possible unicode characters however, so when you need -# these (or just want a differently looking font) you can specify the font name -# using DOT_FONTNAME. You need need to make sure dot is able to find the font, -# which can be done by putting it in a standard location or by setting the -# DOTFONTPATH environment variable or by setting DOT_FONTPATH to the directory -# containing the font. - -DOT_FONTNAME = FreeSans - -# The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs. -# The default size is 10pt. - -DOT_FONTSIZE = 10 - -# By default doxygen will tell dot to use the output directory to look for the -# FreeSans.ttf font (which doxygen will put there itself). If you specify a -# different font using DOT_FONTNAME you can set the path where dot -# can find it using this tag. - -DOT_FONTPATH = - -# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen -# will generate a graph for each documented class showing the direct and -# indirect inheritance relations. Setting this tag to YES will force the -# the CLASS_DIAGRAMS tag to NO. - -CLASS_GRAPH = YES - -# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen -# will generate a graph for each documented class showing the direct and -# indirect implementation dependencies (inheritance, containment, and -# class references variables) of the class with other documented classes. - -COLLABORATION_GRAPH = YES - -# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen -# will generate a graph for groups, showing the direct groups dependencies - -GROUP_GRAPHS = YES - -# If the UML_LOOK tag is set to YES doxygen will generate inheritance and -# collaboration diagrams in a style similar to the OMG's Unified Modeling -# Language. - -UML_LOOK = NO - -# If set to YES, the inheritance and collaboration graphs will show the -# relations between templates and their instances. - -TEMPLATE_RELATIONS = YES - -# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT -# tags are set to YES then doxygen will generate a graph for each documented -# file showing the direct and indirect include dependencies of the file with -# other documented files. - -INCLUDE_GRAPH = NO - -# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and -# HAVE_DOT tags are set to YES then doxygen will generate a graph for each -# documented header file showing the documented files that directly or -# indirectly include this file. - -INCLUDED_BY_GRAPH = NO - -# If the CALL_GRAPH and HAVE_DOT options are set to YES then -# doxygen will generate a call dependency graph for every global function -# or class method. Note that enabling this option will significantly increase -# the time of a run. So in most cases it will be better to enable call graphs -# for selected functions only using the \callgraph command. - -CALL_GRAPH = NO - -# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then -# doxygen will generate a caller dependency graph for every global function -# or class method. Note that enabling this option will significantly increase -# the time of a run. So in most cases it will be better to enable caller -# graphs for selected functions only using the \callergraph command. - -CALLER_GRAPH = NO - -# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen -# will graphical hierarchy of all classes instead of a textual one. - -GRAPHICAL_HIERARCHY = YES - -# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES -# then doxygen will show the dependencies a directory has on other directories -# in a graphical way. The dependency relations are determined by the #include -# relations between the files in the directories. - -DIRECTORY_GRAPH = YES - -# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images -# generated by dot. Possible values are png, jpg, or gif -# If left blank png will be used. - -DOT_IMAGE_FORMAT = png - -# The tag DOT_PATH can be used to specify the path where the dot tool can be -# found. If left blank, it is assumed the dot tool can be found in the path. - -DOT_PATH = - -# The DOTFILE_DIRS tag can be used to specify one or more directories that -# contain dot files that are included in the documentation (see the -# \dotfile command). - -DOTFILE_DIRS = - -# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of -# nodes that will be shown in the graph. If the number of nodes in a graph -# becomes larger than this value, doxygen will truncate the graph, which is -# visualized by representing a node as a red box. Note that doxygen if the -# number of direct children of the root node in a graph is already larger than -# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note -# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH. - -DOT_GRAPH_MAX_NODES = 50 - -# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the -# graphs generated by dot. A depth value of 3 means that only nodes reachable -# from the root by following a path via at most 3 edges will be shown. Nodes -# that lay further from the root node will be omitted. Note that setting this -# option to 1 or 2 may greatly reduce the computation time needed for large -# code bases. Also note that the size of a graph can be further restricted by -# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction. - -MAX_DOT_GRAPH_DEPTH = 0 - -# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent -# background. This is disabled by default, because dot on Windows does not -# seem to support this out of the box. Warning: Depending on the platform used, -# enabling this option may lead to badly anti-aliased labels on the edges of -# a graph (i.e. they become hard to read). - -DOT_TRANSPARENT = NO - -# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output -# files in one run (i.e. multiple -o and -T options on the command line). This -# makes dot run faster, but since only newer versions of dot (>1.8.10) -# support this, this feature is disabled by default. - -DOT_MULTI_TARGETS = NO - -# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will -# generate a legend page explaining the meaning of the various boxes and -# arrows in the dot generated graphs. - -GENERATE_LEGEND = YES - -# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will -# remove the intermediate dot files that are used to generate -# the various graphs. - -DOT_CLEANUP = YES - -#--------------------------------------------------------------------------- -# Options related to the search engine -#--------------------------------------------------------------------------- - -# The SEARCHENGINE tag specifies whether or not a search engine should be -# used. If set to NO the values of all tags below this one will be ignored. - -SEARCHENGINE = NO - diff --git a/tuplr_highlight.py b/tuplr_highlight.py deleted file mode 100755 index c48831d..0000000 --- a/tuplr_highlight.py +++ /dev/null @@ -1,152 +0,0 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- -import sys -import pygments -import re -from pygments import highlight -from pygments.lexers import SchemeLexer -from pygments.formatters import HtmlFormatter, LatexFormatter -from pygments.lexer import RegexLexer, bygroups -from pygments.token import * -from pygments.style import Style - -#from pygments.styles import STYLE_MAP -#print STYLE_MAP.keys() - -class TuplrLexer(RegexLexer): - name = 'Tuplr' - aliases = ['tuplr', 'tpr'] - filenames = ['*.tpr'] - mimetypes = ['text/x-tuplr', 'application/x-tuplr'] - - keywords = [ 'fn', 'def', 'if', 'match', 'ns', 'type' ] - builtins = [ 'cons', 'car', 'cdr' ] - - valid_name = r'[.a-zA-Z0-9!$%&*+,/:<=>?@^_~|-]+' - - tokens = { - 'root' : [ - # types - (r':?[A-Z][a-zA-Z.]*|:\([A-Z][a-zA-Z.\ ]*\)', Keyword.Type), - - # line comments - (r';.*$', Comment.Single), - - # whitespace - (r'\s+', Text), - - # numbers - (r'-?\d+\.\d+', Number.Float), - (r'-?\d+', Number.Integer), - - # strings, symbols and characters - (r'"(\\\\|\\"|[^"])*"', String), - (r"'" + valid_name, String.Symbol), - (r"#\\([()/'\".'_!ยง$%& ?=+-]{1}|[a-zA-Z0-9]+)", String.Char), - - # constants - (r'(#t|#f)', Name.Constant), - - # highlight keywords - ('(%s)' % '|'.join([ - re.escape(entry) + ' ' for entry in keywords]), - Keyword - ), - - # highlight builtins - ("(?<=\()(%s)" % '|'.join([ - re.escape(entry) + ' ' for entry in builtins]), - Name.Builtin - ), - - # remaining functions - (r'(?<=\()' + valid_name, Name.Function), - - # remaining variables - (valid_name, Name.Variable), - - # parenthesis - (r'(\(|\))', Punctuation), - ], - } - -class TuplrStyleDark(Style): - default_style = "#FFF" - background_color = "#222" - styles = { - Comment: '#79E', - Keyword: '#EE5', - Name: '#DDD', - Text: '#DDD', - String: '#F88', - Keyword.Type: '#5E5', - Punctuation: '#AAA', - Number: '#F88' - } - -class TuplrStyleLight(Style): - default_style = "#FFF" - background_color = "#EEE" - styles = { - Comment: '#57C', - Keyword: '#AA0', - Name: '#777', - Text: '#777', - String: '#D66', - Keyword.Type: '#3C3', - Punctuation: '#888', - Number: '#D66' - } - -if len(sys.argv) != 3: - print 'USAGE: %s IN OUT' % sys.argv[0] - sys.exit(1) - -infile = open(sys.argv[1], 'r') -text = infile.read() -infile.close() - - -if re.match('.*\.html$', sys.argv[2]): - style = TuplrStyleDark - formatter = HtmlFormatter(style=style) -elif re.match('.*\.tex$', sys.argv[2]): - style = TuplrStyleLight - formatter = LatexFormatter(style=style) - -if re.match('.*\.html$', sys.argv[2]): - outfile = open(sys.argv[2], 'w') - print >>outfile, ''' - - - - %s - - - - ''' - print >>outfile, highlight(text, TuplrLexer(), formatter) - print >>outfile, ''' - - ''' - outfile.close() - -if re.match('.*\.tex$', sys.argv[2]): - outfile = open(sys.argv[2], 'w') - print >>outfile, '''\\documentclass[10pt]{article} -\\usepackage{fancyvrb} -\\usepackage{color}''' - print >>outfile, formatter.get_style_defs() - print >>outfile, '\\newcommand\\PYlambda{$\\lambda$}' - print >>outfile, '\\newcommand\\PYbiglambda{$\\Lambda$}' - print >>outfile, '\\begin{document}' - out = highlight(text, TuplrLexer(), formatter) - out = out.replace('[fn', '[@PYlambda') - out = out.replace('[Fn', '[@PYbiglambda') - print >>outfile, out - print >>outfile, '\\end{document}' - outfile.close() - -- cgit v1.2.1