1. MELT Programming Reference

This documentation is generated on July 27, 2015 by MELT 1.2.0 [melt-branch_revision_226151].

1.1 MELT macros

There are 82 documented macros.

1.1.1 *

Macro defined at file ‘warmelt-macro.melt’, line 6642.

macro description: The product * operator is variadic, and understood as successive applications of *i primitives.

1.1.2 +

Macro defined at file ‘warmelt-macro.melt’, line 6584.

macro description: The addition + operator is variadic, and understood as successive applications of +i primitives.

1.1.3 -

Macro defined at file ‘warmelt-macro.melt’, line 6613.

macro description: The substraction - operator is variadic, and understood as successive applications of -i primitives.

1.1.4 /

Macro defined at file ‘warmelt-macro.melt’, line 6671.

macro description: The division / operator is variadic, and understood as successive applications of /i primitives.

1.1.5 AGAIN

Macro defined at file ‘warmelt-macro.melt’, line 8379.

macro description: The AGAIN syntax is for restarting a local FOREVER loop in the same function. Syntax is (AGAIN <loop-label>).

1.1.6 ASSERT_MSG

Macro defined at file ‘warmelt-macro.melt’, line 8554.

macro description: ASSERT_MSG macro with a message cstring and an optional condition. Generates an assertion -if MELT_HAVE_DEBUG enabled- and also issues a compile warning if condition is missing so false.

1.1.7 AT_MACRO_EXPANSION

Macro defined at file ‘warmelt-macro.melt’, line 4014.

macro description: The AT_MACRO_EXPANSION macro will evaluate its body, e.g. containing defun or definstance at macro-expansion time. In particular, functions used inside a DEFMACRO should be defined inside AT_MACRO_EXPANSION and are not available in ordinary code.

1.1.8 BACKQUOTE

Macro defined at file ‘warmelt-moremacro.melt’, line 426.

