From 267170167d52cab9e97f879d9127a1cf04f6bb58 Mon Sep 17 00:00:00 2001 From: Martin Peach Date: Tue, 15 Mar 2011 20:53:57 +0000 Subject: This is a version of Claude Heiland-Allen's lua for Pd. The objects are named pdlua and pdluax instead of lua and luax. So far it seems to work on linux. svn path=/trunk/externals/pdlua/; revision=15030 --- src/.deps/pdlua-pdlua.Po | 129 +++++ src/Doxyfile | 1252 ++++++++++++++++++++++++++++++++++++++++ src/Makefile | 368 ++++++++++++ src/config.h | 75 +++ src/hello-help.pd | 10 + src/hello.lua | 1 + src/hello.pd_lua | 12 + src/hello.pd_luax | 4 + src/pd.lua | 303 ++++++++++ src/pdlua-help.pd | 15 + src/pdlua-meta.pd | 10 + src/pdlua.c | 1427 ++++++++++++++++++++++++++++++++++++++++++++++ src/pdluax-help.pd | 12 + 13 files changed, 3618 insertions(+) create mode 100644 src/.deps/pdlua-pdlua.Po create mode 100644 src/Doxyfile create mode 100644 src/Makefile create mode 100644 src/config.h create mode 100644 src/hello-help.pd create mode 100644 src/hello.lua create mode 100644 src/hello.pd_lua create mode 100644 src/hello.pd_luax create mode 100644 src/pd.lua create mode 100644 src/pdlua-help.pd create mode 100644 src/pdlua-meta.pd create mode 100644 src/pdlua.c create mode 100644 src/pdluax-help.pd (limited to 'src') diff --git a/src/.deps/pdlua-pdlua.Po b/src/.deps/pdlua-pdlua.Po new file mode 100644 index 0000000..70f7954 --- /dev/null +++ b/src/.deps/pdlua-pdlua.Po @@ -0,0 +1,129 @@ +pdlua-pdlua.o: pdlua.c /usr/include/stdio.h /usr/include/features.h \ + /usr/include/bits/predefs.h /usr/include/sys/cdefs.h \ + /usr/include/bits/wordsize.h /usr/include/gnu/stubs.h \ + /usr/include/gnu/stubs-32.h \ + /usr/lib/gcc/i486-linux-gnu/4.4.5/include/stddef.h \ + /usr/include/bits/types.h /usr/include/bits/typesizes.h \ + /usr/include/libio.h /usr/include/_G_config.h /usr/include/wchar.h \ + /usr/lib/gcc/i486-linux-gnu/4.4.5/include/stdarg.h \ + /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \ + /usr/include/bits/stdio.h /usr/include/stdlib.h /usr/include/sys/types.h \ + /usr/include/time.h /usr/include/endian.h /usr/include/bits/endian.h \ + /usr/include/bits/byteswap.h /usr/include/sys/select.h \ + /usr/include/bits/select.h /usr/include/bits/sigset.h \ + /usr/include/bits/time.h /usr/include/sys/sysmacros.h \ + /usr/include/bits/pthreadtypes.h /usr/include/alloca.h \ + /usr/include/string.h /usr/include/xlocale.h /usr/include/bits/string.h \ + /usr/include/bits/string2.h /usr/include/unistd.h \ + /usr/include/bits/posix_opt.h /usr/include/bits/confname.h \ + /usr/include/getopt.h /usr/include/lua5.1/lua.h \ + /usr/include/lua5.1/luaconf.h \ + /usr/lib/gcc/i486-linux-gnu/4.4.5/include-fixed/limits.h \ + /usr/lib/gcc/i486-linux-gnu/4.4.5/include-fixed/syslimits.h \ + /usr/include/limits.h /usr/include/bits/posix1_lim.h \ + /usr/include/bits/local_lim.h /usr/include/linux/limits.h \ + /usr/include/bits/posix2_lim.h /usr/include/lua5.1/lauxlib.h \ + /usr/include/lua5.1/lua.h /usr/include/lua5.1/lualib.h \ + /home/martin/pd_from_svn/pd/src/m_pd.h + +/usr/include/stdio.h: + +/usr/include/features.h: + +/usr/include/bits/predefs.h: + +/usr/include/sys/cdefs.h: + +/usr/include/bits/wordsize.h: + +/usr/include/gnu/stubs.h: + +/usr/include/gnu/stubs-32.h: + +/usr/lib/gcc/i486-linux-gnu/4.4.5/include/stddef.h: + +/usr/include/bits/types.h: + +/usr/include/bits/typesizes.h: + +/usr/include/libio.h: + +/usr/include/_G_config.h: + +/usr/include/wchar.h: + +/usr/lib/gcc/i486-linux-gnu/4.4.5/include/stdarg.h: + +/usr/include/bits/stdio_lim.h: + +/usr/include/bits/sys_errlist.h: + +/usr/include/bits/stdio.h: + +/usr/include/stdlib.h: + +/usr/include/sys/types.h: + +/usr/include/time.h: + +/usr/include/endian.h: + +/usr/include/bits/endian.h: + +/usr/include/bits/byteswap.h: + +/usr/include/sys/select.h: + +/usr/include/bits/select.h: + +/usr/include/bits/sigset.h: + +/usr/include/bits/time.h: + +/usr/include/sys/sysmacros.h: + +/usr/include/bits/pthreadtypes.h: + +/usr/include/alloca.h: + +/usr/include/string.h: + +/usr/include/xlocale.h: + +/usr/include/bits/string.h: + +/usr/include/bits/string2.h: + +/usr/include/unistd.h: + +/usr/include/bits/posix_opt.h: + +/usr/include/bits/confname.h: + +/usr/include/getopt.h: + +/usr/include/lua5.1/lua.h: + +/usr/include/lua5.1/luaconf.h: + +/usr/lib/gcc/i486-linux-gnu/4.4.5/include-fixed/limits.h: + +/usr/lib/gcc/i486-linux-gnu/4.4.5/include-fixed/syslimits.h: + +/usr/include/limits.h: + +/usr/include/bits/posix1_lim.h: + +/usr/include/bits/local_lim.h: + +/usr/include/linux/limits.h: + +/usr/include/bits/posix2_lim.h: + +/usr/include/lua5.1/lauxlib.h: + +/usr/include/lua5.1/lua.h: + +/usr/include/lua5.1/lualib.h: + +/home/martin/pd_from_svn/pd/src/m_pd.h: diff --git a/src/Doxyfile b/src/Doxyfile new file mode 100644 index 0000000..50a8de0 --- /dev/null +++ b/src/Doxyfile @@ -0,0 +1,1252 @@ +# Doxyfile 1.5.1 + +# 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 +#--------------------------------------------------------------------------- + +# The PROJECT_NAME tag is a single word (or a sequence of words surrounded +# by quotes) that should identify the project. + +PROJECT_NAME = pdlua + +# 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.6 + +# 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 = ../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, Finnish, French, German, Greek, Hungarian, +# Italian, Japanese, Japanese-en (Japanese with English messages), Korean, +# Korean-en, Lithuanian, Norwegian, Polish, Portuguese, Romanian, Russian, +# Serbian, Slovak, Slovene, Spanish, Swedish, and Ukrainian. + +OUTPUT_LANGUAGE = English + +# This tag can be used to specify the encoding used in the generated output. +# The encoding is not always determined by the language that is chosen, +# but also whether or not the output is meant for Windows or non-Windows users. +# In case there is a difference, setting the USE_WINDOWS_ENCODING tag to YES +# forces the Windows encoding (this is the default for the Windows binary), +# whereas setting the tag to NO uses a Unix-style encoding (the default for +# all platforms other than Windows). + +USE_WINDOWS_ENCODING = NO + +# 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 = YES + +# 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 = YES + +# 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 = YES + +# 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 the Qt-style comments (thus requiring an +# explicit @brief command for a brief description. + +JAVADOC_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 DETAILS_AT_TOP tag is set to YES then Doxygen +# will output the detailed description near the top, like JavaDoc. +# If set to NO, the detailed description appears after the member +# documentation. + +DETAILS_AT_TOP = 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 = 8 + +# 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 = YES + +# 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 + +# 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 = NO + +# 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 + +#--------------------------------------------------------------------------- +# 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 = YES + +# If the EXTRACT_STATIC tag is set to YES all static members of a file +# will be included in the documentation. + +EXTRACT_STATIC = YES + +# 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 = YES + +# 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 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 = NO + +# 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 = NO + +# 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 = NO + +# 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 = YES + +# 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 = YES + +# 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 = YES + +# 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 = NO + +# 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 = YES + +# 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 = YES + +# 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 = YES + +# 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 + +# 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 = + +#--------------------------------------------------------------------------- +# 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 = NO + +# 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 = YES + +# 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 = "lua.c" + +# 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 + +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 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 = + +# 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 = YES + +# 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 (the default) +# 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 (the default) +# 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 documentstion. + +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 = YES + +# 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 = NO + +# 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 compressed 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 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 + +# 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 + +# If the GENERATE_TREEVIEW tag is set to YES, 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. + +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 + +#--------------------------------------------------------------------------- +# 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 = latex + +# 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 = NO + +# 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 = NO + +# 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 = NO + +# 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 + +# 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 + +# 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 = NO + +# 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 = YES + +# 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 = YES + +# If the CALL_GRAPH and HAVE_DOT tags 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 = YES + +# 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 = YES + +# 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 MAX_DOT_GRAPH_WIDTH tag can be used to set the maximum allowed width +# (in pixels) of the graphs generated by dot. If a graph becomes larger than +# this value, doxygen will try to truncate the graph, so that it fits within +# the specified constraint. Beware that most browsers cannot cope with very +# large images. + +MAX_DOT_GRAPH_WIDTH = 1024 + +# The MAX_DOT_GRAPH_HEIGHT tag can be used to set the maximum allows height +# (in pixels) of the graphs generated by dot. If a graph becomes larger than +# this value, doxygen will try to truncate the graph, so that it fits within +# the specified constraint. Beware that most browsers cannot cope with very +# large images. + +MAX_DOT_GRAPH_HEIGHT = 1024 + +# 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 a graph may be further truncated if the graph's +# image dimensions are not sufficient to fit the graph (see MAX_DOT_GRAPH_WIDTH +# and MAX_DOT_GRAPH_HEIGHT). If 0 is used for the depth value (the default), +# the graph is not depth-constrained. + +MAX_DOT_GRAPH_DEPTH = 0 + +# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent +# background. This is disabled by default, which results in a white background. +# 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 + +#--------------------------------------------------------------------------- +# Configuration::additions 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/src/Makefile b/src/Makefile new file mode 100644 index 0000000..4ade6ff --- /dev/null +++ b/src/Makefile @@ -0,0 +1,368 @@ +## from Pd library template version 1.0.9 +# http://puredata.info/docs/developer/Makefilepdlua +LIBRARY_NAME = pdlua + +# add your .c source files, one object per file, to the SOURCES +# variable, help files will be included automatically, and for GUI +# objects, the matching .tcl file too +SOURCES = pdlua.c + +# list all pd objects (i.e. myobject.pd) files here, and their helpfiles will +# be included automatically +PDOBJECTS = pd.lua hello.lua hello.pd_lua hello.pd_luax + +# example patches and related files, in the 'examples' subfolder +EXAMPLES = examples/* + +# manuals and related files, in the 'manual' subfolder +MANUAL = doc/* + +# if you want to include any other files in the source and binary tarballs, +# list them here. This can be anything from header files, test patches, +# documentation, etc. README.txt and LICENSE.txt are required and therefore +# automatically included +EXTRA_DIST = nothing + + + + + +#------------------------------------------------------------------------------# +# +# things you might need to edit if you are using other C libraries +# +#------------------------------------------------------------------------------# + +# -I"$(PD_INCLUDE)/pd" supports the header location for 0.43 +# Lua setup +#CFLAGS += -ansi -pedantic -O2 -fPIC -I/usr/include/lua5.1 -I"$(PD_INCLUDE)/pd" -Wall -W -g +LDFLAGS = +LIBS = -llua5.1 + +#------------------------------------------------------------------------------# +# +# you shouldn't need to edit anything below here, if we did it right :) +# +#------------------------------------------------------------------------------# + +# get library version from meta file +LIBRARY_VERSION = $(shell sed -n 's|^\#X text [0-9][0-9]* [0-9][0-9]* VERSION \(.*\);|\1|p' $(LIBRARY_NAME)-meta.pd) + +LUACFLAGS = -DPD -DVERSION='"$(LIBRARY_VERSION)"' +LUACFLAGS += -fPIC -I"/usr/include/lua5.1" -I"$(PD_INCLUDE)/pd" -g + +PD_INCLUDE = $(PD_PATH)/include +# where to install the library, overridden below depending on platform +prefix = /usr/local +libdir = $(prefix)/lib +pkglibdir = $(libdir)/pd-externals +objectsdir = $(pkglibdir) + +INSTALL = install +INSTALL_PROGRAM = $(INSTALL) -p -m 644 +INSTALL_DATA = $(INSTALL) -p -m 644 +INSTALL_DIR = $(INSTALL) -p -m 755 -d + +ALLSOURCES := $(SOURCES) $(SOURCES_android) $(SOURCES_cygwin) $(SOURCES_macosx) \ + $(SOURCES_iphoneos) $(SOURCES_linux) $(SOURCES_windows) + +DISTDIR=$(LIBRARY_NAME)-$(LIBRARY_VERSION) +ORIGDIR=pd-$(LIBRARY_NAME:~=)_$(LIBRARY_VERSION) + +UNAME := $(shell uname -s) +ifeq ($(UNAME),Darwin) + CPU := $(shell uname -p) + ifeq ($(CPU),arm) # iPhone/iPod Touch + SOURCES += $(SOURCES_iphoneos) + EXTENSION = pd_darwin + OS = iphoneos + PD_PATH = /Applications/Pd-extended.app/Contents/Resources + IPHONE_BASE=/Developer/Platforms/iPhoneOS.platform/Developer/usr/bin + CC=$(IPHONE_BASE)/gcc + CPP=$(IPHONE_BASE)/cpp + CXX=$(IPHONE_BASE)/g++ + ISYSROOT = -isysroot /Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS3.0.sdk + IPHONE_CFLAGS = -miphoneos-version-min=3.0 $(ISYSROOT) -arch armv6 + OPT_CFLAGS = -fast -funroll-loops -fomit-frame-pointer + CFLAGS := $(IPHONE_CFLAGS) $(OPT_CFLAGS) $(CFLAGS) + LDFLAGS += -arch armv6 -bundle -undefined dynamic_lookup $(ISYSROOT) + LIBS += -lc + STRIP = strip -x + DISTBINDIR=$(DISTDIR)-$(OS) + else # Mac OS X + SOURCES += $(SOURCES_macosx) + EXTENSION = pd_darwin + OS = macosx + PD_PATH = /Applications/Pd-extended.app/Contents/Resources + OPT_CFLAGS = -ftree-vectorize -ftree-vectorizer-verbose=2 -fast +# build universal 32-bit on 10.4 and 32/64 on newer + ifeq ($(shell uname -r | sed 's|\([0-9][0-9]*\)\.[0-9][0-9]*\.[0-9][0-9]*|\1|'), 8) + FAT_FLAGS = -arch ppc -arch i386 -mmacosx-version-min=10.4 + else + FAT_FLAGS = -arch ppc -arch i386 -arch x86_64 -mmacosx-version-min=10.4 + SOURCES += $(SOURCES_iphoneos) + endif + CFLAGS += $(FAT_FLAGS) -fPIC -I/sw/include + LDFLAGS += $(FAT_FLAGS) -bundle -undefined dynamic_lookup -L/sw/lib + # if the 'pd' binary exists, check the linking against it to aid with stripping + LDFLAGS += $(shell test -e $(PD_PATH)/bin/pd && echo -bundle_loader $(PD_PATH)/bin/pd) + LIBS += -lc + STRIP = strip -x + DISTBINDIR=$(DISTDIR)-$(OS) +# install into ~/Library/Pd on Mac OS X since /usr/local isn't used much + pkglibdir=$(HOME)/Library/Pd + endif +endif +# Tho Android uses Linux, we use this fake uname to provide an easy way to +# setup all this things needed to cross-compile for Android using the NDK +ifeq ($(UNAME),ANDROID) + CPU := arm + SOURCES += $(SOURCES_android) + EXTENSION = pd_linux + OS = android + PD_PATH = /usr + NDK_BASE := /usr/local/android-ndk + NDK_PLATFORM_VERSION := 5 + NDK_SYSROOT=$(NDK_BASE)/platforms/android-$(NDK_PLATFORM_VERSION)/arch-arm + NDK_UNAME := $(shell uname -s | tr '[A-Z]' '[a-z]') + NDK_TOOLCHAIN_BASE=$(NDK_BASE)/toolchains/arm-linux-androideabi-4.4.3/prebuilt/$(NDK_UNAME)-x86 + CC := $(NDK_TOOLCHAIN_BASE)/bin/arm-linux-androideabi-gcc --sysroot=$(NDK_SYSROOT) + OPT_CFLAGS = -O6 -funroll-loops -fomit-frame-pointer + CFLAGS += + LDFLAGS += -Wl,--export-dynamic -shared + LIBS += -lc + STRIP := $(NDK_TOOLCHAIN_BASE)/bin/arm-linux-androideabi-strip \ + --strip-unneeded -R .note -R .comment + DISTBINDIR=$(DISTDIR)-$(OS)-$(shell uname -m) +endif +ifeq ($(UNAME),Linux) + CPU := $(shell uname -m) + SOURCES += $(SOURCES_linux) + EXTENSION = pd_linux + OS = linux + PD_PATH = /usr + OPT_CFLAGS = -O6 -funroll-loops -fomit-frame-pointer + CFLAGS += -fPIC -threepic + LDFLAGS += -Wl,--export-dynamic -shared -fPIC + LIBS += -lc + STRIP = strip --strip-unneeded -R .note -R .comment + DISTBINDIR=$(DISTDIR)-$(OS)-$(shell uname -m) +endif +ifeq ($(UNAME),GNU) + # GNU/Hurd, should work like GNU/Linux for basically all externals + CPU := $(shell uname -m) + SOURCES += $(SOURCES_linux) + EXTENSION = pd_linux + OS = linux + PD_PATH = /usr + OPT_CFLAGS = -O6 -funroll-loops -fomit-frame-pointer + CFLAGS += -fPIC + LDFLAGS += -Wl,--export-dynamic -shared -fPIC + LIBS += -lc + STRIP = strip --strip-unneeded -R .note -R .comment + DISTBINDIR=$(DISTDIR)-$(OS)-$(shell uname -m) +endif +ifeq ($(UNAME),GNU/kFreeBSD) + # Debian GNU/kFreeBSD, should work like GNU/Linux for basically all externals + CPU := $(shell uname -m) + SOURCES += $(SOURCES_linux) + EXTENSION = pd_linux + OS = linux + PD_PATH = /usr + OPT_CFLAGS = -O6 -funroll-loops -fomit-frame-pointer + CFLAGS += -fPIC + LDFLAGS += -Wl,--export-dynamic -shared -fPIC + LIBS += -lc + STRIP = strip --strip-unneeded -R .note -R .comment + DISTBINDIR=$(DISTDIR)-$(OS)-$(shell uname -m) +endif +ifeq (CYGWIN,$(findstring CYGWIN,$(UNAME))) + CPU := $(shell uname -m) + SOURCES += $(SOURCES_cygwin) + EXTENSION = dll + OS = cygwin + PD_PATH = $(cygpath $(PROGRAMFILES))/pd + OPT_CFLAGS = -O6 -funroll-loops -fomit-frame-pointer + CFLAGS += + LDFLAGS += -Wl,--export-dynamic -shared -L"$(PD_PATH)/src" -L"$(PD_PATH)/bin" + LIBS += -lc -lpd + STRIP = strip --strip-unneeded -R .note -R .comment + DISTBINDIR=$(DISTDIR)-$(OS) +endif +ifeq (MINGW,$(findstring MINGW,$(UNAME))) + CPU := $(shell uname -m) + SOURCES += $(SOURCES_windows) + EXTENSION = dll + OS = windows + PD_PATH = $(shell cd "$(PROGRAMFILES)"/pd && pwd) + OPT_CFLAGS = -O3 -funroll-loops -fomit-frame-pointer + CFLAGS += -mms-bitfields + LDFLAGS += -s -shared -Wl,--enable-auto-import + LIBS += -L"$(PD_PATH)/src" -L"$(PD_PATH)/bin" -L"$(PD_PATH)/obj" -lpd -lwsock32 -lkernel32 -luser32 -lgdi32 + STRIP = strip --strip-unneeded -R .note -R .comment + DISTBINDIR=$(DISTDIR)-$(OS) +endif + +# in case somebody manually set the HELPPATCHES above +HELPPATCHES ?= $(SOURCES:.c=-help.pd) $(PDOBJECTS:.pd=-help.pd) + +#CFLAGS += $(OPT_CFLAGS) +#CFLAGS += $(LUACFLAGS) + +.PHONY = install libdir_install single_install install-doc install-exec install-examples install-manual clean dist etags $(LIBRARY_NAME) + +all: $(SOURCES:.c=.$(EXTENSION)) + +%.o: %.c + @echo "compiling $(LIBRARY_NAME) version $(LIBRARY_VERSION)" + @echo "cflags are $(CFLAGS)" + @echo "optflags are $(OPTFLAGS)" + @echo "luacflags are $(LUACFLAGS)" + $(CC) $(CFLAGS) $(OPTFLAGS) $(LUACFLAGS) -o "$*.o" -c "$*.c" + +%.$(EXTENSION): %.o + @echo "linking $(LIBRARY_NAME) with $(LIBS)" + $(CC) $(LDFLAGS) -o "$*.$(EXTENSION)" "$*.o" $(LIBS) + chmod a-x "$*.$(EXTENSION)" + +# this links everything into a single binary file +$(LIBRARY_NAME): $(SOURCES:.c=.o) $(LIBRARY_NAME).o + $(CC) $(LDFLAGS) -o $(LIBRARY_NAME).$(EXTENSION) $(SOURCES:.c=.o) $(LIBRARY_NAME).o $(LIBS) + chmod a-x $(LIBRARY_NAME).$(EXTENSION) + +install: libdir_install + +# The meta and help files are explicitly installed to make sure they are +# actually there. Those files are not optional, then need to be there. +libdir_install: $(SOURCES:.c=.$(EXTENSION)) install-doc install-examples install-manual + $(INSTALL_DIR) $(DESTDIR)$(objectsdir)/$(LIBRARY_NAME) + $(INSTALL_DATA) $(LIBRARY_NAME)-meta.pd \ + $(DESTDIR)$(objectsdir)/$(LIBRARY_NAME) + test -z "$(strip $(SOURCES))" || (\ + $(INSTALL_PROGRAM) $(SOURCES:.c=.$(EXTENSION)) $(DESTDIR)$(objectsdir)/$(LIBRARY_NAME) && \ + $(STRIP) $(addprefix $(DESTDIR)$(objectsdir)/$(LIBRARY_NAME)/,$(SOURCES:.c=.$(EXTENSION)))) + test -z "$(strip $(shell ls $(SOURCES:.c=.tcl)))" || \ + $(INSTALL_DATA) $(shell ls $(SOURCES:.c=.tcl)) \ + $(DESTDIR)$(objectsdir)/$(LIBRARY_NAME) + test -z "$(strip $(PDOBJECTS))" || \ + $(INSTALL_DATA) $(PDOBJECTS) \ + $(DESTDIR)$(objectsdir)/$(LIBRARY_NAME) + +# install library linked as single binary +single_install: $(LIBRARY_NAME) install-doc install-exec + $(INSTALL_DIR) $(DESTDIR)$(objectsdir)/$(LIBRARY_NAME) + $(INSTALL_PROGRAM) $(LIBRARY_NAME).$(EXTENSION) $(DESTDIR)$(objectsdir)/$(LIBRARY_NAME) + $(STRIP) $(DESTDIR)$(objectsdir)/$(LIBRARY_NAME)/$(LIBRARY_NAME).$(EXTENSION) + +install-doc: + $(INSTALL_DIR) $(DESTDIR)$(objectsdir)/$(LIBRARY_NAME) + test -z "$(strip $(SOURCES) $(PDOBJECTS))" || \ + $(INSTALL_DATA) $(HELPPATCHES) \ + $(DESTDIR)$(objectsdir)/$(LIBRARY_NAME) + $(INSTALL_DATA) README.txt $(DESTDIR)$(objectsdir)/$(LIBRARY_NAME)/README.txt + $(INSTALL_DATA) LICENSE.txt $(DESTDIR)$(objectsdir)/$(LIBRARY_NAME)/LICENSE.txt + +install-examples: + test -z "$(strip $(EXAMPLES))" || \ + $(INSTALL_DIR) $(DESTDIR)$(objectsdir)/$(LIBRARY_NAME)/examples && \ + for file in $(EXAMPLES); do \ + $(INSTALL_DATA) examples/$$file $(DESTDIR)$(objectsdir)/$(LIBRARY_NAME)/examples; \ + done + +install-manual: + test -z "$(strip $(MANUAL))" || \ + $(INSTALL_DIR) $(DESTDIR)$(objectsdir)/$(LIBRARY_NAME)/manual && \ + for file in $(MANUAL); do \ + $(INSTALL_DATA) manual/$$file $(DESTDIR)$(objectsdir)/$(LIBRARY_NAME)/manual; \ + done + + +clean: + -rm -f -- $(SOURCES:.c=.o) $(SOURCES_LIB:.c=.o) + -rm -f -- $(SOURCES:.c=.$(EXTENSION)) + -rm -f -- $(LIBRARY_NAME).o + -rm -f -- $(LIBRARY_NAME).$(EXTENSION) + +distclean: clean + -rm -f -- $(DISTBINDIR).tar.gz + -rm -rf -- $(DISTBINDIR) + -rm -f -- $(DISTDIR).tar.gz + -rm -rf -- $(DISTDIR) + -rm -f -- $(ORIGDIR).tar.gz + -rm -rf -- $(ORIGDIR) + + +$(DISTBINDIR): + $(INSTALL_DIR) $(DISTBINDIR) + +libdir: all $(DISTBINDIR) + $(INSTALL_DATA) $(LIBRARY_NAME)-meta.pd $(DISTBINDIR) + $(INSTALL_DATA) $(SOURCES) $(DISTBINDIR) + $(INSTALL_DATA) $(HELPPATCHES) $(DISTBINDIR) + test -z "$(strip $(EXTRA_DIST))" || \ + $(INSTALL_DATA) $(EXTRA_DIST) $(DISTBINDIR) +# tar --exclude-vcs -czpf $(DISTBINDIR).tar.gz $(DISTBINDIR) + +$(DISTDIR): + $(INSTALL_DIR) $(DISTDIR) + +$(ORIGDIR): + $(INSTALL_DIR) $(ORIGDIR) + +dist: $(DISTDIR) + $(INSTALL_DATA) Makefile $(DISTDIR) + $(INSTALL_DATA) README.txt $(DISTDIR) + $(INSTALL_DATA) LICENSE.txt $(DISTDIR) + $(INSTALL_DATA) $(LIBRARY_NAME)-meta.pd $(DISTDIR) + test -z "$(strip $(ALLSOURCES))" || \ + $(INSTALL_DATA) $(ALLSOURCES) $(DISTDIR) + test -z "$(strip $(shell ls $(ALLSOURCES:.c=.tcl)))" || \ + $(INSTALL_DATA) $(shell ls $(ALLSOURCES:.c=.tcl)) $(DISTDIR) + test -z "$(strip $(PDOBJECTS))" || \ + $(INSTALL_DATA) $(PDOBJECTS) $(DISTDIR) + test -z "$(strip $(HELPPATCHES))" || \ + $(INSTALL_DATA) $(HELPPATCHES) $(DISTDIR) + test -z "$(strip $(EXTRA_DIST))" || \ + $(INSTALL_DATA) $(EXTRA_DIST) $(DISTDIR) + test -z "$(strip $(EXAMPLES))" || \ + $(INSTALL_DIR) $(DISTDIR)/examples && \ + for file in $(EXAMPLES); do \ + $(INSTALL_DATA) examples/$$file $(DISTDIR)/examples; \ + done + test -z "$(strip $(MANUAL))" || \ + $(INSTALL_DIR) $(DISTDIR)/manual && \ + for file in $(MANUAL); do \ + $(INSTALL_DATA) manual/$$file $(DISTDIR)/manual; \ + done + tar --exclude-vcs -czpf $(DISTDIR).tar.gz $(DISTDIR) + +# make a Debian source package +dpkg-source: + debclean + make distclean dist + mv $(DISTDIR) $(ORIGDIR) + tar --exclude-vcs -czpf ../$(ORIGDIR).orig.tar.gz $(ORIGDIR) + rm -f -- $(DISTDIR).tar.gz + rm -rf -- $(DISTDIR) $(ORIGDIR) + cd .. && dpkg-source -b $(LIBRARY_NAME) + +etags: + etags *.h $(SOURCES) ../../pd/src/*.[ch] /usr/include/*.h /usr/include/*/*.h + +showsetup: + @echo "CFLAGS: $(CFLAGS)" + @echo "LDFLAGS: $(LDFLAGS)" + @echo "LIBS: $(LIBS)" + @echo "PD_INCLUDE: $(PD_INCLUDE)" + @echo "PD_PATH: $(PD_PATH)" + @echo "objectsdir: $(objectsdir)" + @echo "LIBRARY_NAME: $(LIBRARY_NAME)" + @echo "LIBRARY_VERSION: $(LIBRARY_VERSION)" + @echo "SOURCES: $(SOURCES)" + @echo "PDOBJECTS: $(PDOBJECTS)" + @echo "ALLSOURCES: $(ALLSOURCES)" + @echo "UNAME: $(UNAME)" + @echo "CPU: $(CPU)" + @echo "pkglibdir: $(pkglibdir)" + @echo "DISTDIR: $(DISTDIR)" + @echo "ORIGDIR: $(ORIGDIR)" diff --git a/src/config.h b/src/config.h new file mode 100644 index 0000000..ed61e31 --- /dev/null +++ b/src/config.h @@ -0,0 +1,75 @@ +/* src/config.h. Generated from config.h.in by configure. */ +/* src/config.h.in. Generated from configure.ac by autoheader. */ + +/* Define to 1 if you have the header file. */ +#define HAVE_INTTYPES_H 1 + +/* Define to 1 if your system has a GNU libc compatible `malloc' function, and + to 0 otherwise. */ +#define HAVE_MALLOC 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_MEMORY_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_STDINT_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_STDLIB_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_STRINGS_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_STRING_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_STAT_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_TYPES_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_UNISTD_H 1 + +/* Define to 1 if your C compiler doesn't accept -c and -o together. */ +/* #undef NO_MINUS_C_MINUS_O */ + +/* Name of package */ +#define PACKAGE "pdlua" + +/* Define to the address where bug reports for this package should be sent. */ +#define PACKAGE_BUGREPORT "martin.peach@sympatico.ca" + +/* Define to the full name of this package. */ +#define PACKAGE_NAME "pdlua" + +/* Define to the full name and version of this package. */ +#define PACKAGE_STRING "pdlua 0.1" + +/* Define to the one symbol short name of this package. */ +#define PACKAGE_TARNAME "pdlua" + +/* Define to the home page for this package. */ +#define PACKAGE_URL "" + +/* Define to the version of this package. */ +#define PACKAGE_VERSION "0.1" + +/* Define to 1 if you have the ANSI C header files. */ +#define STDC_HEADERS 1 + +/* Version number of package */ +#define VERSION "0.6" + +/* Define to empty if `const' does not conform to ANSI C. */ +/* #undef const */ + +/* Define to rpl_malloc if the replacement function should be used. */ +/* #undef malloc */ + +/* Define to `unsigned int' if does not define. */ +/* #undef size_t */ + +/* Define to `int' if does not define. */ +/* #undef ssize_t */ diff --git a/src/hello-help.pd b/src/hello-help.pd new file mode 100644 index 0000000..8f7e3ea --- /dev/null +++ b/src/hello-help.pd @@ -0,0 +1,10 @@ +#N canvas 43 60 476 189 10; +#X obj 34 62 hello; +#X obj 94 62 hello; +#X obj 154 62 hello; +#X obj 214 62 hello; +#X text 33 95 See also:; +#X text 32 14 [lua] registers a loader that allows [hello] to be defined +by a source file "hello.pd_lua".; +#X obj 49 125 pdlua; +#X obj 93 125 pdluax hello; diff --git a/src/hello.lua b/src/hello.lua new file mode 100644 index 0000000..1967df0 --- /dev/null +++ b/src/hello.lua @@ -0,0 +1 @@ +pd.post("Hello, you!") diff --git a/src/hello.pd_lua b/src/hello.pd_lua new file mode 100644 index 0000000..7024855 --- /dev/null +++ b/src/hello.pd_lua @@ -0,0 +1,12 @@ +pd.post("Hello, universe!") + +local Hello = pd.Class:new():register("hello") + +function Hello:initialize(name, atoms) + pd.post("Hello, world!") + return true +end + +function Hello:finalize() + pd.post("Bye bye, world!") +end diff --git a/src/hello.pd_luax b/src/hello.pd_luax new file mode 100644 index 0000000..5eb1f14 --- /dev/null +++ b/src/hello.pd_luax @@ -0,0 +1,4 @@ +return function(self, sel, atoms) + pd.post("Hello, world!") + return true +end diff --git a/src/pd.lua b/src/pd.lua new file mode 100644 index 0000000..341894f --- /dev/null +++ b/src/pd.lua @@ -0,0 +1,303 @@ +--[[ +pdlua -- a Lua embedding for Pd +Copyright (C) 2007,2008 Claude Heiland-Allen + +This program is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License +as published by the Free Software Foundation; either version 2 +of the License, or (at your option) any later version. + +This program 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +--]] + +-- storage for Pd C<->Lua interaction +pd._classes = { } +pd._objects = { } +pd._clocks = { } +pd._receives = { } + +-- add a path to Lua's "require" search paths +pd._setrequirepath = function(path) + pd._packagepath = package.path + pd._packagecpath = package.cpath + if (pd._iswindows) then + package.path = path .. "\\?;" .. path .. "\\?.lua;" .. package.path + package.cpath = path .. "\\?.dll;" .. package.cpath + else + package.path = path .. "/?;" .. path .. "/?.lua;" .. package.path + package.cpath = path .. "/?.so;" .. package.cpath + end +end + +-- reset Lua's "require" search paths +pd._clearrequirepath = function() + package.path = pd._packagepath + package.cpath = pd._packagecpath +end + +-- constructor dispatcher +pd._constructor = function (name, atoms) + if nil ~= pd._classes[name] then + local o = pd._classes[name]:new():construct(name, atoms) + if o then + pd._objects[o._object] = o + return o._object + end + end + return nil +end + +-- destructor dispatcher +pd._destructor = function (object) + if nil ~= pd._objects[object] then + pd._objects[object]:destruct() + end +end + +-- inlet method dispatcher +pd._dispatcher = function (object, inlet, sel, atoms) + if nil ~= pd._objects[object] then + pd._objects[object]:dispatch(inlet, sel, atoms) + end +end + +-- clock method dispatcher +pd._clockdispatch = function (c) + if nil ~= pd._clocks[c] then + local m = pd._clocks[c]._method + pd._clocks[c]._target[m](pd._clocks[c]._target) + end +end + +-- prototypical OO system +pd.Prototype = { } +function pd.Prototype:new(o) + o = o or {} + setmetatable(o, self) + self.__index = self + return o +end + + +-- clocks +pd.Clock = pd.Prototype:new() +function pd.Clock:register(object, method) + if nil ~= object then + if nil ~= object._object then + self._clock = pd._createclock(object._object, method) + self._target = object + self._method = method + pd._clocks[self._clock] = self + return self + end + end + return nil +end +function pd.Clock:destruct() + pd._clocks[self._clock] = nil + pd._clockfree(self._clock) + self._clock = nil +end +function pd.Clock:dispatch() + local m = self._target[self._method] + if type(m) == "function" then + return m(self._target) + else + self._target:error( + "no method for `" .. self._method .. + "' at clock of Lua object `" .. self._name .. "'" + ) + end +end +function pd.Clock:set(systime) + pd._clockset(self._clock, systime) +end +function pd.Clock:delay(delaytime) + pd._clockdelay(self._clock, delaytime) +end +function pd.Clock:unset() + pd._clockunset(self._clock) +end + +-- tables +pd.Table = pd.Prototype:new() +function pd.Table:sync(name) + self.name = name + self._length, self._array = pd._getarray(name) + if self._length < 0 then + return nil + else + return self + end +end +function pd.Table:destruct() + self._length = -3 + self._array = nil +end +function pd.Table:get(i) + if type(i) == "number" and 0 <= i and i < self._length then + return pd._readarray(self._length, self._array, i) + else + return nil + end +end +function pd.Table:set(i, f) + if type(i) == "number" and type(f) == "number" and 0 <= i and i < self._length then + return pd._writearray(self._length, self._array, i, f) + else + return nil + end +end +function pd.Table:length() + if self._length >= 0 then + return self._length + else + return nil + end +end +function pd.Table:redraw() + pd._redrawarray(self.name) +end + +-- receivers +function pd._receivedispatch(receive, sel, atoms) + if nil ~= pd._receives[receive] then + pd._receives[receive]:dispatch(sel, atoms) + end +end +pd.Receive = pd.Prototype:new() +function pd.Receive:register(object, name, method) + if nil ~= object then + if nil ~= object._object then + self._receive = pd._createreceive(object._object, name) + self._name = name + self._target = object + self._method = method + pd._receives[self._receive] = self + return self + end + end + return nil +end +function pd.Receive:destruct() + pd._receives[self._receive] = nil + pd._receivefree(self._receive) + self._receive = nil + self._name = nil + self._target = nil + self._method = nil +end +function pd.Receive:dispatch(sel, atoms) + self._target[self._method](self._target, sel, atoms) +end + +-- patchable objects +pd.Class = pd.Prototype:new() +function pd.Class:register(name) + if nil ~= pd._classes[name] then -- already registered + return pd._classes[name] -- return existing + else + self._class = pd._register(name) -- register new class + pd._classes[name] = self -- record registration + self._name = name + return self -- return new + end +end +function pd.Class:construct(sel, atoms) + self._object = pd._create(self._class) + self.inlets = 0 + self.outlets = 0 + if self:initialize(sel, atoms) then + pd._createinlets(self._object, self.inlets) + pd._createoutlets(self._object, self.outlets) + self:postinitialize() + return self + else + return nil + end +end +function pd.Class:destruct() + pd._objects[self] = nil + self:finalize() + pd._destroy(self._object) +end +function pd.Class:dispatch(inlet, sel, atoms) + local m = self["in_" .. inlet .. "_" .. sel] + if type(m) == "function" then + if sel == "bang" then return m(self) end + if sel == "float" then return m(self, atoms[1]) end + if sel == "symbol" then return m(self, atoms[1]) end + if sel == "pointer" then return m(self, atoms[1]) end + if sel == "list" then return m(self, atoms) end + return m(self, atoms) + end + m = self["in_n_" .. sel] + if type(m) == "function" then + if sel == "bang" then return m(self, inlet) end + if sel == "float" then return m(self, inlet, atoms[1]) end + if sel == "symbol" then return m(self, inlet, atoms[1]) end + if sel == "pointer" then return m(self, inlet, atoms[1]) end + if sel == "list" then return m(self, inlet, atoms) end + return m(self, inlet, atoms) + end + m = self["in_" .. inlet] + if type(m) == "function" then + return m(self, sel, atoms) + end + m = self["in_n"] + if type(m) == "function" then + return m(self, inlet, sel, atoms) + end + self:error( + "no method for `" .. sel .. + "' at inlet " .. inlet .. + " of Lua object `" .. self._name .. "'" + ) +end +function pd.Class:outlet(outlet, sel, atoms) + pd._outlet(self._object, outlet, sel, atoms) +end +function pd.Class:initialize(sel, atoms) end +function pd.Class:postinitialize() end +function pd.Class:finalize() end +function pd.Class:dofile(file) + return pd._dofile(self._object, file) +end +function pd.Class:error(msg) + pd._error(self._object, msg) +end + + +local lua = pd.Class:new():register("pdlua") -- global controls +function lua:initialize(sel, atoms) + self.inlets = 1 + self.outlets = 0 -- FIXME: might be nice to have errors go here? + return true +end +function lua:in_1_load(atoms) -- execute a script + self:dofile(atoms[1]) +end + + +local luax = pd.Class:new():register("pdluax") -- classless lua externals +function luax:initialize(sel, atoms) -- motivation: pd-list 2007-09-23 + local f = self:dofile(atoms[1] .. ".pd_luax") + if nil ~= f then + local atomstail = { } -- munge for better lua<->luax compatibility + for i,_ in ipairs(atoms) do + if i > 1 then + atomstail[i-1] = atoms[i] + end + end + return f(self, atoms[1], atomstail) + else + return false -- error message already output by dofile() + end +end diff --git a/src/pdlua-help.pd b/src/pdlua-help.pd new file mode 100644 index 0000000..efd122d --- /dev/null +++ b/src/pdlua-help.pd @@ -0,0 +1,15 @@ +#N canvas 0 22 534 259 10; +#X msg 44 58; +#X text 118 58 << more methods will come (maybe); +#X text 118 102 << global interface to pdlua; +#X text 118 20 << load and run a Lua file (searches Pd's path); +#X msg 17 21 load hello.lua; +#X text 17 191 See also:; +#X obj 37 216 hello; +#X text 15 135 Side-effects:; +#X obj 17 101 pdlua; +#X obj 87 216 pdluax hello; +#X text 29 157 [pdlua] registers a loader that allows Pd classes written +in Lua to be loaded.; +#X connect 0 0 8 0; +#X connect 4 0 8 0; diff --git a/src/pdlua-meta.pd b/src/pdlua-meta.pd new file mode 100644 index 0000000..ae8607a --- /dev/null +++ b/src/pdlua-meta.pd @@ -0,0 +1,10 @@ +#N canvas 10 10 200 200 10; +#N canvas 360 159 420 300 META 0; +#X text 10 10 META this is a prototype of a libdir meta file; +#X text 10 30 NAME pdlua; +#X text 10 50 LICENSE GNU GPL; +#X text 10 70 DESCRIPTION lua loader for pd; +#X text 10 90 AUTHOR Claude Heiland-Allen \, Frank Barknecht \, Martin +Peach; +#X text 10 110 VERSION 0.6; +#X restore 10 20 pd META; diff --git a/src/pdlua.c b/src/pdlua.c new file mode 100644 index 0000000..cdf9c12 --- /dev/null +++ b/src/pdlua.c @@ -0,0 +1,1427 @@ +/* This is a version hacked by Martin Peach 20110120 martin.peach@sympatico.ca */ +/* Reformmatted the code and added some debug messages. Changed the name of the class to pdlua */ +/** @file lua.c + * @brief pdlua -- a Lua embedding for Pd. + * @author Claude Heiland-Allen + * @date 2008 + * @version 0.6~svn + * + * Copyright (C) 2007,2008 Claude Heiland-Allen + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +/* various C stuff, mainly for reading files */ +#include +#include +#include +#ifdef _MSC_VER +#include +#define read _read +#define close _close +#define ssize_t int +#else +#include +#endif +/* we use Lua */ +#include +#include +#include + +/* we use Pd */ +#include "m_pd.h" +#include "s_stuff.h" // for sys_register_loader() +#ifdef _MSC_VER +#include +#endif +/* BAD: support for Pd < 0.41 */ + +#if PD_MAJOR_VERSION == 0 +# if PD_MINOR_VERSION >= 41 +# define PDLUA_PD41 +/* use new garray support that is 64-bit safe */ +# define PDLUA_ARRAYGRAB garray_getfloatwords +# define PDLUA_ARRAYTYPE t_word +# define PDLUA_ARRAYELEM(arr,idx) ((arr)[(idx)].w_float) +# elif PD_MINOR_VERSION >= 40 +# define PDLUA_PD40 +/* use old garray support, not 64-bit safe */ +# define PDLUA_ARRAYGRAB garray_getfloatarray +# define PDLUA_ARRAYTYPE t_float +# define PDLUA_ARRAYELEM(arr,idx) ((arr)[(idx)]) +# elif PD_MINOR_VERSION >= 39 +# define PDLUA_PD39 +/* use old garray support, not 64-bit safe */ +# define PDLUA_ARRAYGRAB garray_getfloatarray +# define PDLUA_ARRAYTYPE t_float +# define PDLUA_ARRAYELEM(arr,idx) ((arr)[(idx)]) +# else +# error "Pd version is too old, please upgrade" +# endif +#else +# error "Pd version is too new, please file a bug report" +#endif + +/* BAD: end of bad section */ + +/* EVIL: TODO: File requests/patches to Pd so that this becomes unnecessary. */ + +/** Pd loader type, defined in pd/src/s_loader.c but not exported. */ +//typedef int (*loader_t)(t_canvas *, char *); + +/** Pd loader registration, defined in pd/src/s_loader.c but not exported. */ +//void sys_register_loader(loader_t loader); + +/** Pd extern dir declaration (for help finding), defined in pd/src/m_class.c but not exported. */ +//void class_set_extern_dir(t_symbol *s); + +/** Pd [value] getter, defined in pd/src/x_connective.c but not exported. */ +//int value_getfloat(t_symbol *s, t_float *f); + +/** Pd [value] setter, defined in pd/src/x_connective.c but not exported. */ +//int value_setfloat(t_symbol *s, t_float f); + +/* EVIL: end of evil section. */ + +/* If defined, PDLUA_DEBUG lets pdlua post a lot of text */ +// #define PDLUA_DEBUG +/** Global Lua interpreter state, needed in the constructor. */ +static lua_State *L; + +/** State for the Lua file reader. */ +typedef struct pdlua_readerdata +{ + int fd; /**< File descriptor to read from. */ + char buffer[MAXPDSTRING]; /**< Buffer to read into. */ +} t_pdlua_readerdata; + +/** Lua file reader callback. */ +static const char *pdlua_reader +( + lua_State *L, /**< Lua interpreter state. */ + void *rr, /**< Lua file reader state. */ + size_t *size /**< How much data we have read. */ +) +{ + t_pdlua_readerdata *r = rr; + ssize_t s; +#ifdef PDLUA_DEBUG + post("pdlua_reader: fd is %d", r->fd); +#endif // PDLUA_DEBUG + s = read(r->fd, r->buffer, MAXPDSTRING-2); +#ifdef PDLUA_DEBUG + post("pdlua_reader: s is %ld", s);//////// +#endif // PDLUA_DEBUG + if (s <= 0) + { + *size = 0; + return NULL; + } + else + { + *size = s; + return r->buffer; + } +} + +/* declare some stuff in advance */ +struct pdlua_proxyinlet; +struct pdlua_proxyreceive; +struct pdlua_proxyclock; + +/** Pd object data. */ +typedef struct pdlua +{ + t_object pd; /**< We are a Pd object. */ + unsigned int inlets; /**< Number of inlets. */ + struct pdlua_proxyinlet *in; /**< The inlets themselves. */ + unsigned int outlets; /**< Number of outlets. */ + t_outlet **out; /**< The outlets themselves. */ + t_canvas *canvas; /**< The canvas that the object was created on. */ +} t_pdlua; + +/* more forward declarations */ +static void pdlua_dispatch(t_pdlua *o, unsigned int inlet, t_symbol *s, int argc, t_atom *argv); +static void pdlua_receivedispatch(struct pdlua_proxyreceive *r, t_symbol *s, int argc, t_atom *argv); +static void pdlua_clockdispatch(struct pdlua_proxyclock *clock); + +/** Proxy inlet class pointer. */ +static t_class *pdlua_proxyinlet_class; + +/** Proxy inlet object data. */ +typedef struct pdlua_proxyinlet +{ + t_pd pd; /**< Minimal Pd object. */ + struct pdlua *owner; /**< The owning object to forward inlet messages to. */ + unsigned int id; /**< The number of this inlet. */ +} t_pdlua_proxyinlet; + +/** Proxy inlet 'anything' method. */ +static void pdlua_proxyinlet_anything +( + t_pdlua_proxyinlet *p, /**< The proxy inlet that received the message. */ + t_symbol *s, /**< The message selector. */ + int argc, /**< The message length. */ + t_atom *argv /**< The atoms in the message. */ +) +{ + pdlua_dispatch(p->owner, p->id, s, argc, argv); +} + +/** Proxy inlet initialization. */ +static void pdlua_proxyinlet_init +( + t_pdlua_proxyinlet *p, /**< The proxy inlet to initialize. */ + struct pdlua *owner, /**< The owning object. */ + unsigned int id /**< The inlet number. */ +) +{ + p->pd = pdlua_proxyinlet_class; + p->owner = owner; + p->id = id; +} + +/** Register the proxy inlet class with Pd. */ +static void pdlua_proxyinlet_setup(void) +{ + pdlua_proxyinlet_class = class_new(gensym("pdlua proxy inlet"), 0, 0, sizeof(t_pdlua_proxyinlet), 0, 0); + class_addanything(pdlua_proxyinlet_class, pdlua_proxyinlet_anything); +} + +/** Proxy receive class pointer. */ +static t_class *pdlua_proxyreceive_class; + +/** Proxy receive object data. */ +typedef struct pdlua_proxyreceive +{ + t_pd pd; /**< Minimal Pd object. */ + struct pdlua *owner; /**< The owning object to forward received messages to. */ + t_symbol *name; /**< The receive-symbol to bind to. */ +} t_pdlua_proxyreceive; + +/** Proxy receive 'anything' method. */ +static void pdlua_proxyreceive_anything( + t_pdlua_proxyreceive *r, /**< The proxy receive that received the message. */ + t_symbol *s, /**< The message selector. */ + int argc, /**< The message length. */ + t_atom *argv /**< The atoms in the message. */ +) +{ + pdlua_receivedispatch(r, s, argc, argv); +} + +/** Proxy receive allocation and initialization. */ +static t_pdlua_proxyreceive *pdlua_proxyreceive_new +( + struct pdlua *owner, /**< The owning object. */ + t_symbol *name /**< The symbol to bind to. */ +) +{ + t_pdlua_proxyreceive *r = malloc(sizeof(t_pdlua_proxyreceive)); + r->pd = pdlua_proxyreceive_class; + r->owner = owner; + r->name = name; + pd_bind(&r->pd, r->name); + return r; +} + +/** Proxy receive cleanup and deallocation. */ +static void pdlua_proxyreceive_free(t_pdlua_proxyreceive *r /**< The proxy receive to free. */) +{ + pd_unbind(&r->pd, r->name); + r->pd = NULL; + r->owner = NULL; + r->name = NULL; + free(r); +} + +/** Register the proxy receive class with Pd. */ +static void pdlua_proxyreceive_setup() +{ + pdlua_proxyreceive_class = class_new(gensym("pdlua proxy receive"), 0, 0, sizeof(t_pdlua_proxyreceive), 0, 0); + class_addanything(pdlua_proxyreceive_class, pdlua_proxyreceive_anything); +} + + +/** Proxy clock class pointer. */ +static t_class *pdlua_proxyclock_class; + +/** Proxy clock object data. */ +typedef struct pdlua_proxyclock +{ + t_pd pd; /**< Minimal Pd object. */ + struct pdlua *owner; /**< Object to forward messages to. */ + t_clock *clock; /** Pd clock to use. */ +} t_pdlua_proxyclock; + +/** Proxy clock 'bang' method. */ +static void pdlua_proxyclock_bang(t_pdlua_proxyclock *c /**< The proxy clock that received the message. */) +{ + pdlua_clockdispatch(c); +} + +/** Proxy clock allocation and initialization. */ +static t_pdlua_proxyclock *pdlua_proxyclock_new +( + struct pdlua *owner /**< The object to forward messages to. */ +) +{ + t_pdlua_proxyclock *c = malloc(sizeof(t_pdlua_proxyclock)); + c->pd = pdlua_proxyclock_class; + c->owner = owner; + c->clock = clock_new(c, (t_method) pdlua_proxyclock_bang); + return c; +} + +/** Register the proxy clock class with Pd. */ +static void pdlua_proxyclock_setup(void) +{ + pdlua_proxyclock_class = class_new(gensym("pdlua proxy clock"), 0, 0, sizeof(t_pdlua_proxyclock), 0, 0); +} + +/** Dump an array of atoms into a Lua table. */ +static void pdlua_pushatomtable +( + int argc, /**< The number of atoms in the array. */ + t_atom *argv /**< The array of atoms. */ +) +{ + int i; + + lua_newtable(L); + for (i = 0; i < argc; ++i) + { + lua_pushnumber(L, i+1); + switch (argv[i].a_type) + { + case A_FLOAT: + lua_pushnumber(L, argv[i].a_w.w_float); + break; + case A_SYMBOL: + lua_pushstring(L, argv[i].a_w.w_symbol->s_name); + break; + case A_POINTER: /* FIXME: check experimentality */ + lua_pushlightuserdata(L, argv[i].a_w.w_gpointer); + break; + default: + error("lua: zomg weasels!"); + lua_pushnil(L); + break; + } + lua_settable(L, -3); + } +} + +/** Pd object constructor. */ +static t_pdlua *pdlua_new +( + t_symbol *s, /**< The construction message selector. */ + int argc, /**< The construction message atom count. */ + t_atom *argv /**< The construction message atoms. */ +) +{ + int i; +#ifdef PDLUA_DEBUG + post("pdlua_new: s->s_name is %s", s->s_name); +#endif // PDLUA_DEBUG + for (i = 0; i < argc; ++i) + { + switch (argv[i].a_type) + { + case A_FLOAT: +#ifdef PDLUA_DEBUG + post("argv[%d]: %f", i, argv[i].a_w.w_float); +#endif // PDLUA_DEBUG + break; + case A_SYMBOL: +#ifdef PDLUA_DEBUG + post("argv[%d]: %s", i, argv[i].a_w.w_symbol->s_name); +#endif // PDLUA_DEBUG + break; + default: + error("pdlua_new: bad argument type"); // should never happen + return NULL; + } + } + lua_getglobal(L, "pd"); + lua_getfield(L, -1, "_constructor"); + lua_pushstring(L, s->s_name); + pdlua_pushatomtable(argc, argv); + if (lua_pcall(L, 2, 1, 0)) + { + error("pdlua_new: error in constructor for `%s':\n%s", s->s_name, lua_tostring(L, -1)); + lua_pop(L, 1); + return NULL; + } + else + { + t_pdlua *object = NULL; +#ifdef PDLUA_DEBUG + post("pdlua_new: done lua_pcall(L, 2, 1, 0)"); +#endif // PDLUA_DEBUG + if (lua_islightuserdata(L, -1)) + { + object = lua_touserdata(L, -1); + lua_pop(L, 1); +#ifdef PDLUA_DEBUG + post("pdlua_new: TRUE lua_islightuserdata(L, -1) object = %p", object); +#endif // PDLUA_DEBUG + return object; + } + else + { + lua_pop(L, 1); +#ifdef PDLUA_DEBUG + post("pdlua_new: done FALSE lua_islightuserdata(L, -1)"); +#endif // PDLUA_DEBUG + return NULL; + } + } +} + +/** Pd object destructor. */ +static void pdlua_free( t_pdlua *o /**< The object to destruct. */) +{ + lua_getglobal(L, "pd"); + lua_getfield (L, -1, "_destructor"); + lua_pushlightuserdata(L, o); + if (lua_pcall(L, 1, 0, 0)) + { + error("lua: error in destructor:\n%s", lua_tostring(L, -1)); + lua_pop(L, 1); + } + return; +} + +/** Lua class registration. */ +static int pdlua_class_new(lua_State *L) +/**< Lua interpreter state. + * \par Inputs: + * \li \c 1 Class name string. + * \par Outputs: + * \li \c 1 Pd class pointer. + * */ +{ + const char *name; + t_class *c; + +#ifdef PDLUA_DEBUG + post("pdlua_class_new:"); +#endif // PDLUA_DEBUG + name = luaL_checkstring(L, 1); + c = class_new(gensym((char *) name), (t_newmethod) pdlua_new, + (t_method) pdlua_free, sizeof(t_pdlua), CLASS_NOINLET, A_GIMME, 0); + lua_pushlightuserdata(L, c); + return 1; +} + +/** Lua object creation. */ +static int pdlua_object_new(lua_State *L) +/**< Lua interpreter state. + * \par Inputs: + * \li \c 1 Pd class pointer. + * \par Outputs: + * \li \c 2 Pd object pointer. + * */ +{ +#ifdef PDLUA_DEBUG + post("pdlua_object_new:"); +#endif // PDLUA_DEBUG + if (lua_islightuserdata(L, 1)) + { + t_class *c = lua_touserdata(L, 1); + if (c) + { + t_pdlua *o = (t_pdlua *) pd_new(c); + if (o) + { + o->inlets = 0; + o->in = NULL; + o->outlets = 0; + o->out = NULL; + o->canvas = canvas_getcurrent(); + lua_pushlightuserdata(L, o); + return 1; + } + } + } + return 0; +} + +/** Lua object inlet creation. */ +static int pdlua_object_createinlets(lua_State *L) +/**< Lua interpreter state. + * \par Inputs: + * \li \c 1 Pd object pointer. + * \li \c 2 Number of inlets. + * */ +{ + unsigned int i; + +#ifdef PDLUA_DEBUG + post("pdlua_object_createinlets:"); +#endif // PDLUA_DEBUG + if (lua_islightuserdata(L, 1)) + { + t_pdlua *o = lua_touserdata(L, 1); + if (o) + { + o->inlets = luaL_checknumber(L, 2); + o->in = malloc(o->inlets * sizeof(t_pdlua_proxyinlet)); + for (i = 0; i < o->inlets; ++i) + { + pdlua_proxyinlet_init(&o->in[i], o, i); + inlet_new(&o->pd, &o->in[i].pd, 0, 0); + } + } + } + return 0; +} + +/** Lua object outlet creation. */ +static int pdlua_object_createoutlets(lua_State *L) +/**< Lua interpreter state. + * \par Inputs: + * \li \c 1 Pd object pointer. + * \li \c 2 Number of outlets. + * */ +{ + unsigned int i; + +#ifdef PDLUA_DEBUG + post("pdlua_object_createoutlets:"); +#endif // PDLUA_DEBUG + if (lua_islightuserdata(L, 1)) + { + t_pdlua *o = lua_touserdata(L, 1); + if (o) + { + o->outlets = luaL_checknumber(L, 2); + if (o->outlets > 0) + { + o->out = malloc(o->outlets * sizeof(t_outlet *)); + for (i = 0; i < o->outlets; ++i) o->out[i] = outlet_new(&o->pd, 0); + } + else o->out = NULL; + } + } + return 0; +} + +/** Lua object receive creation. */ +static int pdlua_receive_new(lua_State *L) +/**< Lua interpreter state. + * \par Inputs: + * \li \c 1 Pd object pointer. + * \li \c 2 Receive name string. + * \par Outputs: + * \li \c 1 Pd receive pointer. + * */ +{ +#ifdef PDLUA_DEBUG + post("pdlua_receive_new:"); +#endif // PDLUA_DEBUG + if (lua_islightuserdata(L, 1)) + { + t_pdlua *o = lua_touserdata(L, 1); + if (o) + { + const char *name = luaL_checkstring(L, 2); + if (name) + { + t_pdlua_proxyreceive *r = pdlua_proxyreceive_new(o, gensym((char *) name)); /* const cast */ + lua_pushlightuserdata(L, r); + return 1; + } + } + } + return 0; +} + +/** Lua object receive destruction. */ +static int pdlua_receive_free(lua_State *L) +/**< Lua interpreter state. + * \par Inputs: + * \li \c 1 Pd recieve pointer. + * */ +{ +#ifdef PDLUA_DEBUG + post("pdlua_receive_free:"); +#endif // PDLUA_DEBUG + if (lua_islightuserdata(L, 1)) + { + t_pdlua_proxyreceive *r = lua_touserdata(L, 1); + if (r) pdlua_proxyreceive_free(r); + } + return 0; +} + +/** Lua object clock creation. */ +static int pdlua_clock_new(lua_State *L) +/**< Lua interpreter state. + * \par Inputs: + * \li \c 1 Pd object pointer. + * \par Outputs: + * \li \c 1 Pd clock pointer. + * */ +{ + if (lua_islightuserdata(L, 1)) + { + t_pdlua *o = lua_touserdata(L, 1); + if (o) + { + t_pdlua_proxyclock *c = pdlua_proxyclock_new(o); + lua_pushlightuserdata(L, c); + return 1; + } + } + return 0; +} + +/** Lua proxy clock delay. */ +static int pdlua_clock_delay(lua_State *L) +/**< Lua interpreter state. + * \par Inputs: + * \li \c 1 Pd clock pointer. + * \li \c 2 Number of milliseconds to delay. + * */ +{ + if (lua_islightuserdata(L, 1)) + { + t_pdlua_proxyclock *c = lua_touserdata(L, 1); + if (c) + { + double delaytime = luaL_checknumber(L, 2); + clock_delay(c->clock, delaytime); + } + } + return 0; +} + +/** Lua proxy clock set. */ +static int pdlua_clock_set(lua_State *L) +/**< Lua interpreter state. + * \par Inputs: + * \li \c 1 Pd clock pointer. + * \li \c 2 Number to set the clock. + * */ +{ + if (lua_islightuserdata(L, 1)) + { + t_pdlua_proxyclock *c = lua_touserdata(L, 1); + if (c) + { + double systime = luaL_checknumber(L, 2); + clock_set(c->clock, systime); + } + } + return 0; +} + +/** Lua proxy clock unset. */ +static int pdlua_clock_unset(lua_State *L) +/**< Lua interpreter state. + * \par Inputs: + * \li \c 1 Pd clock pointer. + * */ +{ + if (lua_islightuserdata(L, 1)) + { + t_pdlua_proxyclock *c = lua_touserdata(L, 1); + if (c) clock_unset(c->clock); + } + return 0; +} + +/** Lua proxy clock destruction. */ +static int pdlua_clock_free(lua_State *L) +/**< Lua interpreter state. + * \par Inputs: + * \li \c 1 Pd clock pointer. + * */ +{ + if (lua_islightuserdata(L, 1)) + { + t_pdlua_proxyclock *c = lua_touserdata(L, 1); + if (c) + { + clock_free(c->clock); + free(c); + } + } + return 0; +} + +/** Lua object destruction. */ +static int pdlua_object_free(lua_State *L) +/**< Lua interpreter state. + * \par Inputs: + * \li \c 1 Pd object pointer. + * */ +{ + unsigned int i; + +#ifdef PDLUA_DEBUG + post("pdlua_object_free:"); +#endif // PDLUA_DEBUG + if (lua_islightuserdata(L, 1)) + { + t_pdlua *o = lua_touserdata(L, 1); + if (o) + { + if (o->in) free(o->in); + if(o->out) + { + for (i = 0; i < o->outlets; ++i) outlet_free(o->out[i]); + free(o->out); + o->out = NULL; + } + } + } + return 0; +} + +/** Dispatch Pd inlet messages to Lua objects. */ +static void pdlua_dispatch +( + t_pdlua *o, /**< The object that received the message. */ + unsigned int inlet, /**< The inlet that the message arrived at. */ + t_symbol *s, /**< The message selector. */ + int argc, /**< The message length. */ + t_atom *argv /**< The atoms in the message. */ +) +{ +#ifdef PDLUA_DEBUG + post("pdlua_dispatch:"); +#endif // PDLUA_DEBUG + lua_getglobal(L, "pd"); + lua_getfield (L, -1, "_dispatcher"); + lua_pushlightuserdata(L, o); + lua_pushnumber(L, inlet + 1); /* C has 0.., Lua has 1.. */ + lua_pushstring(L, s->s_name); + pdlua_pushatomtable(argc, argv); + if (lua_pcall(L, 4, 0, 0)) + { + pd_error(o, "lua: error in dispatcher:\n%s", lua_tostring(L, -1)); + lua_pop(L, 1); + } + return; +} + +/** Dispatch Pd receive messages to Lua objects. */ +static void pdlua_receivedispatch +( + t_pdlua_proxyreceive *r, /**< The proxy receive that received the message. */ + t_symbol *s, /**< The message selector. */ + int argc, /**< The message length. */ + t_atom *argv /**< The atoms in the message. */ +) +{ +#ifdef PDLUA_DEBUG + post("pdlua_receivedispatch:"); +#endif // PDLUA_DEBUG + lua_getglobal(L, "pd"); + lua_getfield (L, -1, "_receivedispatch"); + lua_pushlightuserdata(L, r); + lua_pushstring(L, s->s_name); + pdlua_pushatomtable(argc, argv); + if (lua_pcall(L, 3, 0, 0)) + { + pd_error(r->owner, "lua: error in receive dispatcher:\n%s", lua_tostring(L, -1)); + lua_pop(L, 1); + } + return; +} + +/** Dispatch Pd clock messages to Lua objects. */ +static void pdlua_clockdispatch( t_pdlua_proxyclock *clock) +/**< The proxy clock that received the message. */ +{ + lua_getglobal(L, "pd"); + lua_getfield (L, -1, "_clockdispatch"); + lua_pushlightuserdata(L, clock); + if (lua_pcall(L, 1, 0, 0)) + { + pd_error(clock->owner, "lua: error in clock dispatcher:\n%s", lua_tostring(L, -1)); + lua_pop(L, 1); + } + return; +} + +/** Convert a Lua table into a Pd atom array. */ +static t_atom *pdlua_popatomtable +( + lua_State *L, /**< Lua interpreter state. + * \par Inputs: + * \li \c -1 Table to convert. + * */ + int *count, /**< Where to store the array length. */ + t_pdlua *o /**< Object reference for error messages. */ +) +{ + int i; + int ok = 1; + t_float f; + const char *s; + void *p; + size_t sl; + t_atom *atoms = NULL; + + if (lua_istable(L, -1)) + { + *count = lua_objlen(L, -1); + if (*count > 0) atoms = malloc(*count * sizeof(t_atom)); + i = 0; + lua_pushnil(L); + while (lua_next(L, -2) != 0) + { + if (i == *count) + { + pd_error(o, "lua: error: too many table elements"); + ok = 0; + break; + } + switch (lua_type(L, -1)) + { + case (LUA_TNUMBER): + f = lua_tonumber(L, -1); + SETFLOAT(&atoms[i], f); + break; + case (LUA_TSTRING): + s = lua_tolstring(L, -1, &sl); + if (s) + { + if (strlen(s) != sl) pd_error(o, "lua: warning: symbol munged (contains \\0 in body)"); + SETSYMBOL(&atoms[i], gensym((char *) s)); + } + else + { + pd_error(o, "lua: error: null string in table"); + ok = 0; + } + break; + case (LUA_TLIGHTUSERDATA): /* FIXME: check experimentality */ + p = lua_touserdata(L, -1); + SETPOINTER(&atoms[i], p); + break; + default: + pd_error(o, "lua: error: table element must be number or string or pointer"); + ok = 0; + break; + } + lua_pop(L, 1); + ++i; + } + if (i != *count) + { + pd_error(o, "lua: error: too few table elements"); + ok = 0; + } + } + else + { + pd_error(o, "lua: error: not a table"); + ok = 0; + } + lua_pop(L, 1); + if (ok) return atoms; + if (atoms) free(atoms); + return NULL; +} + +/** Send a message from a Lua object outlet. */ +static int pdlua_outlet(lua_State *L) +/**< Lua interpreter state. + * \par Inputs: + * \li \c 1 Pd object pointer. + * \li \c 2 Outlet number. + * \li \c 3 Message selector string. + * \li \c 4 Message atom table. + * */ +{ + t_pdlua *o; + int out; + size_t sl; + const char *s; + t_symbol *sym; + int count; + t_atom *atoms; + +#ifdef PDLUA_DEBUG + post("pdlua_outlet:"); +#endif // PDLUA_DEBUG + if (lua_islightuserdata(L, 1)) + { + o = lua_touserdata(L, 1); + if (o) + { + if (lua_isnumber(L, 2)) out = lua_tonumber(L, 2) - 1; /* C has 0.., Lua has 1.. */ + else + { + pd_error(o, "lua: error: outlet must be a number"); + return 0; + } + if (0 <= out && out < o->outlets) + { + if (lua_isstring(L, 3)) + { + s = lua_tolstring(L, 3, &sl); + sym = gensym((char *) s); /* const cast */ + if (s) + { + if (strlen(s) != sl) pd_error(o, "lua: warning: symbol munged (contains \\0 in body)"); + lua_pushvalue(L, 4); + atoms = pdlua_popatomtable(L, &count, o); + if (count == 0 || atoms) outlet_anything(o->out[out], sym, count, atoms); + else pd_error(o, "lua: error: no atoms??"); + if (atoms) + { + free(atoms); + return 0; + } + } + else pd_error(o, "lua: error: null selector"); + } + else pd_error(o, "lua: error: selector must be a string"); + } + else pd_error(o, "lua: error: outlet out of range"); + } + else error("lua: error: no object to outlet from"); + } + else error("lua: error: bad arguments to outlet"); + return 0; +} + +/** Send a message from a Lua object to a Pd receiver. */ +static int pdlua_send(lua_State *L) +/**< Lua interpreter state. + * \par Inputs: + * \li \c 1 Receiver string. + * \li \c 2 Message selector string. + * \li \c 3 Message atom table. + * */ +{ + size_t receivenamel; + const char *receivename; + t_symbol *receivesym; + size_t selnamel; + const char *selname; + t_symbol *selsym; + int count; + t_atom *atoms; + +#ifdef PDLUA_DEBUG + post("pdlua_send:"); +#endif // PDLUA_DEBUG + if (lua_isstring(L, 1)) + { + receivename = lua_tolstring(L, 1, &receivenamel); + receivesym = gensym((char *) receivename); /* const cast */ + if (receivesym) + { + if (strlen(receivename) != receivenamel) error("lua: warning: symbol munged (contains \\0 in body)"); + if (lua_isstring(L, 2)) + { + selname = lua_tolstring(L, 2, &selnamel); + selsym = gensym((char *) selname); /* const cast */ + if (selsym) + { + if (strlen(selname) != selnamel) error("lua: warning: symbol munged (contains \\0 in body)"); + lua_pushvalue(L, 3); + atoms = pdlua_popatomtable(L, &count, NULL); + if ((count == 0 || atoms) && (receivesym->s_thing)) typedmess(receivesym->s_thing, selsym, count, atoms); + else error("lua: error: no atoms??"); + if (atoms) + { + free(atoms); + return 0; + } + } + else error("lua: error: null selector"); + } + else error("lua: error: selector must be a string"); + } + else error("lua: error: null receive name"); + } + else error("lua: error: receive name must be string"); + return 0; +} + +/** Set a [value] object's value. */ +static int pdlua_setvalue(lua_State *L) +/**< Lua interpreter state. + * \par Inputs: + * \li \c 1 Value name string. + * \li \c 2 Value number. + * \par Outputs: + * \li \c 1 success (usually depends on a [value] existing or not). + */ +{ + const char *str = luaL_checkstring(L, 1); + t_float val = luaL_checknumber(L, 2); + int err = value_setfloat(gensym(str), val); + + lua_pushboolean(L, !err); + return 1; +} + +/** Get a [value] object's value. */ +static int pdlua_getvalue(lua_State *L) +/**< Lua interpreter state. + * \par Inputs: + * \li \c 1 Value name string. + * \par Outputs: + * \li \c 1 Value number, or nil for failure. + * */ +{ + const char *str = luaL_checkstring(L, 1); + t_float val; + int err = value_getfloat(gensym(str), &val); + + if (!err) lua_pushnumber(L, val); + else lua_pushnil(L); + return 1; +} + +/** Get a [table] object's array. */ +static int pdlua_getarray(lua_State *L) +/**< Lua interpreter state. + * \par Inputs: + * \li \c 1 Table name string. + * \par Outputs: + * \li \c 1 Table length, or < 0 for failure. + * \li \c 2 Table pointer, or nil for failure. + * */ +{ + t_garray *a; + int n; + PDLUA_ARRAYTYPE *v; + const char *str = luaL_checkstring(L, 1); + + if (!(a = (t_garray *) pd_findbyclass(gensym(str), garray_class))) + { + lua_pushnumber(L, -1); + return 1; + } + else if (!PDLUA_ARRAYGRAB(a, &n, &v)) + { + lua_pushnumber(L, -2); + return 1; + } + else + { + lua_pushnumber(L, n); + lua_pushlightuserdata(L, v); + return 2; + } +} + +/** Read from a [table] object's array. */ +static int pdlua_readarray(lua_State *L) +/**< Lua interpreter state. + * \par Inputs: + * \li \c 1 Table length number. + * \li \c 2 Table array pointer. + * \li \c 3 Table index number. + * \par Outputs: + * \li \c 1 Table element value, or nil for index out of range. + * */ +{ + int n = luaL_checknumber(L, 1); + PDLUA_ARRAYTYPE *v = lua_islightuserdata(L, 2) ? lua_touserdata(L, 2) : NULL; + int i = luaL_checknumber(L, 3); + + if (0 <= i && i < n && v) + { + lua_pushnumber(L, PDLUA_ARRAYELEM(v, i)); + return 1; + } + return 0; +} + +/** Write to a [table] object's array. */ +static int pdlua_writearray(lua_State *L) +/**< Lua interpreter state. + * \par Inputs: + * \li \c 1 Table length number. + * \li \c 2 Table array pointer. + * \li \c 3 Table index number. + * \li \c 4 Table element value number. + * */ +{ + int n = luaL_checknumber(L, 1); + PDLUA_ARRAYTYPE *v = lua_islightuserdata(L, 2) ? lua_touserdata(L, 2) : NULL; + int i = luaL_checknumber(L, 3); + t_float x = luaL_checknumber(L, 4); + + if (0 <= i && i < n && v) PDLUA_ARRAYELEM(v, i) = x; + return 0; +} + +/** Redraw a [table] object's graph. */ +static int pdlua_redrawarray(lua_State *L) +/**< Lua interpreter state. + * \par Inputs: + * \li \c 1 Table name string. + * */ +{ + t_garray *a; + const char *str = luaL_checkstring(L, 1); + + if ((a = (t_garray *) pd_findbyclass(gensym(str), garray_class))) garray_redraw(a); + return 0; +} + +/** Post to Pd's console. */ +static int pdlua_post(lua_State *L) +/**< Lua interpreter state. + * \par Inputs: + * \li \c 1 Message string. + * */ +{ + const char *str = luaL_checkstring(L, 1); + post("%s", str); + return 0; +} + +/** Report an error from a Lua object to Pd's console. */ +static int pdlua_error(lua_State *L) +/**< Lua interpreter state. + * \par Inputs: + * \li \c 1 Pd object pointer. + * \li \c 2 Message string. + * */ +{ + t_pdlua *o; + const char *s; + + if (lua_islightuserdata(L, 1)) + { + o = lua_touserdata(L, 1); + if (o) + { + s = luaL_checkstring(L, 2); + if (s) pd_error(o, "%s", s); + else pd_error(o, "lua: error: null string in error function"); + } + else error("lua: error: null object in error function"); + } + else error("lua: error: bad arguments to error function"); + return 0; +} + +void pdlua_setrequirepath +( /* FIXME: documentation */ + lua_State *L, + const char *path +) +{ + lua_getglobal(L, "pd"); + lua_pushstring(L, "_setrequirepath"); + lua_gettable(L, -2); + lua_pushstring(L, path); + if (lua_pcall(L, 1, 0, 0) != 0) + { + error("lua: internal error in `pd._setrequirepath': %s", lua_tostring(L, -1)); + lua_pop(L, 1); + } + lua_pop(L, 1); +} + +void pdlua_clearrequirepath +( /* FIXME: documentation */ + lua_State *L +) +{ + lua_getglobal(L, "pd"); + lua_pushstring(L, "_clearrequirepath"); + lua_gettable(L, -2); + if (lua_pcall(L, 0, 0, 0) != 0) + { + error("lua: internal error in `pd._clearrequirepath': %s", lua_tostring(L, -1)); + lua_pop(L, 1); + } + lua_pop(L, 1); +} + +/** Run a Lua script using Pd's path. */ +static int pdlua_dofile(lua_State *L) +/**< Lua interpreter state. + * \par Inputs: + * \li \c 1 Pd object pointer. + * \li \c 2 Filename string. + * \par Outputs: + * \li \c * Determined by the script. + * */ +{ + char buf[MAXPDSTRING]; + char *ptr; + t_pdlua_readerdata reader; + int fd; + int n; + const char *filename; + t_pdlua *o; + +#ifdef PDLUA_DEBUG + post("pdlua_dofile:"); +#endif // PDLUA_DEBUG + n = lua_gettop(L); + if (lua_islightuserdata(L, 1)) + { + o = lua_touserdata(L, 1); + if (o) + { + filename = luaL_optstring(L, 2, NULL); + fd = canvas_open(o->canvas, filename, "", buf, &ptr, MAXPDSTRING, 1); + if (fd >= 0) + { + pdlua_setrequirepath(L, buf); + reader.fd = fd; + if (lua_load(L, pdlua_reader, &reader, filename)) + { + close(fd); + pdlua_clearrequirepath(L); + lua_error(L); + } + else + { + if (lua_pcall(L, 0, LUA_MULTRET, 0)) + { + pd_error(o, "lua: error running `%s':\n%s", filename, lua_tostring(L, -1)); + lua_pop(L, 1); + close(fd); + pdlua_clearrequirepath(L); + } + else + { + /* succeeded */ + close(fd); + pdlua_clearrequirepath(L); + } + } + } + else pd_error(o, "lua: error loading `%s': canvas_open() failed", filename); + } + else error("lua: error in object:dofile() - object is null"); + } + else error("lua: error in object:dofile() - object is wrong type"); + return lua_gettop(L) - n; +} + +/** Initialize the pd API for Lua. */ +static void pdlua_init(lua_State *L) +/**< Lua interpreter state. */ +{ + lua_newtable(L); + lua_setglobal(L, "pd"); + lua_getglobal(L, "pd"); + lua_pushstring(L, "_iswindows"); +#ifdef MSW + lua_pushboolean(L, 1); +#else + lua_pushboolean(L, 0); +#endif + lua_settable(L, -3); + lua_pushstring(L, "_register"); + lua_pushcfunction(L, pdlua_class_new); + lua_settable(L, -3); + lua_pushstring(L, "_create"); + lua_pushcfunction(L, pdlua_object_new); + lua_settable(L, -3); + lua_pushstring(L, "_createinlets"); + lua_pushcfunction(L, pdlua_object_createinlets); + lua_settable(L, -3); + lua_pushstring(L, "_createoutlets"); + lua_pushcfunction(L, pdlua_object_createoutlets); + lua_settable(L, -3); + lua_pushstring(L, "_destroy"); + lua_pushcfunction(L, pdlua_object_free); + lua_settable(L, -3); + lua_pushstring(L, "_outlet"); + lua_pushcfunction(L, pdlua_outlet); + lua_settable(L, -3); + lua_pushstring(L, "_createreceive"); + lua_pushcfunction(L, pdlua_receive_new); + lua_settable(L, -3); + lua_pushstring(L, "_receivefree"); + lua_pushcfunction(L, pdlua_receive_free); + lua_settable(L, -3); + lua_pushstring(L, "_createclock"); + lua_pushcfunction(L, pdlua_clock_new); + lua_settable(L, -3); + lua_pushstring(L, "_clockfree"); + lua_pushcfunction(L, pdlua_clock_free); + lua_settable(L, -3); + lua_pushstring(L, "_clockset"); + lua_pushcfunction(L, pdlua_clock_set); + lua_settable(L, -3); + lua_pushstring(L, "_clockunset"); + lua_pushcfunction(L, pdlua_clock_unset); + lua_settable(L, -3); + lua_pushstring(L, "_clockdelay"); + lua_pushcfunction(L, pdlua_clock_delay); + lua_settable(L, -3); + lua_pushstring(L, "_dofile"); + lua_pushcfunction(L, pdlua_dofile); + lua_settable(L, -3); + lua_pushstring(L, "send"); + lua_pushcfunction(L, pdlua_send); + lua_settable(L, -3); + lua_pushstring(L, "getvalue"); + lua_pushcfunction(L, pdlua_getvalue); + lua_settable(L, -3); + lua_pushstring(L, "setvalue"); + lua_pushcfunction(L, pdlua_setvalue); + lua_settable(L, -3); + lua_pushstring(L, "_getarray"); + lua_pushcfunction(L, pdlua_getarray); + lua_settable(L, -3); + lua_pushstring(L, "_readarray"); + lua_pushcfunction(L, pdlua_readarray); + lua_settable(L, -3); + lua_pushstring(L, "_writearray"); + lua_pushcfunction(L, pdlua_writearray); + lua_settable(L, -3); + lua_pushstring(L, "_redrawarray"); + lua_pushcfunction(L, pdlua_redrawarray); + lua_settable(L, -3); + lua_pushstring(L, "post"); + lua_pushcfunction(L, pdlua_post); + lua_settable(L, -3); + lua_pushstring(L, "_error"); + lua_pushcfunction(L, pdlua_error); + lua_settable(L, -3); + lua_pop(L, 1); +} + +/** Pd loader hook for loading and executing Lua scripts. */ +static int pdlua_loader +( + t_canvas *canvas, /**< Pd canvas to use to find the script. */ + char *name /**< The name of the script (without .pd_lua extension). */ +) +{ + char dirbuf[MAXPDSTRING]; + char *ptr; + int fd; + t_pdlua_readerdata reader; + +#ifdef PDLUA_DEBUG + post("pdlua_loader:"); +#endif // PDLUA_DEBUG + fd = canvas_open(canvas, name, ".pd_lua", dirbuf, &ptr, MAXPDSTRING, 1); + if (fd >= 0) + { + class_set_extern_dir(gensym(dirbuf)); + pdlua_setrequirepath(L, dirbuf); + reader.fd = fd; + if (lua_load(L, pdlua_reader, &reader, name) || lua_pcall(L, 0, 0, 0)) + { + error("lua: error loading `%s':\n%s", name, lua_tostring(L, -1)); + lua_pop(L, 1); + close(fd); + pdlua_clearrequirepath(L); + class_set_extern_dir(&s_); + return 0; + } + close(fd); + pdlua_clearrequirepath(L); + class_set_extern_dir(&s_); + return 1; + } + return 0; +} + +/** Start the Lua runtime and register our loader hook. */ +//EXPORT void lua_setup(void) { +void pdlua_setup(void) +{ + char buf[MAXPDSTRING]; + char *ptr; + t_pdlua_readerdata reader; + int fd; + int result; + + post("pdlua 0.6 (GPL) 2011 Martin Peach, based on"); + post("lua 0.6~svn (GPL) 2008 Claude Heiland-Allen "); + post("pdlua: compiled for pd-%d.%d on %s %s", PD_MAJOR_VERSION, PD_MINOR_VERSION, __DATE__, __TIME__); + pdlua_proxyinlet_setup(); +#ifdef PDLUA_DEBUG + post("pdlua pdlua_proxyinlet_setup done"); +#endif // PDLUA_DEBUG + pdlua_proxyreceive_setup(); +#ifdef PDLUA_DEBUG + post("pdlua pdlua_proxyreceive_setup done"); +#endif // PDLUA_DEBUG + pdlua_proxyclock_setup(); +#ifdef PDLUA_DEBUG + post("pdlua pdlua_proxyclock_setup done"); +#endif // PDLUA_DEBUG + L = lua_open(); +#ifdef PDLUA_DEBUG + post("pdlua lua_open done L = %p", L); +#endif // PDLUA_DEBUG + luaL_openlibs(L); +#ifdef PDLUA_DEBUG + post("pdlua luaL_openlibs done"); +#endif // PDLUA_DEBUG + pdlua_init(L); +#ifdef PDLUA_DEBUG + post("pdlua pdlua_init done"); +#endif // PDLUA_DEBUG + /* "pd.lua" is the Lua part of pdlua, want to keep the C part minimal */ + fd = canvas_open(0, "pd", ".lua", buf, &ptr, MAXPDSTRING, 1); +#ifdef PDLUA_DEBUG + post ("pd.lua loaded from %s", buf); + post("pdlua canvas_open done fd = %d", fd); +#endif // PDLUA_DEBUG + if (fd >= 0) + { + reader.fd = fd; + result = lua_load(L, pdlua_reader, &reader, "pd.lua"); +#ifdef PDLUA_DEBUG + post ("pdlua lua_load returned %d", result); +#endif // PDLUA_DEBUG + if (0 == result) + { + result = lua_pcall(L, 0, 0, 0); +#ifdef PDLUA_DEBUG + post ("pdlua lua_pcall returned %d", result); +#endif // PDLUA_DEBUG + } + if (0 != result) + //if (lua_load(L, pdlua_reader, &reader, "pd.lua") || lua_pcall(L, 0, 0, 0)) + { + error("lua: error loading `pd.lua':\n%s", lua_tostring(L, -1)); + error("lua: loader will not be registered!"); + error("lua: (is `pd.lua' in Pd's path list?)"); + lua_pop(L, 1); + close(fd); + } + else + { + close(fd); + sys_register_loader(pdlua_loader); + } + } + else + { + error("lua: error loading `pd.lua': canvas_open() failed"); + error("lua: loader will not be registered!"); + } +} + +/* EOF */ diff --git a/src/pdluax-help.pd b/src/pdluax-help.pd new file mode 100644 index 0000000..9293dcc --- /dev/null +++ b/src/pdluax-help.pd @@ -0,0 +1,12 @@ +#N canvas 0 22 447 171 10; +#X obj 134 144 hello; +#X text 31 122 See also:; +#X obj 33 88 pdluax hello; +#X obj 123 88 pdluax hello; +#X obj 213 88 pdluax hello; +#X obj 303 88 pdluax hello; +#X obj 88 144 pdlua; +#X text 31 16 [pdluax foo] loads the source file "foo.pd_luax" on each +object creation. Less efficient than the loader ([foo] loads "foo.pd_lua" +just once for all time) but more flexible when developing or live-coding. +; -- cgit v1.2.1