mirror of
https://github.com/Ardour/ardour.git
synced 2025-12-22 22:56:32 +01:00
remove empty sigc++2 directory
git-svn-id: svn://localhost/ardour2/branches/3.0@3432 d708f5d6-7413-0410-9779-e7cbd77b26cf
This commit is contained in:
Doug McLain
parent
2f3f697bb8
commit
9c0d7d72d7
2797 changed files with 0 additions and 992363 deletions
|
|
@ -1,229 +0,0 @@
|
|||
dnl-----------------------------------------------------------------------
|
||||
dnl
|
||||
dnl Karls M4 macros for the signal system used by gtk--
|
||||
dnl
|
||||
dnl Copyright (C) 1998-2002 The gtkmm Development Team
|
||||
dnl
|
||||
dnl Currently maintained by Tero Pulkkinen. <terop@modeemi.cs.tut.fi>
|
||||
dnl
|
||||
dnl This library is free software; you can redistribute it and/or
|
||||
dnl modify it under the terms of the GNU Library General Public
|
||||
dnl License as published by the Free Software Foundation; either
|
||||
dnl version 2 of the License, or (at your option) any later version.
|
||||
dnl
|
||||
dnl This library is distributed in the hope that it will be useful,
|
||||
dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
dnl Library General Public License for more details.
|
||||
dnl
|
||||
dnl You should have received a copy of the GNU Library General Public
|
||||
dnl License along with this library; if not, write to the Free
|
||||
dnl Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
dnl
|
||||
dnl-----------------------------------------------------------------------
|
||||
dnl Recursion prevention. (Don't attempt to understand why this works!)
|
||||
changequote(, )dnl
|
||||
changequote([, ])dnl
|
||||
pushdef([DIVERSION],divnum)dnl
|
||||
divert(-1)dnl
|
||||
|
||||
ifdef([__template_macros__],[],[
|
||||
define(__template_macros__)
|
||||
dnl-----------------------------------------------------------------------
|
||||
|
||||
|
||||
dnl
|
||||
dnl M4 macros for general sanity
|
||||
dnl
|
||||
|
||||
dnl M4 Quotas are hard to work with, so use braces like autoconf
|
||||
dnl (which are matched by vi, emacs)
|
||||
changequote(, )
|
||||
changequote([, ])
|
||||
|
||||
dnl
|
||||
dnl M4 comments conflict with compiler directives
|
||||
changecom(, )
|
||||
|
||||
dnl BRACE(text) => [text]
|
||||
dnl When we want something to appear with braces
|
||||
define([BRACE],[[[$*]]])
|
||||
|
||||
dnl
|
||||
dnl PROT(macro)
|
||||
dnl If a macro generates an output with commas we need to protect it
|
||||
dnl from being broken down and interpreted
|
||||
define([PROT],[[$*]])
|
||||
|
||||
dnl
|
||||
dnl LOWER(string)
|
||||
dnl lowercase a string
|
||||
define([LOWER],[translit([$*],[ABCDEFGHIJKLMNOPQRSTUVWXYZ],[abcdefghijklmnopqrstuvwxyz])])
|
||||
|
||||
dnl
|
||||
dnl UPPER(string)
|
||||
dnl uppercase a string
|
||||
define([UPPER],[translit([$*],[abcdefghijklmnopqrstuvwxyz],[ABCDEFGHIJKLMNOPQRSTUVWXYZ])])
|
||||
define([UPPER_SAFE],[translit([$*],[abcdefghijklmnopqrstuvwxyz.-],[ABCDEFGHIJKLMNOPQRSTUVWXYZ__])])
|
||||
|
||||
dnl
|
||||
dnl BASENAME(string)
|
||||
dnl extract the basename of a string
|
||||
define([BASENAME],[patsubst([$*],[^.*/],[])])
|
||||
|
||||
dnl
|
||||
dnl M4NAME(string)
|
||||
dnl extract the basename of a string
|
||||
define([M4NAME],[patsubst(BASENAME([$*]),[\.m4$],[])])
|
||||
|
||||
dnl NUM(arg,arg,...)
|
||||
dnl M4 defines $# very badly (empty list=1). So we need a better one
|
||||
define([NUM],[ifelse(len([$*]),0,0,[$#])])
|
||||
|
||||
dnl
|
||||
dnl IF(cond,string1,string2)
|
||||
dnl places string1 if length (without spaces) of cond is zero,
|
||||
dnl else string2
|
||||
define([IF],[ifelse(len(PROT(translit([$1],[ ]))),0,[$3],[$2])])
|
||||
dnl define([IF],[ifelse(len(PROT(patsubst([$1],[ ]))),0,[$3],[$2])])
|
||||
|
||||
dnl
|
||||
dnl minclude(filename)
|
||||
dnl This includes only the macros from a file but throws away the output.
|
||||
dnl Used to take the macros from a file without getting it extra output.
|
||||
define([minclude],[IF([$1],[dnl
|
||||
pushdef([CURRENT_DIVERSION],divnum)dnl
|
||||
divert(-1)
|
||||
include($1)
|
||||
divert(CURRENT_DIVERSION)dnl
|
||||
popdef([CURRENT_DIVERSION])dnl],[[minclude]])])
|
||||
|
||||
dnl
|
||||
dnl makes the current filename into a string approprate for use as
|
||||
dnl C identified define. (Defaults to this library name)
|
||||
dnl
|
||||
dnl example: (filename test.hh.m4)
|
||||
dnl __header__ => SIGCXX_TEST_H
|
||||
dnl __header__(MYHEAD) => MYHEAD_TEST_H
|
||||
dnl define([__header__],[ifelse($1,,[SIGCXX],UPPER($1))[_]UPPER(patsubst(translit(BASENAME(__file__),[.-],[__]),[_m4],[]))])
|
||||
define([__header__],[ifelse($1,,[_GLIBMM],UPPER($1))[_]UPPER_SAFE(M4NAME(__file__))])
|
||||
|
||||
dnl
|
||||
dnl Set of M4 macros for variable argument template building
|
||||
dnl
|
||||
|
||||
dnl ARGS(name,number)
|
||||
dnl Builds a comma seperated protected list of numbered names
|
||||
dnl Use this as short hand to specify arguement names
|
||||
dnl
|
||||
dnl ARGS(arg,3) => ARG1,ARG2,ARG3
|
||||
define([_ARGS],[ifelse(eval($2<$3),0,[$1$2],[$1$2,_ARGS($1,eval($2+1),$3)])])
|
||||
define([ARGS],[ifelse(eval($2>0),1,[PROT(_ARGS(UPPER([$1]),1,$2))],[PROT])])
|
||||
|
||||
dnl
|
||||
dnl LIST(string1,string2,...)
|
||||
dnl These are intended for making extended argument lists
|
||||
dnl parameters are in pairs, the first is output if the
|
||||
dnl 2nd is nonzero length, the process is then repeated
|
||||
dnl with the next set of arguments.
|
||||
dnl
|
||||
dnl Macro expansions that expand to result in commas must call
|
||||
dnl PROT to prevent permature expansion. ARG* macros do
|
||||
dnl this automatically. (If unsure, add braces until it stops
|
||||
dnl interpreting inter macros, remove one set of braces, if
|
||||
dnl still not right use PROT)
|
||||
dnl
|
||||
dnl (LIST is probably the most useful macro in the set.)
|
||||
define([LIST],[ifelse($#,0,,$#,1,[$1],[$1],,[LIST(shift($@))],[__LIST($@)])])
|
||||
define([__LIST],[ifelse($#,0,,$#,1,[$1],[$1[]ifelse([$2],,,[[,]])__LIST(shift($@))])])
|
||||
|
||||
dnl
|
||||
dnl ARG_LOOP(macro_name,seperator,argument_list)
|
||||
dnl Very powerful macro for construction of list of variables
|
||||
dnl formated in specify ways. To use define a macro taking
|
||||
dnl one variable which is called the format. The second argument
|
||||
dnl is a seperator which will appear between each argument.
|
||||
dnl The rest is then interpreted as arguments to form the list.
|
||||
dnl
|
||||
dnl Example:
|
||||
dnl define([FOO],[foo([$1])])
|
||||
dnl ARG_LOOP([FOO],[[, ]],A,B,C)
|
||||
dnl
|
||||
dnl Gives: foo(A), foo(B), foo(C)
|
||||
dnl
|
||||
define([_ARG_LOOP],[dnl
|
||||
ifelse(NUM($*),0,,NUM($*),1,[dnl
|
||||
indir(LOOP_FORMAT,[$1])],[dnl
|
||||
indir(LOOP_FORMAT,[$1])[]LOOP_SEPERATOR[]_ARG_LOOP(shift($*))])])
|
||||
|
||||
define([ARG_LOOP],[dnl
|
||||
pushdef([LOOP_FORMAT],[[$1]])dnl
|
||||
pushdef([LOOP_SEPERATOR],[$2])dnl
|
||||
_ARG_LOOP(shift(shift($*)))[]dnl
|
||||
popdef([LOOP_FORMAT])dnl
|
||||
popdef([LOOP_SEPERATOR])dnl
|
||||
])
|
||||
|
||||
|
||||
dnl
|
||||
dnl Define some useful formats for use with ARG_LOOP.
|
||||
define([FORMAT_ARG_CLASS],[class [$1]])
|
||||
define([FORMAT_ARG_BOTH],[[$1] LOWER([$1])])
|
||||
define([FORMAT_ARG_REF],[Type<[$1]>::ref LOWER([$1])])
|
||||
define([FORMAT_ARG_TYPE],[[$1]])
|
||||
define([FORMAT_ARG_NAME],[LOWER($1)])
|
||||
define([FORMAT_ARG_CBNAME],[LOWER($1)_])
|
||||
define([FORMAT_ARG_CBDECL],[[$1] LOWER([$1])_;])
|
||||
define([FORMAT_ARG_CBINIT],[LOWER([$1])_(LOWER([$1]))])
|
||||
|
||||
|
||||
dnl
|
||||
dnl The following functions generate various types of parameter lists
|
||||
dnl For parameter lists
|
||||
dnl ARG_CLASS([P1,P2]) -> class P1,class P2
|
||||
dnl ARG_BOTH([P1,P2]) -> P1 p1,P2 p2
|
||||
dnl ARG_TYPE([P1,P2]) -> P1,P2
|
||||
dnl ARG_NAME([P1,P2]) -> p1,p2
|
||||
dnl For callback lists
|
||||
dnl ARG_CBNAME([C1,C2]) -> c1_,c2_
|
||||
dnl ARG_CBINIT([C1,C2]) -> c1_(c1),c2_(c2)
|
||||
dnl ARG_CBDECL([C1,C2]) -> C1 c1_; C2 c2_;
|
||||
dnl
|
||||
define([ARG_CLASS],[PROT(ARG_LOOP([FORMAT_ARG_CLASS],[[,]],$*))])
|
||||
define([ARG_BOTH],[PROT(ARG_LOOP([FORMAT_ARG_BOTH],[[,]],$*))])
|
||||
define([ARG_REF],[PROT(ARG_LOOP([FORMAT_ARG_REF],[[,]],$*))])
|
||||
define([ARG_TYPE],[PROT([$*])])
|
||||
define([ARG_NAME],[PROT(LOWER($*))])
|
||||
define([ARG_CBNAME],[PROT(ARG_LOOP([FORMAT_ARG_CBNAME],[[,]],$*))])
|
||||
define([ARG_CBDECL],[PROT(ARG_LOOP([FORMAT_ARG_CBDECL],[ ],$*))])
|
||||
define([ARG_CBINIT],[PROT(ARG_LOOP([FORMAT_ARG_CBINIT],[[,]],$*))])
|
||||
|
||||
|
||||
dnl
|
||||
dnl T_DROP(string)
|
||||
dnl Removes unnecessary <> with empty templates
|
||||
dnl (occasionally useful)
|
||||
define([T_DROP],[ifelse([$1],<>,,[$*])])
|
||||
|
||||
dnl
|
||||
dnl DROP(string,drop)
|
||||
dnl Removes unnecessary strings if they match drop
|
||||
dnl (occasionally useful)
|
||||
define([DROP],[ifelse([$1],[$2],,[$*])])
|
||||
|
||||
dnl
|
||||
dnl LINE(linenum)
|
||||
dnl places a #line statement if __debug__ set
|
||||
dnl Use this at top of macro template and following
|
||||
dnl macros that contain newlines.
|
||||
dnl
|
||||
dnl example:
|
||||
dnl LINE(]__line__[)dnl
|
||||
define([LINE],[ifdef([__debug__],[#line $1 "]__file__["
|
||||
])])
|
||||
|
||||
dnl-----------------------------------------------------------------------
|
||||
dnl End of recursion protection. Do not put anything below this line.
|
||||
])
|
||||
divert(DIVERSION)dnl
|
||||
popdef([DIVERSION])dnl
|
||||
Loading…
Add table
Add a link
Reference in a new issue