macro description: The BACKQUOTE macro is expanding into an s-expr, except for COMMA It is often noted with a prefix backquote-character `....

1.1.9 BOX

Macro defined at file ‘warmelt-macro.melt’, line 7845.

macro description: The BOX syntax is boxing stuff into mutable values. So (box 2) gives the same as (make_integerbox discr_integer 2) and if g is some gimple stuff, (box g) gives the same as (make_gimple discr_gimple g) etc... If the argument is some value, it makes some reference, instance of CLASS_REFERENCE, from that value.

1.1.10 CHEADER

Macro defined at file ‘warmelt-macro.melt’, line 8006.

macro description: The CHEADER syntax inserts C code in the header part of the generated code.

1.1.11 CIMPLEMENT

Macro defined at file ‘warmelt-macro.melt’, line 8054.

macro description: The CIMPLEMENT syntax inserts C code in the implementation part of the generated code.

1.1.12 CODE_CHUNK

Macro defined at file ‘warmelt-macro.melt’, line 5457.

macro description: The CODE_CHUNK macro is for low-level C code chunks. The syntax is (CODE_CHUNK state-symbol chunk...) where chunk-s may be macro-strings or nested s-expressions. It generates a C block. Nested expressions should be :void and are expanded at place of occurence, as blocks. Since it does not make any type verification, it should be used with parcimony. See DEFPRIMITIVE and EXPR_CHUNK etc.

1.1.13 COMMA

Macro defined at file ‘warmelt-moremacro.melt’, line 444.

macro description: The COMMA macro is related to BACKQUTE. COMMA It is often noted with a prefix comma-character ,....

1.1.14 COMMENT

Macro defined at file ‘warmelt-macro.melt’, line 7956.

macro description: The COMMENT syntax inserts comment in the generated code, or skips MELT code. Syntax is (COMMENT <string>) to insert a comment in the generated C code, or (COMMENT ...) to skip some syntax.

1.1.15 COMPILE_ERROR

Macro defined at file ‘warmelt-macro.melt’, line 8458.

macro description: The COMPILE_ERROR syntax issues an error, inspired by GCC #error. Syntax is (COMPILE_ERROR <string> [<expression>]). May be useful in macros or with GCCIF.

1.1.16 COMPILE_WARNING

Macro defined at file ‘warmelt-macro.melt’, line 8419.

macro description: The COMPILE_WARNING syntax issues a warning, inspired by GCC #warning. Syntax is (COMPILE_WARNING <string> [<expression>]).

1.1.17 COND

Macro defined at file ‘warmelt-macro.melt’, line 6139.

macro description: The usual lisp COND conditional. Syntax is (COND <conditions>...). Each condition is a list of the form (<test> <expr>...). The last catch-all condition can be (:else <epxr>...).

1.1.18 CONSTANT_BOX

Macro defined at file ‘warmelt-macro.melt’, line 7877.

macro description: The CONSTANT_BOX syntax is boxing stuff into constant values. So (constant_box 2) gives the same as (make_integerbox discr_constant_integer 2) and if g is some gimple stuff, (box g) gives the same as (make_gimple discr_constant_gimple g) etc...

1.1.19 CONTENT

Macro defined at file ‘warmelt-macro.melt’, line 6494.

macro description: The CONTENT macro is obsolete. Use DEREF instead.

1.1.20 CPPIF

Macro defined at file ‘warmelt-macro.melt’, line 6041.

macro description: The CPPIF macro expands to C-code with an #if condition, so the condition is handled when compiling the generated C code into a MELT module. Syntax is (CPPIF <symbol> <then> [<else>]).

1.1.21 CURRENT_MODULE_ENVIRONMENT_CONTAINER

Macro defined at file ‘warmelt-macro.melt’, line 9017.

macro description: (CURRENT_MODULE_ENVIRONMENT_CONTAINER) is obsolete. Use CURRENT_MODULE_ENVIRONMENT_REFERENCE.

1.1.22 CURRENT_MODULE_ENVIRONMENT_REFERENCE

Macro defined at file ‘warmelt-macro.melt’, line 9008.

macro description: (CURRENT_MODULE_ENVIRONMENT_REFERENCE) returns a container, i.e. a reference thru CLASS_REFERENCE, for the current environment. See also PARENT_MODULE_ENVIRONMENT and CLASS_ENVIRONMENT. (CURRENT_MODULE_ENVIRONMENT_REFERENCE) cannot be used inside hooks. Was previously called inccorrectly CURRENT_MODULE_ENVIRONMENT_CONTAINER.

1.1.23 DEBUG

Macro defined at file ‘warmelt-macro.melt’, line 8740.

macro description: DEBUG is a variadic and polytypic macro for debugging prints. You can give it arbitrary arguments -either stuff or values-. Debugging prints should be enabled at compilation time of the generated C code with the quicklybuilt or debugnoline module flavors, and at run time with the -f[plugin-arg-]melt-debugging= option. Internally (DEBUG arg...) is macro expanded to something similar to (cppif MELT_HAVE_DEBUG (if (melt_need_dbg 0) (melt_debug_fun () count filename lineno ...)))

1.1.24 DEFCITERATOR

Macro defined at file ‘warmelt-macro.melt’, line 3338.

macro description: The DEFCITERATOR macro defines a module-global c-iterator which itself implements iterative for-like loops. Syntax is (DEFCITERATOR name start-formals state-symbol variable-formals [:doc documentation] before-expansion after-expansion). To be visible outside the module, the c-iterator should be exported using EXPORT_VALUES. See also CLASS_CITERATOR.

1.1.25 DEFCLASS

Macro defined at file ‘warmelt-macro.melt’, line 4623.

macro description: The DEFCLASS macro defines a module-global class. Syntax is (DEFCLASS symbol [:doc documentation] :super super-class :fields fields-list). Conventionally, the class name (i.e. the symbol) should preferably start with CLASS_. The fields’ names should preferably be globally unique, and usually share a common prefix. See also CLASS_ROOT CLASS_CLASS CLASS_FIELD etc.

1.1.26 DEFCMATCHER

Macro defined at file ‘warmelt-macro.melt’, line 3538.

macro description: The DEFCMATCHER macro defines a module-global pattern-matching operator by their C expansion. Syntax is (DEFCMATCHER symbol match&ins-formals out-formals state-symbol [:doc documentation] test-expansion fill-expansion [operator-expansion]).

1.1.27 DEFHOOK

Macro defined at file ‘warmelt-macro.melt’, line 4221.

macro description: The DEFHOOK macro defines a module-global hook, that is arbitrary C/C++ routines coded in MELT.. Syntax is (DEFHOOK hook-name input-formals output-formals ctype [:var hook-var] [:predef hook-predef] [:doc documentation] body...). This binds hook-name to a generated hook value of DISCR_HOOK discriminant, containing a pointer to the generated C/C++ routine and closed values, like functions and instances mentionned inside the body, etc... This generates an extern "C" C/C++ routine named melthook_hook-name, return a result of given ctype, and with formal arguments: the hook value itself, the input formals, the pointers to output formals (which can be modified in the body with SETQ). If hook-var is given with a :var annotation, it should be a module variable defined with DEFVAR, and that module variable is assigned to the hook value. Then, a C/C++ routine named melthookproc_hook-name is emitted, taking only the input and output formals, and passing that module variable as the hook. And similarily for predefined hooks with their hook-predef.

1.1.28 DEFINE

Macro defined at file ‘warmelt-macro.melt’, line 4363.

macro description: The DEFINE macro defines a module-global named non-recursive value. Syntax (like in Scheme) is (DEFINE name [:doc documentation] expr ...) to define a value, and (DEFINE (funame formals...) [:doc documentation] expr ...) to define a function like DEFUN does. Use EXPORT_VALUES to make that name visible outside its module.

1.1.29 DEFINE_GCC_BINARY_TREE

Macro defined at file ‘libmelt-ana-tree.melt’, line 2988.

macro description: The macro DEFINE_GCC_BINARY_TREE takes one or many treecode names and expands to exported cmatchers.

1.1.30 DEFINSTANCE

Macro defined at file ‘warmelt-macro.melt’, line 4838.

macro description: The DEFINSTANCE syntax defines a module-global static instance bound by a symbol. Syntax is (DEFINSTANCE <symbol> <class> [:doc documentation] {:<field> <value>}*). The symbol is bound to the newly made instance.

1.1.31 DEFMACRO

Macro defined at file ‘warmelt-macro.melt’, line 3960.

macro description: The DEFMACRO macro defines a module-global macro. Syntax is (DEFMACRO funame formals [:doc documentation] body...). At most four formals are permitted of ctype :value, for the s-expression invoking the macro, the environment at macro-expansion time, the current macro-expander closure and at last the module context.

1.1.32 DEFPRIMITIVE

Macro defined at file ‘warmelt-macro.melt’, line 3184.

macro description: The DEFPRIMITIVE macro defines a module-global new primitive operation by their C expansion. Syntax is (DEFPRIMITIVE name formals type [:doc documentation] expansion) which defines a primitive of given name with formal arguments formals, result c-type type, optional documentation, and given expansion. A macro is expanded into a C instruction if its c-type is :void, otherwise into a C expression. Primitives have to be exported with EXPORT_VALUES to be visible in other modules. See also the classes CLASS_PRIMITIVE, and CLASS_PRIMITIVE_BINDING and the CODE_CHUNK macro.

1.1.33 DEFSELECTOR

Macro defined at file ‘warmelt-macro.melt’, line 4985.

macro description: The DEFSELECTOR syntax defines a module-global selector for sending messages. Syntax is (DEFSELECTOR <symbol> <selector-class> [:doc <documentation>] [:formals ( <formals>...)]).

1.1.34 DEFUN

Macro defined at file ‘warmelt-macro.melt’, line 3760.

macro description: The DEFUN macro defines a module-global function. Syntax is (DEFUN funame formals [:doc documentation] body...). The first formal argument, if any, is required to be of ctype :value. The expressions in the body are evaluated in sequence. The value of the last is returned. See also RETURN and LAMBDA macros. A function defined by DEFUN has to be exported with EXPORT_VALUES to be visible outside its module.

1.1.35 DEFUNMATCHER

Macro defined at file ‘warmelt-macro.melt’, line 3685.

macro description: The DEFUNMATCHER syntax defines a module-global matcher thru a MELT function. Syntax is (DEFUNMATCHER <symbol> <in-formals> <out-formals> [:doc docum] <match-function> [<apply-function> [<data>]])

1.1.36 DEFVAR

Macro defined at file ‘warmelt-macro.melt’, line 4070.

macro description: The DEFVAR macro defines a module-global variable, initialized to the nil value. Syntax is (DEFVAR varame [:doc documentation]).

1.1.37 DEREF

Macro defined at file ‘warmelt-macro.melt’, line 6480.

macro description: The DEREF macro is a short-hand to retrieve values inside instances of CLASS_REFERENCE. So (DEREF <value>) means (GET_FIELD :REFERENCED_VALUE <value>), hence test that <value> is indeed an instance of CLASS_REFERENCE, or else gives null. The special syntax !<expr> is a syntactic sugar for (DEREF <expr>).

1.1.38 DIAGNOSTIC_ARGS_MACRO

Macro defined at file ‘warmelt-macro.melt’, line 98.

macro description: Macro DIAGNOSTIC_ARGS_MACRO to be invoked with two variables nbargs and vect to parse variadic arguments in diagnostic functions like ERROR or WARNING or INFORM.

1.1.39 EACH_COMPONENT_IN_LIST

Macro defined at file ‘warmelt-moremacro.melt’, line 44.

macro description: Macro EACH_COMPONENT_IN_LIST to be invoked with a list-giving expr and a local variable compvar expands into (foreach_pair_component_in_list (expr) (curpairvar compvar) body...) where curpairvar is fresh.

1.1.40 EXCLAIM

Macro defined at file ‘warmelt-macro.melt’, line 6500.

macro description: EXCLAIM [usually given thru the ! syntactic sugar] is a synonym for DEREF, e.g. !(IF p c) means (DEREF (IF P C)) hence (GET_FIELD :REFERENCED_VALUE (IF P C))

1.1.41 EXIT

Macro defined at file ‘warmelt-macro.melt’, line 8339.

macro description: The EXIT syntax is for exiting a local FOREVER loop in the same function. Syntax is (EXIT <loop-name> <expression>...).

1.1.42 EXPORT_CLASS

Macro defined at file ‘warmelt-macro.melt’, line 8931.

macro description: (EXPORT_CLASS names...) is used to export class and their field names.

1.1.43 EXPORT_MACRO

Macro defined at file ‘warmelt-macro.melt’, line 8849.

macro description: (EXPORT_MACRO name macro-expander [:doc documentation]) is used to define an exported macro.

1.1.44 EXPORT_PATMACRO

Macro defined at file ‘warmelt-macro.melt’, line 8901.

macro description: (EXPORT_PATMACRO name pattern-expander [macro-expander] [:doc documentation]) is used to define patmacros.

1.1.45 EXPORT_SYNONYM

Macro defined at file ‘warmelt-macro.melt’, line 8980.

macro description: (EXPORT_SYNONYM new-name old-name [:doc documentation]) is used to define a synonym.

1.1.46 EXPORT_VALUES

Macro defined at file ‘warmelt-macro.melt’, line 8778.

macro description: EXPORT_VALUES is a macro to export values defined by names. Give it a sequence of names bound to values using DEFINE, DEFUN, DEFINSTANCE, DEFSELECTOR, DEFCITERATOR, DEFCMATCHER, DEFFUNMATCHER etc. Use EXPORT_CLASS for exporting classes and their fields.

1.1.47 EXPR_CHUNK

Macro defined at file ‘warmelt-macro.melt’, line 5524.

macro description: The EXPR_CHUNK macro is for low-level C expression chunks, e.g. anonymous primitive-like expressions. The syntax is (EXPR_CHUNK state-symbol ctype chunk...) where chunk-s may be macro-strings or sub-expressions. It generates a C expressions, with all the sub-expressions strictly normalized before the expansion of the expr_chunk. Since it does not make any type verification, it should be usually avoided. See DEFPRIMITIVE and EXPR_CHUNK etc.

1.1.48 FETCH_PREDEFINED

Macro defined at file ‘warmelt-macro.melt’, line 9113.

macro description: (FETCH_PREDEFINED predefined-name) is accessing a predefined value without using environments. You probably don’t need that.

1.1.49 FOREVER

Macro defined at file ‘warmelt-macro.melt’, line 8298.

macro description: The FOREVER syntax is for infinite loops exited thru EXIT. Syntax is (FOREVER <loop-name> <expr>...). Use EXIT to go out of the loop with a result.

1.1.50 GCCIF

Macro defined at file ‘warmelt-moremacro.melt’, line 215.

macro description: The GCCIF macro expands the rest of the expression if the version string of the GCC translating this MELT expression matches the condition. Syntax is (GCCIF condition expr...), where the condition is a constant string such as "4.8" for gcc-4.8 or a list of such strings.

1.1.51 GET_FIELD

Macro defined at file ‘warmelt-macro.melt’, line 5706.

macro description: The GET_FIELD syntax safely access a field. Syntax is (GET_FIELD :<field> <expression>) which evaluates to nil if the expression is not of the class defining the field. See also UNSAFE_GET_FIELD.

1.1.52 IF

Macro defined at file ‘warmelt-macro.melt’, line 5808.

macro description: The IF syntax is for simple conditional expressions. See also WHEN and UNLESS and COND. Syntax is (IF <test-expression> <then-expression> [<else-expression>]).

1.1.53 LAMBDA

Macro defined at file ‘warmelt-macro.melt’, line 7622.

macro description: The LAMBDA syntax is for anonymous functions e.g. closures, with closed values (however closing things like :gimple or :long is not permitted, you have to box them explicitly as :value-s.). Syntax is (LAMBDA ( <formals> ... ) <body>...). The formal argument list should have its first formal be a :value. Other arguments can be c-typed with keywords like :value :gimple :long etc. which applies to all succeeding arguments up to the next ctype keyword. The body is a non-empty sequence of expressions. LAMBDA functions can RETURN a value with possible secondary results. See also MULTICALL. LAMBDA expressions are constructive so can appear in LETREC bindings.

1.1.54 LET

Macro defined at file ‘warmelt-macro.melt’, line 7287.

macro description: The LET syntax is for sequential local bindings of expressions. Syntax is (LET ( <binding> ... ) <body> ...). Each binding is an optional ctype such as :long or :gimple or :value or :auto (which is the default), followed by a local variable name, followed by a single expression. With an :auto type annotation, the bound variable takes the type provided by the binding expression. The body is a non-empty sequence of expressions, evaluated in an environment enriched with the local bindings. The MELT LET syntax is sequential, like LET* in Scheme so a variable bound in a previous binding can appear in the expression of a later binding. If the first element of the <binding> list is exactly :expand like in (LET (:expand <expanded-binding>...) <body> ...). the <expanded-binding> is macro-expanded, but then :macro bindings are not allowed.

1.1.55 LETREC

Macro defined at file ‘warmelt-macro.melt’, line 7575.

macro description: The LETREC syntax is for mutually recursive local bindings. Syntax is (LETREC ( <binding>... ) <body>...). Each binding is an optional ctype such as :long or :gimple or :value (which is the default), followed by a local variable name, followed by a single constructive expression, like LAMBDA INSTANCE TUPLE LIST. The body is a non-empty sequence of sub-expressions evaluated in an augmented environment. Note that MELT LETREC is similar to Scheme’s LETREC.

1.1.56 LOAD

Macro defined at file ‘warmelt-macro.melt’, line 5098.

macro description: The LOAD macro is for reading expressions from another file. Syntax is (LOAD <file-name>). See also SKIP_NIL.

1.1.57 MATCH

Macro defined at file ‘warmelt-macro.melt’, line 6854.

macro description: The MATCH syntax is for pattern-matching expressions. Syntax is (MATCH <matched-expression> <match-case>...). Each match-case starts with a pattern followed by expressions. The catch-all pattern ?_ should appear in the last match-case if any. Pattern variables like ?x are bound by the matching in their match-case.

1.1.58 MATCHALT

Macro defined at file ‘warmelt-macro.melt’, line 6948.

macro description: The temporary MATCHALT syntax is for pattern-matching expressions. It is sama as MATCH but uses an alternative implementation. Don’t use it (except for test cases), it will disappear when that better implemenation will be fully debugged.

1.1.59 MODULE_IS_GPL_COMPATIBLE

Macro defined at file ‘warmelt-macro.melt’, line 8105.

macro description: The MODULE_IS_GPL_COMPATIBLE syntax reminds that MELT modules should be GPL compatible. Argument is a comment-like string or symbol. This has a role analogue to the plugin_is_GPL_compatible symbol in GCC plugins.

1.1.60 MULTICALL

Macro defined at file ‘warmelt-macro.melt’, line 7810.

macro description: The MULTICALL syntax is for accumulating the primary and secondary results of a function application or a message sending. Syntax is (MULTICALL ( <formals> ) <application-or-message-send> <body>...). The first formal is bound to the primary result and should be a :value. Other are for secondary results. The body is evaluated with these results of the given application or sending expression bound by the formals. Inspired by Scheme’s CALL-WITH-VALUES or CommonLisp’s MULTIPLE-VALUE-BIND.

1.1.61 PARENT_MODULE_ENVIRONMENT

Macro defined at file ‘warmelt-macro.melt’, line 9042.

macro description: (PARENT_MODULE_ENVIRONMENT) gives the parent environnment of this module. See also CLASS_ENVIRONMENT and CURRENT_MODULE_ENVIRONMENT_REFERENCE. (PARENT_MODULE_ENVIRONMENT) cannot be used inside hooks.

1.1.62 PROGN

Macro defined at file ‘warmelt-macro.melt’, line 8238.

macro description: The PROGN syntax evaluate a sequence of expressions ignoring all but the last which is the result. Syntax is (PROGN <expression>...).

1.1.63 PUT_FIELDS

Macro defined at file ‘warmelt-macro.melt’, line 5624.

macro description: The PUT_FIELDS syntax is for safely setting fields in an object. Syntax is (PUT_FIELDS <instance-expression> {:<field> <field-expression>}*). If the instance is not an object of the class containing all the fields, no harm is done. See also UNSAFE_PUT_FIELDS which does not produces checks.

1.1.64 QUOTE

Macro defined at file ‘warmelt-moremacro.melt’, line 379.

macro description: The QUOTE syntax (usually noted with a prefix quote-character ') is for quotations. A quoted literal reifies a value, so '2 is a value of DISCR_CONSTANT_INTEGER. A quoted s-expression invokes MELT_MAKE_SEXPR using HOOK_MELT_MAKE_LOCATION.

1.1.65 REGISTER_GCC_ATTRIBUTE

Macro defined at file ‘warmelt-hooks.melt’, line 2392.

macro description: The variadic macro REGISTER_GCC_ATTRIBUTE is registering a GCC attribute ATTR of CLASS_GCC_ATTRIBUTE by expanding to a call to MELT_REGISTER_GCC_ATTRIBUTE_AT internal function. Memory used by the attribute is never freed. After it can occur variadically equivalents of struct attribute_spec fields: :MIN_LENGTH minimal-length (default 0). :MAX_LENGTH maximal-length (default -1). :DECL_REQUIRED decl-required-flag. :TYPE_REQUIRED type-required-flag. :FUNCTION_TYPE_REQUIRED function-type-required-flag :AFFECTS_TYPE_IDENTITY affects-type-identity-flag. Notice that checking of variadic arguments happen at run-time.

1.1.66 RETURN

Macro defined at file ‘warmelt-macro.melt’, line 8259.

macro description: The RETURN syntax is for returning a primary and possibly secondary results. Syntax is (RETURN <expression>...). If no expression is given, returns nil. Hooks cannot return secondary results.

1.1.67 SETQ

Macro defined at file ‘warmelt-macro.melt’, line 5755.

macro description: The SETQ syntax is for assignment of local variables, usually bound by a LET in the same function. Syntax is (SETQ <symbol> <expr>).

1.1.68 SET_REF

Macro defined at file ‘warmelt-macro.melt’, line 6554.

macro description: The SET_REF macro is a short-hand to put a value inside instances of CLASS_REFERENCE. So (SET_REF <ref> <value>) means (PUT_FIELDS <ref> :REFERENCED_VALUE <value>), hence test that <ref> is indeed an instance of CLASS_REFERENCE before updating it.

1.1.69 SKIP_NIL

Macro defined at file ‘warmelt-macro.melt’, line 5130.

macro description: The SKIP_NIL macro is macro-expanding its arguments, and skipping those which are macro-expanded to nil. It might be useful with LOAD to avoid useless expressions from the loaded file.

1.1.70 STORE_PREDEFINED

Macro defined at file ‘warmelt-macro.melt’, line 9149.

macro description: (STORE_PREDEFINED predefined-name value) is storing a predefined value. You probably never need that.

1.1.71 THIS_FILE

Macro defined at file ‘warmelt-macro.melt’, line 8603.

macro description: THIS_FILE, inspired by the __FILE__ macro of C or C++, is a macro expanding to the string naming the source file of its occurrence, or NIL if no source location is available.

1.1.72 THIS_LINE

Macro defined at file ‘warmelt-macro.melt’, line 8580.

macro description: THIS_LINE, inspired by the __LINE__ macro of C or C++, is a macro expanding to the line number in the source file of its occurrence, or NIL if no line.

1.1.73 UNBOX

Macro defined at file ‘warmelt-macro.melt’, line 7925.

macro description: The UNBOX syntax is unboxing some value into some raw stuff. It is given a ctype and an expression: (UNBOX ctype expr).

1.1.74 UNLESS

Macro defined at file ‘warmelt-macro.melt’, line 5881.

macro description: The UNLESS syntax sugar is for negated conditional expressions with body. Syntax is (UNLESS <test> <body>...) = syntactic sugar for (IF <test> () (PROGN <body>...)).

1.1.75 UNSAFE_GET_FIELD

Macro defined at file ‘warmelt-macro.melt’, line 5665.

macro description: The UNSAFE_GET_FIELD syntax retrieves dangerously a field from an instance and may crash when the instance is not an object of the appropriate class. Syntax is (UNSAFE_GET_FIELD :<field> <expression>). Using GET_FIELD is preferrable.

1.1.76 UNSAFE_PUT_FIELDS

Macro defined at file ‘warmelt-macro.melt’, line 5577.

macro description: The UNSAFE_PUT_FIELDS is for expert use only, since it can crash the running GCC MELT compilation. Syntax is (UNSAFE_PUT_FIELDS <instance> {:<field> <expression>}). It sets fields in an instance without any checks. Using PUT_FIELDS is prefered.

1.1.77 UPDATE_CURRENT_MODULE_ENVIRONMENT_REFERENCE

Macro defined at file ‘warmelt-macro.melt’, line 9074.

macro description: (UPDATE_CURRENT_MODULE_ENVIRONMENT_REFERENCE) is a guru macro to update the current module environment reference. You probably should never use it, but it is necessary inside MELT. See CURRENT_MODULE_ENVIRONMENT_REFERENCE. Was previously called incorrectly UPDATE_CURRENT_MODULE_ENVIRONMENT_CONTAINER.

1.1.78 USE-PACKAGE-FROM-PKG-CONFIG

Macro defined at file ‘warmelt-macro.melt’, line 8194.

macro description: The USE-PACKAGE-FROM-PKG-CONFIG or USE_PACKAGE_FROM_PKG_CONFIG syntax enables usage of pkg-config-ured packages. Arguments are strings naming packages. This modifies the compilation and linking of generated C code. Probably using some CHEADER for some #include is useful.

1.1.79 USE_PACKAGE_FROM_PKG_CONFIG

Macro defined at file ‘warmelt-macro.melt’, line 8188.

macro description: The USE_PACKAGE_FROM_PKG_CONFIG or USE-PACKAGE-FROM-PKG-CONFIG syntax enables usage of pkg-config-ured packages. Arguments are strings naming packages. This modifies the compilation and linking of generated C code. Probably using some CHEADER for some #include is useful.

1.1.80 VARIADIC

Macro defined at file ‘warmelt-macro.melt’, line 7745.

macro description: The VARIADIC syntax is for getting variable arguments inside variadic functions -using :REST-. Syntax is (VARIADIC variadic-case ...) where each variadic-case is ( (formal ...) body ...) and the last variadic-case can also be (:ELSE body ...). When the actual variable arguments’s signature match the given formals in a variadic-case, they are bound, and the body of that case is evaluated. If no formals match in type and number and if the last variadic-case starts with :ELSE it is exacuted. As an expression, (VARIADIC ...) gives no result, so is :void. In a variadic-case, if no <formals are given, the body is executed when no more actual variable arguments remain.

1.1.81 WHEN

Macro defined at file ‘warmelt-macro.melt’, line 5844.

macro description: The WHEN syntax sugar is for conditional expressions with body. Syntax is (WHEN <test> <body>...) syntactic sugar for (IF <test> (PROGN <body>...)).

1.1.82 WITH_CLONED_SYMB

Macro defined at file ‘warmelt-macro.melt’, line 5981.

macro description: The WITH_CLONED_SYMB syntax sugar is for easily cloning symbols, notably useful in macros. Syntax is (WITH_CLONED_SYMB (<symb>...) <body>...) same as (LET ( (<symb> (CLONE_SYMBOL (QUOTE <symb>))) ...) <body>...) etc...

1.2 MELT pattern macros

There are 12 documented pattern-macros.

1.2.1 AND

Pattern macro defined at file ‘warmelt-macro.melt’, line 6285.

pattern macro description: The lispy AND conjunction syntax is a short-circuit "and then" conjunction. Expression syntax is (AND <conjunct-subexpression>...) and can evaluate to a :value or a thing such as a :long or a :gimple which is null/zero iff any conjunct is null or zero. Pattern syntax is ?(AND <conjunct-subpattern>...) and matches if all conjunct-subpattern-s match. See also COND OR and IF.

1.2.2 CONTAINER

Pattern macro defined at file ‘warmelt-moremacro.melt’, line 240.

pattern macro description: The CONTAINER syntax for expressions or patterns is obsolete. Use REFERENCE instead

1.2.3 GIMPLE_CALL_ARGS

Pattern macro defined at file ‘libmelt-ana-gimple.melt’, line 2120.

pattern macro description: The GIMPLE_CALL_ARGS is for patterns or expressions for GIMPLE_CALL. Usage is ?(GIMPLE_CALL_ARGS <lhs> <fndecl> <args>...).

1.2.4 GIMPLE_CALL_MORE_ARGS

Pattern macro defined at file ‘libmelt-ana-gimple.melt’, line 2424.

pattern macro description: The GIMPLE_CALL_MORE_ARGS is for patterns but not expressions for GIMPLE_CALL, with at least the given arguments and possibly some more. Usage is ?(GIMPLE_CALL_MORE_ARGS <lhs> <fndecl> <args>...).

1.2.5 INSTANCE

Pattern macro defined at file ‘warmelt-macro.melt’, line 5261.

pattern macro description: The INSTANCE pattern macro matches an instance when used as a pattern, or creates an instance when used as an expression. Pattern syntax is ?(INSTANCE class-name :field1 pattern1 :field2 pattern2...) - there can be zero, one or more distinct fields. A value matches such a pattern if the value is an instance of class-name or a sub-class and if each specified field matches its [sub-]pattern. Expression syntax is (INSTANCE class-name :field1 value1 :field2 value2...). All the fields should be acceptable for the specified class-name. In expressions, missing fields are initialized to nil. In patterns missing fields are not matched. The given class-name is a fixed class (not a variable) possessing all the specified fields.

1.2.6 LIST

Pattern macro defined at file ‘warmelt-macro.melt’, line 6759.

pattern macro description: The LIST syntax is for making or matching lists made of pairs. Expression syntax is (LIST <component-subexpression>...) to make a list of DISCR_LIST with the given components going into the head of pairs of DISCR_PAIR. Pattern syntax is ?(LIST <component-subpattern>...) to match a list of given length with each component matching its corresponding <component-subpattern>. LIST expressions are constructive, so can appear in LETREC bindings.

1.2.7 OBJECT

Pattern macro defined at file ‘warmelt-macro.melt’, line 5366.

pattern macro description: The OBJECT pattern macro matches an instance when used as a pattern. Pattern syntax is ?(OBJECT class-name :field1 pattern1 :field2 pattern2...) - there can be zero, one or more distinct fields. A value matches such a pattern if the value is an instance of exactly class-name (not a sub-class) and if each specified field matches its [sub-]pattern. The OBJECT pattern macro should not be used in expression context. See also INSTANCE and DEFCLASS.

1.2.8 OR

Pattern macro defined at file ‘warmelt-macro.melt’, line 6345.

pattern macro description: The lispy OR disjunctive syntax is a short-circuit "or else" disjonction. Expression syntax is (OR <disjunct-subexpression>...) and can evaluate to a :value or a thing such as a :gimple or a :long etc. which is null/zero iff every disjunct is null/zero. Pattern-syntax is ?(OR <disjunct-subpattern>...) and matches if one of the disjunct-subpattern matches. See also COND AND and IF.

1.2.9 REFERENCE

Pattern macro defined at file ‘warmelt-macro.melt’, line 6428.

pattern macro description: The REFERENCE syntax is a short-hand for making or matching instances of CLASS_REFERENCE. Expression syntax (REFERENCE <subexpression>) is a short-hand for (INSTANCE CLASS_REFERENCE :REFERENCED_VALUE <subexpression>) to make an instance of CLASS_REFERENCE with the given value as REFERENCED_VALUE. Pattern syntax is ?(REFERENCE <subpattern>) to match an instance of CLASS_REFERENCE with its REFERENCED_VALUE matching <subpattern>. REFERENCE expressions are constructive, so can appear in LETREC bindings.

1.2.10 TREE_CALL_EXPR

Pattern macro defined at file ‘libmelt-ana-tree.melt’, line 2697.

pattern macro description: The TREE_CALL_EXPR is for patterns or expressions for treecode CALL_EXPR. Usage is (TREE_CALL_EXPR <called-fun> <chaining> <call-arguments> ...), where everything is a tree

1.2.11 TREE_CALL_MORE_EXPR

Pattern macro defined at file ‘libmelt-ana-tree.melt’, line 2893.

pattern macro description: The TREE_CALL_MORE_EXPR is for patterns or expressions for treecode CALL_EXPR with more arguments than given. Usage is (TREE_CALL_MORE_EXPR <called-fun> <chaining> <call-arguments> ...), where everything is a tree. So ?(tree_call_more_expr ?tfun ?tchain ?ta0 ?ta1) will match call trees with two or more arguments. See also FOREACH_ARGUMENT_IN_CALL_EXPR_TREE, ARITY_TREE_CALL_EXPR and NTH_ARG_TREE_CALL_EXPR

1.2.12 TUPLE

Pattern macro defined at file ‘warmelt-macro.melt’, line 6713.

pattern macro description: The TUPLE syntax is for making or matching tuples. Expression syntax is (TUPLE <component-subexpression>...) to make a tuple of DISCR_MULTIPLE with the given components. Pattern syntax is ?(TUPLE <component-subpattern>...) to match a tuple of given length with each component matching its corresponding <component-subpattern>. TUPLE expressions are constructive, so can appear in LETREC bindings.

1.3 MELT classes

Table of classes sorted by inheritance depth.

0:

CLASS_ROOT

1:

CLASS_ANY_BINDING, CLASS_C_GENERATION_CONTEXT, CLASS_DEBUG_INFORMATION, CLASS_ENVIRONMENT, CLASS_GENERATED_C_CODE, CLASS_MATCHING_CONTEXT, CLASS_MATCH_NORMALIZATION_CONTEXT, CLASS_NORMAL_OR_VARIABLE, CLASS_NREP, CLASS_PATTERN_CONTEXT, CLASS_PATTERN_EXPANSION_CONTEXT, CLASS_PROPED, CLASS_REFERENCE

2:

CLASS_ALARM_HANDLER, CLASS_ANALYSIS_STATE, CLASS_ANY_MODULE_CONTEXT, CLASS_CHILD_PROCESS_HANDLER, CLASS_DEBUG_OUTPUT_INFORMATION, CLASS_DESCRIBED_ENVIRONMENT, CLASS_EXPORTED_BINDING, CLASS_FIXED_BINDING, CLASS_FORMAL_BINDING, CLASS_INITIAL_GENERATION_CONTEXT, CLASS_INPUT_CHANNEL_HANDLER, CLASS_JSON_PARSER, CLASS_LABEL_BINDING, CLASS_LET_BINDING, CLASS_LITERAL_VALUE, CLASS_LOCATED, CLASS_MATCHED_BINDING, CLASS_MATCHED_DATA, CLASS_MATCH_CASE, CLASS_MATCH_GRAPHIC, CLASS_NAMED, CLASS_NORMALIZATION_CONTEXT, CLASS_NORMAL_CONSTRUCTOR_BINDING, CLASS_NORMAL_MAGIC_BINDING, CLASS_NREP_ANYPROC, CLASS_NREP_EXPRESSION, CLASS_NREP_QUASIDATA, CLASS_NREP_SIMPLE

3:

CLASS_ANY_MATCHER, CLASS_CITERATOR, CLASS_CITERATOR_BINDING, CLASS_CLASS_BINDING, CLASS_CMATCHER_BINDING, CLASS_DEFINED_VALUE_BINDING, CLASS_DELAYED_QUEUE, CLASS_DIAGNOSTIC_STATE, CLASS_DISCRIMINANT, CLASS_EXTENSION_GENERATION_CONTEXT, CLASS_FIELD, CLASS_FIELD_BINDING, CLASS_FUNCTION_BINDING, CLASS_FUNMATCHER_BINDING, CLASS_GCC_ATTRIBUTE, CLASS_GCC_PASS, CLASS_GCC_PRAGMA, CLASS_HOOK_BINDING, CLASS_HOOK_DESCRIPTOR, CLASS_INSTANCE_BINDING, CLASS_LETREC_BINDING, CLASS_MACRO_BINDING, CLASS_MAKEDOC_MODULE_CONTEXT, CLASS_MATCHED_NORMAL_DATA, CLASS_MATCH_FLAG, CLASS_MATCH_STEP, CLASS_MELT_MODE, CLASS_NORMAL_CONSTRUCTED_INSTANCE_BINDING, CLASS_NORMAL_CONSTRUCTED_LAMBDA_BINDING, CLASS_NORMAL_CONSTRUCTED_LIST_BINDING, CLASS_NORMAL_CONSTRUCTED_PAIR_BINDING, CLASS_NORMAL_CONSTRUCTED_TUPLE_BINDING, CLASS_NORMAL_LET_BINDING, CLASS_NREP_BOUND_DATA, CLASS_NREP_CHECKSIGNAL, CLASS_NREP_CLOSPROC, CLASS_NREP_COMMENT, CLASS_NREP_CONSUME_VARIADIC, CLASS_NREP_CPPIF, CLASS_NREP_INITPROC, CLASS_NREP_JUMP_WHEN_IS_A, CLASS_NREP_LET, CLASS_NREP_MATCHED_DATA, CLASS_NREP_MATCH_DATA_ACTION, CLASS_NREP_MATCH_FLAG, CLASS_NREP_MATCH_JUMP, CLASS_NREP_MATCH_LABEL, CLASS_NREP_NIL, CLASS_NREP_PREDEF, CLASS_NREP_PROGN, CLASS_NREP_RETURN, CLASS_NREP_TYPED_EXPRESSION, CLASS_PARAGRAPH_INPUT_CHANNEL_HANDLER, CLASS_PRIMITIVE, CLASS_PRIMITIVE_BINDING, CLASS_QUASI_CTYPE, CLASS_RAW_INPUT_CHANNEL_HANDLER, CLASS_RUNNING_EXTENSION_MODULE_CONTEXT, CLASS_SELECTOR, CLASS_SELECTOR_BINDING, CLASS_SEXPR, CLASS_SOURCE, CLASS_SYMBOL, CLASS_SYSTEM_DATA, CLASS_VALUE_BINDING, CLASS_VALUE_DESCRIPTOR, CLASS_VARIABLE_BINDING

4:

CLASS_CLASS, CLASS_CLONED_SYMBOL, CLASS_CMATCHER, CLASS_CTYPE, CLASS_DEFINED_MACRO_BINDING, CLASS_FIRST_MODULE_CONTEXT, CLASS_FUNMATCHER, CLASS_GCC_ANY_IPA_PASS, CLASS_GCC_EXPANDED_PRAGMA, CLASS_GCC_GIMPLE_PASS, CLASS_GCC_PLAIN_PRAGMA, CLASS_GCC_RTL_PASS, CLASS_KEYWORD, CLASS_MATCH_STEP_THEN, CLASS_NORMAL_MODULE_VARIABLE_BINDING, CLASS_NREP_CHUNK, CLASS_NREP_DISCRIMINATED_DATA, CLASS_NREP_HOOKPROC, CLASS_NREP_IFCOMMON, CLASS_NREP_INITEXTENDPROC, CLASS_NREP_LETREC, CLASS_NREP_MATCHALT, CLASS_NREP_MATCH_DATA_CLEAR, CLASS_NREP_MATCH_DATA_FINALIZER, CLASS_NREP_MATCH_DATA_INITIALIZER, CLASS_NREP_MATCH_LABEL_END, CLASS_NREP_ROUTPROC, CLASS_NREP_TYPED_EXPRESSION_WITH_ARGUMENTS, CLASS_PATMACRO_BINDING, CLASS_SEXPR_MACROSTRING, CLASS_SOURCE_ANY_LET_BINDING, CLASS_SOURCE_ARGUMENTED_OPERATOR, CLASS_SOURCE_CODE_STRING, CLASS_SOURCE_COMMENT, CLASS_SOURCE_COMPILE_DIAGNOSTIC, CLASS_SOURCE_CPPIF, CLASS_SOURCE_DEFINITION, CLASS_SOURCE_EXPORTCOMMON, CLASS_SOURCE_EXPORT_ANY_MACRO, CLASS_SOURCE_EXPORT_SYNONYM, CLASS_SOURCE_FIELDASSIGN, CLASS_SOURCE_FIELD_PATTERN, CLASS_SOURCE_GENERATOR_DEVICE, CLASS_SOURCE_GET_FIELD, CLASS_SOURCE_IF, CLASS_SOURCE_IFVARIADIC, CLASS_SOURCE_INSTANCE, CLASS_SOURCE_LABELLED, CLASS_SOURCE_LAMBDA, CLASS_SOURCE_LAZY_MACRO_EXPANSION, CLASS_SOURCE_LET, CLASS_SOURCE_MACRO_INSTALLATION, CLASS_SOURCE_MATCH, CLASS_SOURCE_MATCH_CASE, CLASS_SOURCE_MULTICALL, CLASS_SOURCE_OR, CLASS_SOURCE_PATTERN, CLASS_SOURCE_PROGN, CLASS_SOURCE_PUT_FIELDS, CLASS_SOURCE_QUASI_BOX, CLASS_SOURCE_QUOTE, CLASS_SOURCE_SETQ, CLASS_SOURCE_UNBOX, CLASS_SOURCE_USE_PACKAGE_FROM_PKG_CONFIG, CLASS_VARISIZED_VALUE_DESCRIPTOR

5:

CLASS_CTYPE_GTY, CLASS_CTYPE_PLAIN, CLASS_GCC_SIMPLE_IPA_PASS, CLASS_GCC_TRANSFORM_IPA_PASS, CLASS_MATCH_STEP_CLEAR, CLASS_MATCH_STEP_WITH_DATA, CLASS_MATCH_STEP_WITH_FLAG, CLASS_NREP_APPLY, CLASS_NREP_DEFUNROUTPROC, CLASS_NREP_HOOK_CALL, CLASS_NREP_IF, CLASS_NREP_IFSAME, CLASS_NREP_IFTESTVALUE, CLASS_NREP_IFVARIADIC, CLASS_NREP_LAMBDAROUTPROC, CLASS_NREP_MACROLAMBDAROUTPROC, CLASS_NREP_MSEND, CLASS_SOURCE_AGAIN, CLASS_SOURCE_APPLY, CLASS_SOURCE_ARITHMETIC_VARIADIC_OPERATION, CLASS_SOURCE_BOX, CLASS_SOURCE_CHEADER, CLASS_SOURCE_CIMPLEMENT, CLASS_SOURCE_CITERATION, CLASS_SOURCE_CMATCHEXPR, CLASS_SOURCE_COMPILE_WARNING, CLASS_SOURCE_CONSTANT_BOX, CLASS_SOURCE_DEFINE, CLASS_SOURCE_DEFINITION_FORMAL, CLASS_SOURCE_DEFOBJCOMMON, CLASS_SOURCE_DEFVAR, CLASS_SOURCE_EXIT, CLASS_SOURCE_EXPORT_CLASS, CLASS_SOURCE_EXPORT_DEFMACRO, CLASS_SOURCE_EXPORT_MACRO, CLASS_SOURCE_EXPORT_VALUES, CLASS_SOURCE_FOREVER, CLASS_SOURCE_FUNMATCHEXPR, CLASS_SOURCE_HOOK_CALL, CLASS_SOURCE_IFELSE, CLASS_SOURCE_LAMBDA_FOR_MACRO, CLASS_SOURCE_LETREC, CLASS_SOURCE_LET_BINDING, CLASS_SOURCE_LIST, CLASS_SOURCE_MACRO_LET_BINDING, CLASS_SOURCE_MATCHALT, CLASS_SOURCE_MODULE_IS_GPL_COMPATIBLE, CLASS_SOURCE_MSEND, CLASS_SOURCE_PATTERN_AND, CLASS_SOURCE_PATTERN_CONSTANT, CLASS_SOURCE_PATTERN_CONSTRUCT, CLASS_SOURCE_PATTERN_OBJECT, CLASS_SOURCE_PATTERN_OR, CLASS_SOURCE_PATTERN_VARIABLE, CLASS_SOURCE_PATTERN_WHEN, CLASS_SOURCE_PRIMITIVE, CLASS_SOURCE_RETURN, CLASS_SOURCE_TUPLE, CLASS_SOURCE_UNSAFE_GET_FIELD, CLASS_SOURCE_UNSAFE_PUT_FIELDS

6:

CLASS_MATCH_STEP_FLAG_OPERATION, CLASS_MATCH_STEP_FLAG_SET, CLASS_MATCH_STEP_SUCCESS_WHEN_FLAG, CLASS_MATCH_STEP_TEST, CLASS_NREP_IFISA, CLASS_NREP_IFTUPLESIZED, CLASS_NREP_MULTIAPPLY, CLASS_NREP_MULTIMSEND, CLASS_SOURCE_DEFCITERATOR, CLASS_SOURCE_DEFCLASS, CLASS_SOURCE_DEFCMATCHER, CLASS_SOURCE_DEFHOOK, CLASS_SOURCE_DEFINSTANCE, CLASS_SOURCE_DEFPRIMITIVE, CLASS_SOURCE_DEFUN, CLASS_SOURCE_DEFUNMATCHER, CLASS_SOURCE_EXPORT_PATMACRO, CLASS_SOURCE_LETREC_BINDING, CLASS_SOURCE_LET_BINDING_FOR_MACRO, CLASS_SOURCE_PATTERN_COMPOSITE, CLASS_SOURCE_PATTERN_INSTANCE, CLASS_SOURCE_PATTERN_JOKER_VARIABLE, CLASS_SOURCE_PATTERN_LIST, CLASS_SOURCE_PATTERN_TUPLE

7:

CLASS_MATCH_STEP_FLAG_CONJUNCTION, CLASS_MATCH_STEP_FLAG_DISJUNCTION, CLASS_MATCH_STEP_TEST_CONSTANT, CLASS_MATCH_STEP_TEST_GROUP, CLASS_MATCH_STEP_TEST_INSTANCE, CLASS_MATCH_STEP_TEST_MATCHER, CLASS_MATCH_STEP_TEST_MULTIPLE, CLASS_MATCH_STEP_TEST_VARIABLE, CLASS_SOURCE_DEFMACRO, CLASS_SOURCE_DEFSELECTOR, CLASS_SOURCE_PATTERN_MATCHER

8:

CLASS_SOURCE_DEFMACRO_IN_LET, CLASS_SOURCE_PATTERN_C_MATCH, CLASS_SOURCE_PATTERN_FUN_MATCH

1.3.1 CLASS_ALARM_HANDLER

Class defined at file ‘warmelt-first.melt’, line 835.

2 ancestors: CLASS_ROOT CLASS_PROPED.

4 fields:

class description: Internal class for alarm handling. ALARMH_PERIOD is the boxed period in milliseconds, ALARMH_CLOS is the closure to be called, ALARMH_DATA is the client data. See REGISTER_ALARM_TIMER and

1.3.2 CLASS_ANALYSIS_STATE

Class defined at file ‘libmelt-ana-base.melt’, line 37.

2 ancestors: CLASS_ROOT CLASS_PROPED.

1 fields:

class description: A class containing some analysis state, to be subclassed.

1.3.3 CLASS_ANY_BINDING

Class defined at file ‘warmelt-first.melt’, line 466.

1 ancestors: CLASS_ROOT.

1 fields:

32 sub-classes: CLASS_CITERATOR_BINDING, CLASS_CLASS_BINDING, CLASS_CMATCHER_BINDING, CLASS_DEFINED_MACRO_BINDING, CLASS_DEFINED_VALUE_BINDING, CLASS_EXPORTED_BINDING, CLASS_FIELD_BINDING, CLASS_FIXED_BINDING, CLASS_FORMAL_BINDING, CLASS_FUNCTION_BINDING, CLASS_FUNMATCHER_BINDING, CLASS_HOOK_BINDING, CLASS_INSTANCE_BINDING, CLASS_LABEL_BINDING, CLASS_LETREC_BINDING, CLASS_LET_BINDING, CLASS_MACRO_BINDING, CLASS_MATCHED_BINDING, CLASS_NORMAL_CONSTRUCTED_INSTANCE_BINDING, CLASS_NORMAL_CONSTRUCTED_LAMBDA_BINDING, CLASS_NORMAL_CONSTRUCTED_LIST_BINDING, CLASS_NORMAL_CONSTRUCTED_PAIR_BINDING, CLASS_NORMAL_CONSTRUCTED_TUPLE_BINDING, CLASS_NORMAL_CONSTRUCTOR_BINDING, CLASS_NORMAL_LET_BINDING, CLASS_NORMAL_MAGIC_BINDING, CLASS_NORMAL_MODULE_VARIABLE_BINDING, CLASS_PATMACRO_BINDING, CLASS_PRIMITIVE_BINDING, CLASS_SELECTOR_BINDING, CLASS_VALUE_BINDING, CLASS_VARIABLE_BINDING.

class description: The CLASS_ANY_BINDING is the super-class of every binding. The BINDER field is the bound name. Bindings are added by module initializers. Don’t create bindings by instanciating this class in user code, they are created within the Melt translator.

1.3.4 CLASS_ANY_MATCHER

Class defined at file ‘warmelt-first.melt’, line 171.

3 ancestors: CLASS_ROOT CLASS_PROPED CLASS_NAMED.

5 fields:

2 sub-classes: CLASS_CMATCHER, CLASS_FUNMATCHER.

class description: The CLASS_ANY_MATCHER is the common super-class for matcher descriptors. The AMATCH_IN gives the formal input arguments, the AMATCH_MATCHBIND is the formal binding of the matched stuff, and AMATCH_OUT is the formal output arguments. Instances of sub-classes of CLASS_ANY_MATCHER are automagically created by macros like DEFCMATCHER and DEFUNMATCHER.

1.3.5 CLASS_ANY_MODULE_CONTEXT

Class defined at file ‘warmelt-first.melt’, line 876.

2 ancestors: CLASS_ROOT CLASS_PROPED.

22 fields:

3 sub-classes: CLASS_FIRST_MODULE_CONTEXT, CLASS_MAKEDOC_MODULE_CONTEXT, CLASS_RUNNING_EXTENSION_MODULE_CONTEXT.

class description: The internal CLASS_ANY_MODULE_CONTEXT describes the whole module or extension context of a translation. MOCX_MODULENAME gives the module name, MOCX_EXPFIELDICT gives the dictionnary of exported fields, MOCX_EXPCLASSDICT gives the dictionnary of exported classes, and MOCX_INITIALENV the initial environment. MOCX_MACROENV is the environment for macros. MOCX_FUNCOUNT is a boxed integer counting the defined functions (excluding LAMBDA-s, counting only DEFUN), used to help generate C code in several files, described in MOCX_FILETUPLE. MOCX_CFLAGS is for the C compilation flags of the module. MOCX_LINKFLAGS is for the linking flags. MOCX_CHEADERLIST is the list of cheaders. MOCX_CIMPLEMENTLIST is the list of cimplements. MOCX_STARTCOMMENT is the initial comment. MOCX_GENDEVLIST is the list of instances of CLASS_SOURCE_GENERATOR_DEVICE. MOCX_ERRORHANDLER is the closure, if any, to call on errors. MOCX_VARCOUNT is the counter for variables. MOCX_VARLIST contains the list of variable descriptions. MOCX_MACROLIST is the list of not-yet-compiled macros. MOCX_ISGPLCOMPATIBLE is a string or null - see MODULE_IS_GPL_COMPATIBLE macro. For gurus!

1.3.6 CLASS_CHILD_PROCESS_HANDLER

Class defined at file ‘warmelt-first.melt’, line 847.

2 ancestors: CLASS_ROOT CLASS_PROPED.

4 fields:

class description: Internal class for child process handling. CHILPROH_PID is the boxed pid, CHILPROH_CLOS is the boxed closure, CHILPROH_DATA is the client data.

1.3.7 CLASS_CITERATOR

Class defined at file ‘warmelt-first.melt’, line 154.

3 ancestors: CLASS_ROOT CLASS_PROPED CLASS_NAMED.

7 fields:

class description: The CLASS_CITERATOR is the class describing c-iterators. The formal start arguments are in the CITER_START_FORMALS field, the CITER_STATE field gives the state symbol, the CITER_BODY_FORMALS gives the formal body arguments, and the before and after expansions are CITER_EXPBEFORE and CITER_EXPAFTER. Instances of CLASS_CITERATOR are automagically created by the DEFCITERATOR macro.

1.3.8 CLASS_CITERATOR_BINDING

Class defined at file ‘warmelt-first.melt’, line 547.

3 ancestors: CLASS_ROOT CLASS_ANY_BINDING CLASS_FIXED_BINDING.

4 fields:

class description: The internal CLASS_CITERATOR_BINDING is for c-iterator bindings. See the DEFCITERATOR macro. The CBIND_CITERDEF gives the definition, and the CBIND_CITERATOR provides the c-iterator itself.

1.3.9 CLASS_CLASS

Class defined at file ‘warmelt-first.melt’, line 118.

4 ancestors: CLASS_ROOT CLASS_PROPED CLASS_NAMED CLASS_DISCRIMINANT.

8 fields:

class description: The CLASS_CLASS is the class of all classes - which are therefore discriminants. The CLASS_ANCESTORS field holds the sequence of ancestors. The CLASS_FIELDS gives the sequence of inherited and own fields. The CLASS_DATA is for class variables. Instances of CLASS_CLASS are automagically created by the DEFCLASS macro.

1.3.10 CLASS_CLASS_BINDING

Class defined at file ‘warmelt-first.melt’, line 616.

3 ancestors: CLASS_ROOT CLASS_ANY_BINDING CLASS_FIXED_BINDING.

4 fields:

class description: The internal CLASS_CLASS_BINDING is for class bindings. See the DEFCLASS macro. The definition is provided by CBIND_DEFCLASS, and the class itself is given by CBIND_CLASS. A class definition also define fields.

1.3.11 CLASS_CLONED_SYMBOL

Class defined at file ‘warmelt-first.melt’, line 277.

4 ancestors: CLASS_ROOT CLASS_PROPED CLASS_NAMED CLASS_SYMBOL.

4 fields:

class description: The CLASS_CLONED_SYMBOL is the sub-class of cloned symbols, e.g. like GENSYM-ed symbols is many Lisps. Cloned symbols are internally generated inside the MELT translator by the CLONE_SYMBOL function. Their CSYM_URANK field gives their unique rank as a boxed integer. Cloned symbols are not interned.

1.3.12 CLASS_CMATCHER

Class defined at file ‘warmelt-first.melt’, line 185.

4 ancestors: CLASS_ROOT CLASS_PROPED CLASS_NAMED CLASS_ANY_MATCHER.

9 fields:

class description: The CLASS_CMATCHER is the class for c-matcher descriptors. CMATCH_STATE is the state symbol, CMATCH_EXPTEST gives the expansion for testing in patterns, CMATCH_EXPFILL is the expansion for filling a matched pattern. CMATCH_EXPOPER is the expansion for operator uses. Instances of CLASS_CMATCHER are automagically created by the DEFCMATCHER macro.

1.3.13 CLASS_CMATCHER_BINDING

Class defined at file ‘warmelt-first.melt’, line 646.

3 ancestors: CLASS_ROOT CLASS_ANY_BINDING CLASS_FIXED_BINDING.

3 fields:

class description: The internal CLASS_CMATCHER_BINDING is for c-matcher bindings. See the DEFCMATCHER macro. The c-matcher is in CMBIND_MATCHER.

1.3.14 CLASS_CTYPE

Class defined at file ‘warmelt-first.melt’, line 330.

4 ancestors: CLASS_ROOT CLASS_PROPED CLASS_NAMED CLASS_QUASI_CTYPE.

13 fields:

2 sub-classes: CLASS_CTYPE_GTY, CLASS_CTYPE_PLAIN.

class description: The CLASS_CTYPE is for predefined descriptors of C types (like long or tree). CTYPE_KEYWORD gives the associated keywords (for formal argument lists, etc...), CTYPE_CNAME gives the C identifier of the type. Parameter passing is described by CTYPE_PARCHAR (for the character) and CTYPE_PARSTRING (for the corresponding C string). Argument member in union is given by CTYPE_ARGFIELD, and by CTYPE_RESFIELD for results. The marking routine is CTYPE_MARKER and CTYPE_DESCR is some descriptive string or data. A possible alternate keyword is given by CTYPE_ALTKEYWORD. The CTYPE_AUTOBOXDISCR gives the discriminant for autoboxing or nil, and the CTYPE_AUTOCONSTBOXDISCR gives the discriminant for const autoboxinf oe nil. Adding new c-types requires an update of MELT runtime!

1.3.15 CLASS_CTYPE_GTY

Class defined at file ‘warmelt-first.melt’, line 374.

5 ancestors: CLASS_ROOT CLASS_PROPED CLASS_NAMED CLASS_QUASI_CTYPE CLASS_CTYPE.

35 fields:

class description: The CLASS_CTYPE_GTY is a subclass of CLASS_CTYPE and describes C types which are GTY-ed, that is handled by the Ggc [the existing Gcc Garbage Collector].

1.3.16 CLASS_CTYPE_PLAIN

Class defined at file ‘warmelt-first.melt’, line 360.

5 ancestors: CLASS_ROOT CLASS_PROPED CLASS_NAMED CLASS_QUASI_CTYPE CLASS_CTYPE.

15 fields:

class description: The CLASS_CTYPE_PLAIN is for predefined descriptors of plain c-types which are not GTY-ed so need a boxing and unboxing chunk. The CTYPP_BOXING is the name of a C function or macro getting the discriminant and the stuff and boxing them. The CTYPP_UNBOXING is the name of a C function or macro unboxing its value.

1.3.17 CLASS_C_GENERATION_CONTEXT

Class defined at file ‘warmelt-first.melt’, line 978.

1 ancestors: CLASS_ROOT.

10 fields:

2 sub-classes: CLASS_EXTENSION_GENERATION_CONTEXT, CLASS_INITIAL_GENERATION_CONTEXT.

class description: The internal CLASS_C_GENERATION_CONTEXT (for gurus) is the class of contexts for C code generation, while generating a single C routine. The containing object routine is GNCX_OBJROUT. The object map from normal bindings to local is given in GNCX_LOCMAP. The list of freed local value pointers is in GNCX_FREEPTRLIST. The list of free longs is in GNCX_FREELONGLIST. For other c-types, each c-type has its list, associated to it in GNCX_FREEOTHERMAPS. The return location is in GNCX_RETLOC. The cached map of procedures to compiled routines is in GNCX_COMPICACHE. The module compilation context is in GNCX_MODULCONTEXT. A map keyed by normal matchers to give a unique label prefix is in GNCX_MATCHMAP.

1.3.18 CLASS_DEBUG_INFORMATION

Class defined at file ‘warmelt-debug.melt’, line 42.

1 ancestors: CLASS_ROOT.

3 fields:

1 sub-classes: CLASS_DEBUG_OUTPUT_INFORMATION.

class description: The CLASS_DEBUG_INFORMATION is for debug information output, e.g. DEBUG_MSG macro. The produced output or buffer is DBGI_OUT, the occurrence map is DBGI_OCCMAP, used to avoid outputting twice the same object. The boxed maximal depth is DBGI_MAXDEPTH.

1.3.19 CLASS_DEBUG_OUTPUT_INFORMATION

Class defined at file ‘warmelt-debug.melt’, line 53.

2 ancestors: CLASS_ROOT CLASS_DEBUG_INFORMATION.

3 fields:

class description: The CLASS_DEBUG_OUTPUT_INFORMATION is for debug output, which happens even when debug printing is not enabled by a program argument like -f[plugin-arg-]melt-debugging.

1.3.20 CLASS_DEFINED_MACRO_BINDING

Class defined at file ‘warmelt-macro.melt’, line 825.

4 ancestors: CLASS_ROOT CLASS_ANY_BINDING CLASS_EXPORTED_BINDING CLASS_MACRO_BINDING.

4 fields:

class description: The internal CLASS_DEFINED_MACRO_BINDING is for macros defined with DEFMACRO.

1.3.21 CLASS_DEFINED_VALUE_BINDING

Class defined at file ‘warmelt-first.melt’, line 607.

3 ancestors: CLASS_ROOT CLASS_ANY_BINDING CLASS_FIXED_BINDING.

3 fields:

class description: The internal CLASS_DEFINED_VALUE_BINDING is for defined values thru the DEFINE macro. DEFVALBIND_DEFINE provides the definition. FIXBIND_DATA gives a symbol occurrence in that case.

1.3.22 CLASS_DELAYED_QUEUE

Class defined at file ‘warmelt-first.melt’, line 3244.

3 ancestors: CLASS_ROOT CLASS_PROPED CLASS_NAMED.

5 fields:

class description: A class for named queues of delayed tasks. DELQU_FIRST is the list of actions to do first, DELQU_LAST those to do last.

1.3.23 CLASS_DESCRIBED_ENVIRONMENT

Class defined at file ‘warmelt-first.melt’, line 458.

2 ancestors: CLASS_ROOT CLASS_ENVIRONMENT.

4 fields:

class description: The CLASS_DESCRIBED_ENVIRONMENT provides an extra descriptor DENV_DESCR which can for example be a descriptive string.

1.3.24 CLASS_DIAGNOSTIC_STATE

Class defined at file ‘warmelt-macro.melt’, line 78.

3 ancestors: CLASS_ROOT CLASS_PROPED CLASS_LOCATED.

5 fields:

class description: The CLASS_DIAGNOSTIC_STATE manage diagnostic handling by ERROR and WARNING ....

1.3.25 CLASS_DISCRIMINANT

Class defined at file ‘warmelt-first.melt’, line 105.

3 ancestors: CLASS_ROOT CLASS_PROPED CLASS_NAMED.

5 fields:

1 sub-classes: CLASS_CLASS.

class description: The CLASS_DISCRIMINANT is the class of every discriminant. It has the method dictionnary DISC_METHODICT and the super-discriminant DISC_SUPER. The DISC_SENDER can hold a closure doing the send if the selector is not found. Otherwise, the default is to send thru the super-discriminant.

1.3.26 CLASS_ENVIRONMENT

Class defined at file ‘warmelt-first.melt’, line 444.

1 ancestors: CLASS_ROOT.

3 fields:

1 sub-classes: CLASS_DESCRIBED_ENVIRONMENT.

class description: The CLASS_ENVIRONMENT reifies environments. The binding map is ENV_BIND, the previous environment is ENV_PREV, and the procedure if any of this environment is ENV_PROC. It is heavily used within the MELT translator. Module initialization produces fresh instances of it. See the CURRENT_MODULE_ENVIRONMENT_REFERENCE and PARENT_MODULE_ENVIRONMENT macros.

1.3.27 CLASS_EXPORTED_BINDING

Class defined at file ‘warmelt-first.melt’, line 475.

2 ancestors: CLASS_ROOT CLASS_ANY_BINDING.

1 fields:

4 sub-classes: CLASS_DEFINED_MACRO_BINDING, CLASS_MACRO_BINDING, CLASS_PATMACRO_BINDING, CLASS_VALUE_BINDING.

class description: The CLASS_EXPORTED_BINDING is the super-class of exported bindings.

1.3.28 CLASS_EXTENSION_GENERATION_CONTEXT

Class defined at file ‘warmelt-first.melt’, line 1026.

3 ancestors: CLASS_ROOT CLASS_C_GENERATION_CONTEXT CLASS_INITIAL_GENERATION_CONTEXT.

16 fields:

class description: The internal CLASS_EXTENSION_GENERATION_CONTEXT (for gurus) is used when generating the initial routine of an extension, i.e. for runtime evaluation of expressions. EGNCX_VALOCLIST is the list of literal values stack locations, and EGNCX_LITVALTUPLOC is the stack location for the literal values tuple.

1.3.29 CLASS_FIELD

Class defined at file ‘warmelt-first.melt’, line 131.

3 ancestors: CLASS_ROOT CLASS_PROPED CLASS_NAMED.

4 fields:

class description: The CLASS_FIELD is the class of every field. Its objnum is its offset. Its FLD_OWNCLASS is the class owning that field. The FLD_DATA is for additional data. Instances of CLASS_FIELD are automagically created by the DEFCLASS macro.

1.3.30 CLASS_FIELD_BINDING

Class defined at file ‘warmelt-first.melt’, line 627.

3 ancestors: CLASS_ROOT CLASS_ANY_BINDING CLASS_FIXED_BINDING.

4 fields:

class description: The internal CLASS_FIELD_BINDING is for field bindings. See the DEFCLASS macro. The class binding is FLBIND_CLABIND, and the defined field is FLBIND_FIELD.

1.3.31 CLASS_FIRST_MODULE_CONTEXT

Class defined at file ‘warmelt-outobj.melt’, line 7206.

4 ancestors: CLASS_ROOT CLASS_PROPED CLASS_ANY_MODULE_CONTEXT CLASS_MODULE_CONTEXT.

22 fields:

class description: CLASS_FIRST_MODULE_CONTEXT is for compiling the bootstrapped first module warmelt-first. For Gurus.