Loading...
Searching...
No Matches
alc native

COMPILE A native-library into a managed-object.

Introduction

Basically, the alc-compiler is a tool for the programmer who is faced with the question of extracting information from a definition file, e.g. a c-header-file, in order to start various actions from it.

The example below shows a workflow using the native library libconfig which is used as a reference implementation.

‍Libconfig is a simple library for processing structured configuration files. This file format is more compact and more readable than XML. And unlike XML, it is type-aware, so it is not necessary to do string parsing in application code.

The libconfig can be found at: http://hyperrealm.github.io/libconfig/

libconfig is a native-library which means that the library itself, as downloaded from the internet, does not contain any managed-object information and is therefore completely independent of the alc-compiler project.


'cls_MqC' - Create a "class" from the class definition database

First it needs a framework for the managed-object library.

The basic framework consists of the class-definitions and the library-definition. The class-definitions are generated from a database containing the definitions of all classes and ultimately sort to ensure that the class-hierarchy is enforced.

A class is a managed-object and is defined by one or more struct in C. The class definition is replaced by cls_MqC added to the header file.

The class definition database ClassDB is very simple :

    # ====================================================================================
    # Define "LcConfig" classes

    define class MkObjectS LcConfigS {
      desc      "LcConfigC class handle"
      Short     Cfg
      header    LcConfigC
    }

    define class MkObjectS LcSettingS {
      desc      "LcSettingC class handle"
      Short     Cfs
      header    LcSettingC
    }
Note
This tool does not add class-attributes or class-methods, this tool only add the code to proper use a class as managed-object.

There will be one file per class ( LcConfigC_lc.h and LcSettingC_lc.h ) and one file as library-definition ( LibLcConfig_lc.h ).

 call: 'c_Class.tcl' '-lc' '-d'


pInit                                    -> PINIT[#0] -> +++ use              : lang<c>         : api<Class>           : top<c_Class.tcl>
                                         -> PINIT[#0] -> argv<-lc -d>
                                         -> PINIT[>0] -> INIT(lang)<c> : INIT(Api)<Class> : INIT(argv)<-i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta>
                                         -> PINIT[>0] -> CONFIG(FUNCEXPR)<§undef§> : CONFIG(CLASSEXPR)<§undef§>
                                         -> PINIT[=1] -> CONFIG(PRINT)<1> : CONFIG(ONFILTER)<0> : CONFIG(ONFILTER2)<0> : CONFIG(ONVERBOSE)<1>
                                         -> PINIT[=1] -> CONFIG(LIB_BASE_DIR)<NHI1_HOME/theConfig> : CONFIG(LIBDIR)<NHI1_HOME/theConfig/c>
                                         -> PINIT[>0] -> config load          : LIB<NHI1_HOME/theCompiler/src/lib_C.tcl>
                                         -> PINIT[>0] -> config load          : LIB<NHI1_HOME/theKernel/c/compiler.tcl>
                                         -> PINIT[>0] -> config load          : LIB<NHI1_HOME/theConfig/c/compiler.tcl>
                                         -> PINIT[#1] -> call init            : top<c_Class.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/lib_MqS.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/lib_CLS.tcl>
classTree::Main                          -> use classdb: NHI1_HOME/etc/ClassDB.tcl
                                         -> PINIT[#1]            : LIST
                                         ->   | info                 : +++ use
                                         ->   | IGNORE(#ignore)      : <>
                                         ->   | IGNORE(#only)        : <>
                                         ->   | IGNORE(INTERNAL)     : 0
                                         -> PINIT[#1] -> IGNORE(HIDE)<0> : ::HIDE<> : ::KEEP<>
                                         -> PINIT[#1] -> imeta<NHI1_HOME/theConfig/c/gen/c_lcconfig.meta>
                                         -> PINIT[#1] -> getterL<alias:pGet_M2L> : getterS<alias:pGet_M2S> : getterC<alias:pGet_M2C>
::cache::cache_open                      -> CUM -> chORfn<LcConfig> , ext<c> , args<LibNsPkg_lib>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.c>
pInclude                                 -> id<Class-Setup> , cfn<rc0> , fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.c> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
pInclude                                 -> PRINT -> id<Class-Setup>                , fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.c>
::cache::cache_open                      -> CUM -> chORfn<rc0> , ext<-> , args<{}>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.c>
::cache::cache_open                      -> CUM -> chORfn<LcConfig> , ext<c> , args<LibNsPkg_lib>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.c>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.c>
pInclude                                 -> id<Class-Cleanup> , cfn<rc0> , fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.c> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
pInclude                                 -> PRINT -> id<Class-Cleanup>              , fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.c>
::cache::cache_open                      -> CUM -> chORfn<rc0> , ext<-> , args<{}>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.c>
::cache::cache_open                      -> CUM -> chORfn<private_lc> , ext<h> , args<package_private_lib>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/private_lc.h>
pInclude                                 -> id<Class-Extern> , cfn<rc2> , fn<NHI1_HOME/theConfig/c/private_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
pInclude                                 -> PRINT -> id<Class-Extern>               , fn<NHI1_HOME/theConfig/c/private_lc.h>
::cache::cache_open                      -> CUM -> chORfn<rc2> , ext<-> , args<{}>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/private_lc.h>
::cache::cache_open                      -> CUM -> chORfn<LcConfig> , ext<h> , args<LibNsPkg_lib>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.h>
pInclude                                 -> id<Class-Include> , cfn<rc4> , fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
pInclude                                 -> PRINT -> id<Class-Include>              , fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.h>
::cache::cache_open                      -> CUM -> chORfn<rc4> , ext<-> , args<{}>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.h>
::cache::cache_open                      -> CUM -> chORfn<private_lc> , ext<h> , args<package_private_lib>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/private_lc.h>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/private_lc.h>
pInclude                                 -> id<Class-Init-Define> , cfn<rc2> , fn<NHI1_HOME/theConfig/c/private_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
pInclude                                 -> PRINT -> id<Class-Init-Define>          , fn<NHI1_HOME/theConfig/c/private_lc.h>
::cache::cache_open                      -> CUM -> chORfn<rc2> , ext<-> , args<{}>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/private_lc.h>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/LcConfigC_lc.c>
tmpl_make_from_file                      -> keep file -> fn<NHI1_HOME/theConfig/c/LcConfigC_lc.c>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/LcSettingC_lc.c>
tmpl_make_from_file                      -> keep file -> fn<NHI1_HOME/theConfig/c/LcSettingC_lc.c>
::cache::cache_open                      -> CUM -> chORfn<LcSettingC_def> , ext<h> , args<Class_def §ClassC§ LcSettingC §ClassS§ LcSettingS §Class§ LcSetting §Name§ Setting §param§ lccfs §PaRam§ LcCfs §Short§ Cfs §RootC§ SettingC §native§ config_setting_t>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/LcSettingC_def_lc.h>
pInclude                                 -> id<LcSettingS-Definition> , cfn<rc6> , fn<NHI1_HOME/theConfig/c/LcSettingC_def_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
pInclude                                 -> PRINT -> id<LcSettingS-Definition>      , fn<NHI1_HOME/theConfig/c/LcSettingC_def_lc.h>
::cache::cache_open                      -> CUM -> chORfn<rc6> , ext<-> , args<{}>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LcSettingC_def_lc.h>
::cache::cache_open                      -> CUM -> chORfn<LcConfigC_def> , ext<h> , args<Class_def §ClassC§ LcConfigC §ClassS§ LcConfigS §Class§ LcConfig §Name§ Config §param§ lccfg §PaRam§ LcCfg §Short§ Cfg §RootC§ ConfigC §native§ config_t>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/LcConfigC_def_lc.h>
pInclude                                 -> id<LcConfigS-Definition> , cfn<rc8> , fn<NHI1_HOME/theConfig/c/LcConfigC_def_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
pInclude                                 -> PRINT -> id<LcConfigS-Definition>       , fn<NHI1_HOME/theConfig/c/LcConfigC_def_lc.h>
::cache::cache_open                      -> CUM -> chORfn<rc8> , ext<-> , args<{}>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LcConfigC_def_lc.h>
::cache::cache_open                      -> CUM -> chORfn<LcConfigC_def> , ext<h> , args<>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/LcConfigC_def_lc.h>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LcConfigC_def_lc.h>
pInclude                                 -> id<Class-Introspection> , cfn<rc8> , fn<NHI1_HOME/theConfig/c/LcConfigC_def_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
pInclude                                 -> PRINT -> id<Class-Introspection>        , fn<NHI1_HOME/theConfig/c/LcConfigC_def_lc.h>
::cache::cache_open                      -> CUM -> chORfn<rc8> , ext<-> , args<{}>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LcConfigC_def_lc.h>
::cache::cache_open                      -> CUM -> chORfn<LcSettingC_def> , ext<h> , args<>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/LcSettingC_def_lc.h>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LcSettingC_def_lc.h>
pInclude                                 -> id<Class-Introspection> , cfn<rc6> , fn<NHI1_HOME/theConfig/c/LcSettingC_def_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
pInclude                                 -> PRINT -> id<Class-Introspection>        , fn<NHI1_HOME/theConfig/c/LcSettingC_def_lc.h>
::cache::cache_open                      -> CUM -> chORfn<rc6> , ext<-> , args<{}>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LcSettingC_def_lc.h>
::cache::cache_open                      -> CUM -> chORfn<LcConfigC_def> , ext<h> , args<>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/LcConfigC_def_lc.h>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LcConfigC_def_lc.h>
pInclude                                 -> id<Class-Doc-Order> , cfn<rc8> , fn<NHI1_HOME/theConfig/c/LcConfigC_def_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
pInclude                                 -> PRINT -> id<Class-Doc-Order>            , fn<NHI1_HOME/theConfig/c/LcConfigC_def_lc.h>
::cache::cache_open                      -> CUM -> chORfn<rc8> , ext<-> , args<{}>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LcConfigC_def_lc.h>
::cache::cache_open                      -> CUM -> chORfn<LcSettingC_def> , ext<h> , args<>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/LcSettingC_def_lc.h>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LcSettingC_def_lc.h>
pInclude                                 -> id<Class-Doc-Order> , cfn<rc6> , fn<NHI1_HOME/theConfig/c/LcSettingC_def_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
pInclude                                 -> PRINT -> id<Class-Doc-Order>            , fn<NHI1_HOME/theConfig/c/LcSettingC_def_lc.h>
::cache::cache_open                      -> CUM -> chORfn<rc6> , ext<-> , args<{}>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LcSettingC_def_lc.h>
::cache::cache_open                      -> CUM -> chORfn<LcSettingC_def> , ext<h> , args<>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/LcSettingC_def_lc.h>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LcSettingC_def_lc.h>
pInclude                                 -> id<LcSettingS-Export> , cfn<rc6> , fn<NHI1_HOME/theConfig/c/LcSettingC_def_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
pInclude                                 -> PRINT -> id<LcSettingS-Export>          , fn<NHI1_HOME/theConfig/c/LcSettingC_def_lc.h>
::cache::cache_open                      -> CUM -> chORfn<rc6> , ext<-> , args<{}>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LcSettingC_def_lc.h>
::cache::cache_open                      -> CUM -> chORfn<LcConfigC_def> , ext<h> , args<>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/LcConfigC_def_lc.h>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LcConfigC_def_lc.h>
pInclude                                 -> id<LcConfigS-Export> , cfn<rc8> , fn<NHI1_HOME/theConfig/c/LcConfigC_def_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
pInclude                                 -> PRINT -> id<LcConfigS-Export>           , fn<NHI1_HOME/theConfig/c/LcConfigC_def_lc.h>
::cache::cache_open                      -> CUM -> chORfn<rc8> , ext<-> , args<{}>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LcConfigC_def_lc.h>
::cache::cache_open                      -> CUM -> chORfn<LcSettingC_def> , ext<h> , args<>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/LcSettingC_def_lc.h>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LcSettingC_def_lc.h>
pInclude                                 -> id<LcSettingS-native> , cfn<rc6> , fn<NHI1_HOME/theConfig/c/LcSettingC_def_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
pInclude                                 -> PRINT -> id<LcSettingS-native>          , fn<NHI1_HOME/theConfig/c/LcSettingC_def_lc.h>
::cache::cache_open                      -> CUM -> chORfn<rc6> , ext<-> , args<{}>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LcSettingC_def_lc.h>
::cache::cache_open                      -> CUM -> chORfn<LcSettingC_def> , ext<h> , args<>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/LcSettingC_def_lc.h>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LcSettingC_def_lc.h>
pInclude                                 -> id<LcSettingS-super> , cfn<rc6> , fn<NHI1_HOME/theConfig/c/LcSettingC_def_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
pInclude                                 -> PRINT -> id<LcSettingS-super>           , fn<NHI1_HOME/theConfig/c/LcSettingC_def_lc.h>
::cache::cache_open                      -> CUM -> chORfn<rc6> , ext<-> , args<{}>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LcSettingC_def_lc.h>
::cache::cache_open                      -> CUM -> chORfn<LibLcConfig> , ext<h> , args<>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.h>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.h>
pInclude                                 -> id<ShortDef> , cfn<rc4> , fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
pInclude                                 -> PRINT -> id<ShortDef>                   , fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.h>
::cache::cache_open                      -> CUM -> chORfn<rc4> , ext<-> , args<{}>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.h>
::cache::cache_open                      -> CUM -> chORfn<LcConfigC_def> , ext<h> , args<>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/LcConfigC_def_lc.h>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LcConfigC_def_lc.h>
pInclude                                 -> id<LcConfigS-native> , cfn<rc8> , fn<NHI1_HOME/theConfig/c/LcConfigC_def_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
pInclude                                 -> PRINT -> id<LcConfigS-native>           , fn<NHI1_HOME/theConfig/c/LcConfigC_def_lc.h>
::cache::cache_open                      -> CUM -> chORfn<rc8> , ext<-> , args<{}>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LcConfigC_def_lc.h>
::cache::cache_open                      -> CUM -> chORfn<LcConfigC_def> , ext<h> , args<>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/LcConfigC_def_lc.h>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LcConfigC_def_lc.h>
pInclude                                 -> id<LcConfigS-super> , cfn<rc8> , fn<NHI1_HOME/theConfig/c/LcConfigC_def_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
pInclude                                 -> PRINT -> id<LcConfigS-super>            , fn<NHI1_HOME/theConfig/c/LcConfigC_def_lc.h>
::cache::cache_open                      -> CUM -> chORfn<rc8> , ext<-> , args<{}>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LcConfigC_def_lc.h>
GLOBAL                                   -> outCLASS<EMPTY> , outTMP<EMPTY>
pInclude                                 -> id<Class-define> , cfn<NHI1_HOME/theConfig/c/tmpl/lc_misc_check_lng.h> , fn<NHI1_HOME/theConfig/c/tmpl/lc_misc_check_lng.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | ns_misc_check_lng
                                         ->     | -tmpl-args    | <>
pInclude                                 -> PRINT -> id<Class-define>               , fn<NHI1_HOME/theConfig/c/tmpl/lc_misc_check_lng.h>
::cache::cache_open                      -> CUM -> chORfn<NHI1_HOME/theConfig/c/tmpl/lc_misc_check_lng.h> , ext<-> , args<ns_misc_check_lng>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/tmpl/lc_misc_check_lng.h>
pInclude                                 -> id<Class-define> , cfn<NHI1_HOME/theConfig/c/tmpl/lc_type_S_macros.h> , fn<NHI1_HOME/theConfig/c/tmpl/lc_type_S_macros.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | ns_type_S_macros
                                         ->     | -tmpl-args    | <>
pInclude                                 -> PRINT -> id<Class-define>               , fn<NHI1_HOME/theConfig/c/tmpl/lc_type_S_macros.h>
::cache::cache_open                      -> CUM -> chORfn<NHI1_HOME/theConfig/c/tmpl/lc_type_S_macros.h> , ext<-> , args<ns_type_S_macros>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/tmpl/lc_type_S_macros.h>
pInclude                                 -> id<HEADER> , cfn<LibLcConfig> , fn<LibLcConfig> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | h
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
pInclude                                 -> PRINT -> id<HEADER>                     , fn<LibLcConfig>
::cache::cache_open                      -> CUM -> chORfn<LibLcConfig> , ext<h> , args<{}>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.h>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.h>
cache_close                              -> keep file -> fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.h>
cache_close                              -> keep file -> fn<NHI1_HOME/theConfig/c/tmpl/lc_type_S_macros.h>
cache_close                              -> keep file -> fn<NHI1_HOME/theConfig/c/private_lc.h>
cache_close                              -> keep file -> fn<NHI1_HOME/theConfig/c/tmpl/lc_misc_check_lng.h>
cache_close                              -> keep file -> fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.c>
cache_close                              -> keep file -> fn<NHI1_HOME/theConfig/c/LcConfigC_def_lc.h>
cache_close                              -> keep file -> fn<NHI1_HOME/theConfig/c/LcSettingC_def_lc.h>
 

And create the following code (example: LcConfigS) :

Example from LcConfigC_def_lc.h class hierarchy

// BEGIN-LcConfigS-super - created by 'c_Class.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
union {
struct MkObjectS obj; // instance-base MkObjectS
} super;
// END-LcConfigS-super - created by 'c_Class.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change

Example from LcConfigC_def_lc.h class definition

// BEGIN-LcConfigS-Definition - created by 'c_Class.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
__parser__push__(prefix=Class, doc-group=Define, doc-index=Class);
// Signature --------------------------------------------------------------
#define LcConfigC_SIGNATURE (MkObjectC_SIGNATURE ^ (15u<<10))
#define LcConfigC_MASK (((1u<<22)-1)<<10)
// CompileTimeCast --------------------------------------------------------------
#define LcConfigC_X2cfg(x) (x)
#define LcConfigC_X2obj(x) MkOBJ(x)
// TypeDef --------------------------------------------------------------
__parser__(ignore) typedef struct LcConfigS LcConfigCR;
__parser__(ignore) typedef const struct LcConfigS LcConfigCNR;
#define LcConfigC_T ( (struct MkSuperTypeS *) (LcConfigC_TT) )
#define LcConfigST LcConfigC_T
#define LcConfigSTT (MkTYP(LcConfigST))
#define LcConfigC_type LC_CFG
#define LcConfigCT_X(instance) ( (struct MkSuperTypeS *) (MkOBJ_R(instance).type) )
#define LcConfigCTT_X(instance) (MkOBJ_R(instance).type)
#define LcConfigCT_TT(typ) ( (struct MkSuperTypeS *) (typ) )
#define LcConfigC_NS LC
#define LcConfigCTT LcConfigCTT
#define LcConfigCT ( (struct MkSuperTypeS *) LcConfigCTT )
// TypeCheck --------------------------------------------------------------
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wattributes"
__parser__(class=LcConfigC,static,hide)
return MkSanitizeCheck(LcConfigC,mng);
}
__parser__(class=LcConfigC,static,hide)
return MkSanitizeCheckO(LcConfigC,obj);
}
#pragma GCC diagnostic pop
#define LcConfigC_Check(mng) LcCfgCheck(mng)
// RunTimeCast --------------------------------------------------------------
__parser__(class=LcConfigC,hide,static)
META_ATTRIBUTE_SANITIZE
return (LcCfgCheck(mng) ? (LC_CFG)mng : NULL);
}
__parser__(class=LcConfigC,hide,static)
META_ATTRIBUTE_SANITIZE
return (LcCfgCheck(mng) ? (LC_CFGN)mng : NULL);
}
#define LcCfgRaise(_cfg) if (!_MkCheckX(LcConfigC,_cfg)) { \
MkErrorSetC_1E("'LcConfigC' hdl is NULL"); \
goto error ; \
}
#define LcCFG_R(x) (*(x)).super.cfg
#define LcCFG(x) (&LcCFG_R(x))
// LcConfigC_Class_Define_C_API
// END-LcConfigS-Definition - created by 'c_Class.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
bool LcCfgCheckO(MK_OBJN obj)
LC_CFG LcCfg(MK_MNG mng)
MkThreadLocal MK_TYP LcConfigC_TT
LC_CFGN LcCfgN(MK_MNGN mng)
bool LcCfgCheck(MK_MNGN mng)
#define LC_EXTERN_DATA
#define LC_ATTR_CLASS
#define mk_inline
#define __parser__pop__
#define __parser__push__(...)
#define __parser__(...)
const MK_PTRB * MK_MNGN
MK_PTRB * MK_MNG
#define MkSanitizeCheck(_root, _m)
#define MkSanitizeCheckO(_root, _o)
#define MkThreadLocal
struct MkObjectS obj

Example from LibLcConfig_lc.h class type definition

// BEGIN-ShortDef - created by 'c_Class.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
__parser__(type=ME_CCC_LcConfigC:"LcConfigC class handle":primary)
typedef struct LcConfigS * LC_CFG;
__parser__(type=ME_CCN_LcConfigC:"const - LcConfigC class handle":primary)
typedef const struct LcConfigS * LC_CFGN;
__parser__(ignore)
typedef struct LcConfigS LC_CFGR;
// LcConfigC_Class_C_API
__parser__(type=ME_CCC_LcSettingC:"LcSettingC class handle":primary)
typedef struct LcSettingS * LC_CFS;
__parser__(type=ME_CCN_LcSettingC:"const - LcSettingC class handle":primary)
typedef const struct LcSettingS * LC_CFSN;
__parser__(ignore)
typedef struct LcSettingS LC_CFSR;
// LcSettingC_Class_C_API
// END-ShortDef - created by 'c_Class.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
const struct LcConfigS * LC_CFGN
struct LcConfigS * LC_CFG
const struct LcSettingS * LC_CFSN
struct LcSettingS * LC_CFS

Example from LcConfigC_def_lc.h class introspection

// BEGIN-Class-Introspection - created by 'c_Class.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
__parser__push__(doc-name=Introspection,doc-index=Class,class=LcConfigC,no-rpc,null-return-allow,flags=new);
}
return (LC_CFG)LcConfigC_X2obj(cfg)->obj_protect.next;
}
return (LC_CFG)LcConfigC_X2obj(cfg)->obj_protect.prev;
}
// LcConfigC_Class_C_API
// END-Class-Introspection - created by 'c_Class.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
LC_CFG LcConfigNext(LC_CFG const cfg)
LC_CFG LcConfigPrev(LC_CFG const cfg)
LC_CFG LcConfigInstances_RT(MK_PARSER_RT_ONLY)
#define LcConfigC_X2obj(x)
#define LC_ATTR_INSTANCE
#define LC_ATTR_RT_CLASS
#define LC_STATIC_RT
#define MK_PARSER_RT_ONLY
#define MK_INSTANCE_HDL(x)
MK_OBJ instances

'c_Meta' - Create the "meta-code" from the header file(s)

The meta-code is the most important file from the alc-compiler as near all tools use this file to extract the api-definition.

The config_lc.h file is the wrapper needed only for compiling with c_Meta to add __parser__ directives that ultimately adapt the native definitions in libconfig.h to the managed-object structure. In addition to the native API, the classes generated using c_Class are also compiled.

The c_Meta write the meta-code into the package-directory because this file will be added into the release-management (git). By default the filenames gen/c_lcconfig.meta and gen/nat_lcconfig.meta are created and follow the project name LibLcConfig.

 call: 'c_Meta.tcl' '-lc'


pInit                                    -> PINIT[#0] -> +++ use              : lang<c>         : api<Meta>            : top<c_Meta.tcl>
                                         -> PINIT[#0] -> argv<-lc>
c_Meta__Main                             -> LIST
                                         ->   | imk                  : NHI1_HOME/theKernel/c
                                         ->   | header               : NHI1_HOME/theConfig/c/config_lc.h
WriteMeta                                -> LIST
                                         ->   | metaf                : NHI1_HOME/theConfig/c/gen/nat_lcconfig.meta
                                         ->   | indexF               : NHI1_HOME/theConfig/c/gen/nat_lcconfig.index
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/nat_lcconfig.meta
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/nat_lcconfig.index
WriteMeta                                -> LIST
                                         ->   | metaf                : NHI1_HOME/theConfig/c/gen/c_lcconfig.meta
                                         ->   | indexF               : NHI1_HOME/theConfig/c/gen/c_lcconfig.index
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/c_lcconfig.meta
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/c_lcconfig.index
 

The following image shows the meta-code of the native function config_lookup_int64 :

call: grep '\<LcConfigLookupInt64\>' NHI1_HOME/theConfig/c/gen/nat_lcconfig.meta
...
attributeDEF LcConfigLookupInt64,cast yes
attributeDEF LcConfigLookupInt64,config,native {nat config_t §S§M§P}
attributeDEF LcConfigLookupInt64,default-args value_out
attributeDEF LcConfigLookupInt64,error-check ME_ENE_LcErrorE
attributeDEF LcConfigLookupInt64,inline yes
attributeDEF LcConfigLookupInt64,native-alias config_lookup_int64
attributeDEF LcConfigLookupInt64,type-attr {value_out P#1}
attributeDEF LcConfigLookupInt64,value_out,out yes
funcDEF LcConfigLookupInt64 ME_ENE_MkErrorE {{ME_CCN_LcConfigC config} {ME_PSN_MK_STRN path} {ME_NI8_MK_I64 value_out}}
...
enum MkErrorE LcConfigLookupInt64(LC_CFGN config, MK_STRN path, MK_I64 *value_out)
LIBCONFIG_API int config_lookup_int64(const config_t *config, const char *path, long long *value)

'c_Native' - Add code to wrap "native-code" into "managed-object-code"

The problem is that a native-library lacks all the functionality required to function properly as a managed-object

The c_Native perform the following tasks:

  1. change the api-data-types into PRIMITIVE TYPE
  2. change the error-handling from native to managed-object-error
  3. create an inline-wrapper for every public native-api-function
  4. convert a native-struct (handle) into a managed-object-class
 call: 'c_Native.tcl' '-lc' '-v'


pInit                                    -> PINIT[#0] -> +++ use              : lang<c>         : api<Native>          : top<c_Native.tcl>
                                         -> PINIT[#0] -> argv<-lc -v>
                                         -> PINIT[>0] -> INIT(lang)<c> : INIT(Api)<Native> : INIT(argv)<-i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta>
                                         -> PINIT[>0] -> CONFIG(FUNCEXPR)<§undef§> : CONFIG(CLASSEXPR)<§undef§>
                                         -> PINIT[=1] -> CONFIG(PRINT)<0> : CONFIG(ONFILTER)<0> : CONFIG(ONFILTER2)<0> : CONFIG(ONVERBOSE)<1>
                                         -> PINIT[=1] -> CONFIG(LIB_BASE_DIR)<NHI1_HOME/theConfig> : CONFIG(LIBDIR)<NHI1_HOME/theConfig/c>
                                         -> PINIT[>0] -> config load          : LIB<NHI1_HOME/theCompiler/src/lib_C.tcl>
                                         -> PINIT[>0] -> config load          : LIB<NHI1_HOME/theKernel/c/compiler.tcl>
                                         -> PINIT[>0] -> config load          : LIB<NHI1_HOME/theConfig/c/compiler.tcl>
                                         -> PINIT[#1] -> call init            : top<c_Native.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/c_MqS.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/lib_MqS.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/lib_DX.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/c_MqC.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/lib_MqC.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/lib_MqC_type_C.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/lib_Native.tcl>
                                         -> PINIT[#1]            : LIST
                                         ->   | info                 : +++ use
                                         ->   | IGNORE(#ignore)      : <>
                                         ->   | IGNORE(#only)        : <>
                                         ->   | IGNORE(INTERNAL)     : 0
                                         -> PINIT[#1] -> IGNORE(HIDE)<0> : ::HIDE<> : ::KEEP<>
                                         -> PINIT[#1] -> imeta<NHI1_HOME/theConfig/c/gen/c_lcconfig.meta>
                                         -> PINIT[#1] -> getterL<alias:pGet_M2L> : getterS<alias:pGet_M2S> : getterC<alias:pGet_M2S>
pEVAL                                    -> +++000 -> try native
pEVAL                                    -> +++333 -> use imeta -> imeta<NHI1_HOME/theConfig/c/gen/nat_lcconfig.meta>
pEVAL                                    -> +++333 -> use cache -> cache<NHI1_BUILD/theConfig/c/gen/nat_lcconfig.meta.compile>
p_funcEND                                -> statistics -> p_funcDEF_all<126> , p_funcDEF_use<126> , p_funcDEF_skip<0> , p_funcDEF_internal<13> , p_funcDEF_hide<0>
p_funcEND                                -> use all '126' functions
lib_ME__build_CLASS_index                -> print CLASS database -> CLASS<array|P|*>
                                         ->   CLASS = <array|P|*>
                                         ->     | LcConfig   | empty
                                         ->     | LcConfigC  | LcConfigC-Error LcConfigC-Get LcConfigC-Lookup LcConfigC-Misc LcConfigC-Set
                                         ->     | LcSettingC | LcSettingC-Get LcSettingC-Is LcSettingC-Lookup LcSettingC-Misc LcSettingC-Set LcSettingC-TOR
lib_ME__write_funcARY                    -> Xclass<LcConfig>
::cache::cache_open                      -> CUM -> chORfn<LcConfig> , ext<h> , args<{} §ClassC§ LcConfig>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.h>
pInclude                                 -> id<LcConfig-inline> , cfn<rc0> , fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
::cache::cache_open                      -> CUM -> chORfn<rc0> , ext<-> , args<{}>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.h>
lib_ME__write_funcARY                    -> Xclass<LcConfigC>
::cache::cache_open                      -> CUM -> chORfn<LcConfigC> , ext<h> , args<{} §ClassC§ LcConfigC §NS_CLS§ LC_CFG>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/LcConfigC_lc.h>
pInclude                                 -> id<LcConfigC-inline> , cfn<rc2> , fn<NHI1_HOME/theConfig/c/LcConfigC_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
::cache::cache_open                      -> CUM -> chORfn<rc2> , ext<-> , args<{}>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LcConfigC_lc.h>
lib_ME__write_funcARY                    -> Xclass<LcSettingC>
::cache::cache_open                      -> CUM -> chORfn<LcSettingC> , ext<h> , args<{} §ClassC§ LcSettingC §NS_CLS§ LC_CFS>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/LcSettingC_lc.h>
pInclude                                 -> id<LcSettingC-inline> , cfn<rc4> , fn<NHI1_HOME/theConfig/c/LcSettingC_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
::cache::cache_open                      -> CUM -> chORfn<rc4> , ext<-> , args<{}>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LcSettingC_lc.h>
lib_ME__build_CLASS_index                -> print CLASS database -> CLASS<array|P|*>
                                         ->   CLASS = <array|P|*>
                                         ->     | LcConfig   | empty
                                         ->     | LcConfigC  | empty
                                         ->     | LcSettingC | empty
lib_ME__write_funcARY                    -> Xclass<LcConfig>
::cache::cache_open                      -> CUM -> chORfn<LcConfig> , ext<h> , args<{} §ClassC§ LcConfig>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.h>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.h>
pInclude                                 -> id<LcConfig-fupu> , cfn<rc0> , fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
::cache::cache_open                      -> CUM -> chORfn<rc0> , ext<-> , args<{}>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.h>
lib_ME__write_funcARY                    -> Xclass<LcConfigC>
::cache::cache_open                      -> CUM -> chORfn<LcConfigC> , ext<h> , args<{} §ClassC§ LcConfigC §NS_CLS§ LC_CFG>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/LcConfigC_lc.h>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LcConfigC_lc.h>
pInclude                                 -> id<LcConfigC-fupu> , cfn<rc2> , fn<NHI1_HOME/theConfig/c/LcConfigC_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
::cache::cache_open                      -> CUM -> chORfn<rc2> , ext<-> , args<{}>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LcConfigC_lc.h>
lib_ME__write_funcARY                    -> Xclass<LcSettingC>
::cache::cache_open                      -> CUM -> chORfn<LcSettingC> , ext<h> , args<{} §ClassC§ LcSettingC §NS_CLS§ LC_CFS>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/LcSettingC_lc.h>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LcSettingC_lc.h>
pInclude                                 -> id<LcSettingC-fupu> , cfn<rc4> , fn<NHI1_HOME/theConfig/c/LcSettingC_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
::cache::cache_open                      -> CUM -> chORfn<rc4> , ext<-> , args<{}>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LcSettingC_lc.h>
cache_close                              -> keep file -> fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.h>
cache_close                              -> keep file -> fn<NHI1_HOME/theConfig/c/LcConfigC_lc.h>
cache_close                              -> keep file -> fn<NHI1_HOME/theConfig/c/LcSettingC_lc.h>
 

The following image shows the translation of the native function config_lookup_int64 into the manged-object function LcConfigLookupInt64.

 call: 'c_Native.tcl' '-lc' '-d' '-f' 'LcConfigLookupInt64'


pInit                                    -> PINIT[#0] -> +++ use              : lang<c>         : api<Native>          : top<c_Native.tcl>
                                         -> PINIT[#0] -> argv<-lc -d -f LcConfigLookupInt64>
                                         -> PINIT[>0] -> INIT(lang)<c> : INIT(Api)<Native> : INIT(argv)<-i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta>
                                         -> PINIT[>0] -> CONFIG(FUNCEXPR)<LcConfigLookupInt64> : CONFIG(CLASSEXPR)<§undef§>
                                         -> PINIT[=1] -> CONFIG(PRINT)<1> : CONFIG(ONFILTER)<1> : CONFIG(ONFILTER2)<1> : CONFIG(ONVERBOSE)<1>
                                         -> PINIT[=1] -> CONFIG(LIB_BASE_DIR)<NHI1_HOME/theConfig> : CONFIG(LIBDIR)<NHI1_HOME/theConfig/c>
                                         -> PINIT[>0] -> config load          : LIB<NHI1_HOME/theCompiler/src/lib_C.tcl>
                                         -> PINIT[>0] -> config load          : LIB<NHI1_HOME/theKernel/c/compiler.tcl>
                                         -> PINIT[>0] -> config load          : LIB<NHI1_HOME/theConfig/c/compiler.tcl>
                                         -> PINIT[#1] -> call init            : top<c_Native.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/c_MqS.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/lib_MqS.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/lib_DX.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/c_MqC.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/lib_MqC.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/lib_MqC_type_C.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/lib_Native.tcl>
                                         -> PINIT[#1]            : LIST
                                         ->   | info                 : +++ use
                                         ->   | IGNORE(#ignore)      : <>
                                         ->   | IGNORE(#only)        : <>
                                         ->   | IGNORE(INTERNAL)     : 0
                                         -> PINIT[#1] -> IGNORE(HIDE)<0> : ::HIDE<> : ::KEEP<>
                                         -> PINIT[#1] -> imeta<NHI1_HOME/theConfig/c/gen/c_lcconfig.meta>
                                         -> PINIT[#1] -> getterL<alias:pGet_M2L> : getterS<alias:pGet_M2S> : getterC<alias:pGet_M2S>
  |DEBUG[1]: pEVAL                                    -> >>> START:                          , CONFIG<array|P|*> , INIT<array|P|*>
  |DEBUG[1]:                                          ->   CONFIG = <array|P|*>
  |DEBUG[1]:                                          ->     | ALLOW_argv      | no                                   | ALWAYS_DEFAULT      | no
  |DEBUG[1]:                                          ->     | ARRAY_IS_VARARG | no                                   | BROKEN_C_NAME       | no
  |DEBUG[1]:                                          ->     | CLASSEXPR       | §undef§                              | CMD                 | c_Native.tcl
  |DEBUG[1]:                                          ->     | CMT             | //                                   | CMT_DX              | ///
  |DEBUG[1]:                                          ->     | CNs             | LcNs                                 | CODEEXT_C           | c
  |DEBUG[1]:                                          ->     | CODEEXT_N       | c                                    | CODEEXT_S           | c
  |DEBUG[1]:                                          ->     | C_API           | yes                                  | DEBUG               | 1
  |DEBUG[1]:                                          ->     | DEPENDENCY      | no                                   | DOCID               | C
  |DEBUG[1]:                                          ->     | ERASE_ALL       | no                                   | FILTER              | yes
  |DEBUG[1]:                                          ->     | FORCE           | no                                   | FRAME_CLEANUP       | no
  |DEBUG[1]:                                          ->     | FRAME_GET_ALL   | no                                   | FRAME_INIT_STACK    | no
  |DEBUG[1]:                                          ->     | FUNCEXPR        | LcConfigLookupInt64                  | HAS_CLASS           | no
  |DEBUG[1]:                                          ->     | HAS_DEFAULT_ARG | no                                   | HAS_REF_POINTER     | no
  |DEBUG[1]:                                          ->     | HAS_TYPE_FIRST  | yes                                  | JUMP_ON_ERROR       | no
  |DEBUG[1]:                                          ->     | KEYWORDS        | <>                                   | LIBDIR              | NHI1_HOME/theConfig/c
  |DEBUG[1]:                                          ->     | LIB_BASE_DIR    | NHI1_HOME/theConfig | LONG                | lc
  |DEBUG[1]:                                          ->     | LngId           | c                                    | META_FILE_EXTENSION | <>
  |DEBUG[1]:                                          ->     | META_HIDE_BEGIN | #ifndef PARSE_C_HEADER_TO_META       | META_HIDE_END       | #endif
  |DEBUG[1]:                                          ->     | ONFILTER        | 1                                    | ONFILTER2           | 1
  |DEBUG[1]:                                          ->     | ONPROFILE       | false                                | ONVERBOSE           | 1
  |DEBUG[1]:                                          ->     | OVERLOAD        | no                                   | OVERLOAD_CALL       | yes
  |DEBUG[1]:                                          ->     | OVERLOAD_NAME   | yes                                  | PRINT               | 1
  |DEBUG[1]:                                          ->     | PRINT2          | 1                                    | PROFILE_KEY         | exclusiveRuntime
  |DEBUG[1]:                                          ->     | PROFILE_PAT     | *                                    | RCNs                | @RLcNs
  |DEBUG[1]:                                          ->     | SHOW_FILTER     | no                                   | SHOW_FILTER_DETAIL  | no
  |DEBUG[1]:                                          ->     | SILENT          | 0                                    | STDOUT              | 0
  |DEBUG[1]:                                          ->     | STYLE           | C                                    | TOPLEVEL            | NHI1_HOME/theCompiler/src/c_Native.tcl
  |DEBUG[1]:                                          ->     | USE_CALLBACK    | no                                   | USE_FINAL_NAME      | false
  |DEBUG[1]:                                          ->     | USE_NS          | no                                   | VARARG_IS_ARRAY     | no
  |DEBUG[1]:                                          ->     | VERBOSE         | 1                                    | WARNING_AS_ERROR    | no
  |DEBUG[1]:                                          ->     | WRITE           | no                                   | lng_nspkg           | c_lcconfig
  |DEBUG[1]:                                          ->   INIT = <array|P|*>
  |DEBUG[1]:                                          ->     | Api  | Native                                       | LANG      | C
  |DEBUG[1]:                                          ->     | Ns   | Lc                                           | Prefix    | c_Native
  |DEBUG[1]:                                          ->     | argv | -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta | example   | no
  |DEBUG[1]:                                          ->     | lang | c                                            | langid    | c
  |DEBUG[1]:                                          ->     | ns   | lc                                           | overwrite | no
pEVAL                                    -> +++000 -> try native
pEVAL                                    -> +++333 -> use imeta -> imeta<NHI1_HOME/theConfig/c/gen/nat_lcconfig.meta>
pEVAL                                    -> +++333 -> use cache -> cache<NHI1_BUILD/theConfig/c/gen/nat_lcconfig.meta.compile>
  |      DEBUG[1]: tcl::mathfunc::checkIgnore               -> allow<FUNC_M>                       ,
  |         DEBUG[1]: tcl::mathfunc::checkIgnore               -> ignore<HIDE>                        ,
  |         DEBUG[1]: tcl::mathfunc::checkNotIgnore            -> allow<INTERNAL>                     ,
p_filter                                 -> DEBUG[#1] -> use , __NAME__<LcConfigLookupInt64>
p_funcEND                                -> statistics -> p_funcDEF_all<126> , p_funcDEF_use<1> , p_funcDEF_skip<125> , p_funcDEF_internal<13> , p_funcDEF_hide<0>
p_funcEND                                -> skip '125' from '126' functions -> p_funcDEF_use<LcConfigLookupInt64>
pEVAL                                    -> funcDEF RESULT : LcConfigLookupInt64 =========================================
pEVAL                                    -> ty<omo>                        , type0M<ME_CCN_LcConfigC>       , var0<config>                   ,
pEVAL                                    -> retM<ME_ENE_MkErrorE>          , retC<MkErrorE>                 , retOM<ME_ENE_MkErrorE>         ,
pEVAL                                    -> class<LcConfigC>               , classM<ME_CCN_LcConfigC>       , classC<LcConfigC>              ,
pEVAL                                    -> prefix<LcConfig>               , prefixM<ME_CCN_LcConfigC>      , prefixC<LcConfigC>             ,
pEVAL                                    -> argv<{ME_CCN_LcConfigC config} {ME_PSN_MK_STRN path} {ME_NI8_MK_I64 value_out}> , RETURN_MAPPING<>
pEVAL                                    -> ===================================================================
  |DEBUG[1]: tcl::mathfunc::checkNotIgnore            -> allow<FUNC_S>                       ,
  |      DEBUG[1]: tcl::mathfunc::checkIgnore               -> allow<INSTANCE>                     ,
  |      DEBUG[1]: tcl::mathfunc::checkIgnore               -> allow<STATIC>                       ,
  |   DEBUG[1]: lib_DX__getDocParameterApi               -> >>> START:                          , __NAME__<LcConfigLookupInt64>
  |      DEBUG[1]: getDocR                                  -> >>> START: doc(R)                   , __NAME__<LcConfigLookupInt64> , cls<LcConfigC> , pfx<LcConfig>
  |   DEBUG[1]: lib_DX__getDocParameterApi               -> LIST
  |   DEBUG[1]:                                          ->   | __NAME__             : LcConfigLookupInt64
  |   DEBUG[1]:                                          ->   | isDocI               : 0
  |   DEBUG[1]:                                          ->   | dR                   : Lookup
  |   DEBUG[1]:                                          ->   | dRA                  : LcConfigC-Lookup
  |   DEBUG[1]:                                          ->   | dI                   : _ignore_
  |   DEBUG[1]:                                          ->   | dIA                  : LcConfigC-Lookup
  |   DEBUG[1]:                                          ->   | clsR                 : LcConfigC
  |   DEBUG[1]:                                          ->   | dDA                  : LcConfigC_Lookup_C_API
writeARY(LcConfigC,LcConfigC-Lookup,omo) =   |DEBUG[1]: lib_MqC__funcLST_2_funcARY__styleC       -> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^~ ,
  |DEBUG[1]:                                          -> +++ START +++                       , __NAME__<LcConfigLookupInt64>
  |DEBUG[1]: lib_MqC__funcLST_2_funcARY__styleC       -> >>> START: Setup                    , __NAME__<LcConfigLookupInt64>
  |   DEBUG[1]: lib_MqS__ARG                             -> >>> START:                          , __NAME__<LcConfigLookupInt64> , ty<omo> , argv<{ME_CCN_LcConfigC config} {ME_PSN_MK_STRN path} {ME_NI8_MK_I64 value_out}> , getter<getterC> , formater<Filter_arg_in>
  |      DEBUG[1]: lib_MqS__ARG_default_init                -> >>> START:                          , at<ME_CCN_LcConfigC> , av<config> , getter<getterC> , ::Flag_onNativeDefault<false>
  |      DEBUG[1]: lib_MqS__ARG_default_init                -> >>> START:                          , at<ME_PSN_MK_STRN> , av<path> , getter<getterC> , ::Flag_onNativeDefault<false>
  |      DEBUG[1]: lib_MqS__ARG_default                     -> >>> START:                          , at<ME_NI8_MK_I64> , av<value_out> , getter<getterC>
  |         DEBUG[1]: lib_MqS__ARG_default_init                -> >>> START:                          , at<ME_NI8_MK_I64> , av<value_out> , getter<getterC> , ::Flag_onNativeDefault<false>
  |DEBUG[1]: lib_MqC__funcLST_2_funcARY__styleC       -> >>> START: LevelProc                ,
  |   DEBUG[1]: LevelProc                                -> >>> START:                          ,

/// @ingroup LcConfigC_Lookup_C_API
mk_inline enum MkErrorE LcConfigLookupInt64 (LC_CFGN config, MK_STRN path, MK_I64 *value_out) {
  LC_INSTANCE_HDL(config);
    |DEBUG[1]: lib_MqC__funcLST_2_funcARY__styleC       -> >>> START: LevelInit                ,
    |   DEBUG[1]: LevelInit                                -> >>> START:                          ,
    |   DEBUG[1]: lib_MqC__CALL__styleC                    -> >>> START:                          , argv<{ME_CCN_LcConfigC config} {ME_PSN_MK_STRN path} {ME_NI8_MK_I64 value_out}>
    |DEBUG[1]: lib_MqC__funcLST_2_funcARY__styleC       -> >>> START: LevelCode                ,
    |   DEBUG[1]: LevelCode                                -> >>> START:                          ,
    |DEBUG[1]: lib_MqC__funcLST_2_funcARY__styleC       -> >>> START: SpecialArgument          , retVal<__retVal__L> , __NAME__<LcConfigLookupInt64>
    |DEBUG[1]: lib_MqC__funcLST_2_funcARY__styleC       -> >>> START: retVal definition        , retOM<ME_ENE_MkErrorE> , ::LibAllErrorType<^ME_ENE_MkErrorE> , retVal<__retVal__L> , CALL<(enum LcErrorE)config_lookup_int64(config->nat, path, value_out)>
    |DEBUG[1]: lib_MqC__funcLST_2_funcARY__styleC       -> 111                                 , ::attributeDEF<EMPTY>
  enum LcErrorE errVal = (enum LcErrorE)config_lookup_int64(config->nat, path, value_out);
    |   DEBUG[1]: lib_MqC__Raise_Error                     -> >>> START: RaiseError               , CONFIG(JUMP_ON_ERROR)
  LcErrorE_Check(config, errVal);
    |DEBUG[1]: lib_MqC__funcLST_2_funcARY__styleC       -> >>> START: return                   , retM<void> , retOM<ME_ENE_MkErrorE> , classM<ME_CCN_LcConfigC> , ty<omo> , CALL<errVal>
  return MK_OK;
error:
  return MK_ERROR;
}

lib_ME__build_CLASS_index                -> print CLASS database -> CLASS<array|P|*>
                                         ->   CLASS = <array|P|*>
                                         ->     | LcConfig   | empty
                                         ->     | LcConfigC  | LcConfigC-Lookup
                                         ->     | LcSettingC | empty
lib_ME__write_funcARY                    -> Xclass<LcConfigC>
::cache::cache_open                      -> CUM -> chORfn<LcConfigC> , ext<h> , args<{} §ClassC§ LcConfigC §NS_CLS§ LC_CFG>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/LcConfigC_lc.h>
pInclude                                 -> id<LcConfigC-inline> , cfn<rc0> , fn<NHI1_HOME/theConfig/c/LcConfigC_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>

#ifndef PARSE_C_HEADER_TO_META
  
  // doc-key: LcConfigC,LcConfigC-Lookup,omo
    |DEBUG[1]: lib_MqC__funcLST_2_funcARY__styleC       -> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^~ ,
    |DEBUG[1]:                                          -> +++ START +++                       , __NAME__<LcConfigLookupInt64>
    |DEBUG[1]: lib_MqC__funcLST_2_funcARY__styleC       -> >>> START: Setup                    , __NAME__<LcConfigLookupInt64>
    |   DEBUG[1]: lib_MqS__ARG                             -> >>> START:                          , __NAME__<LcConfigLookupInt64> , ty<omo> , argv<{ME_CCN_LcConfigC config} {ME_PSN_MK_STRN path} {ME_NI8_MK_I64 value_out}> , getter<getterC> , formater<Filter_arg_in>
    |      DEBUG[1]: lib_MqS__ARG_default_init                -> >>> START:                          , at<ME_CCN_LcConfigC> , av<config> , getter<getterC> , ::Flag_onNativeDefault<false>
    |      DEBUG[1]: lib_MqS__ARG_default_init                -> >>> START:                          , at<ME_PSN_MK_STRN> , av<path> , getter<getterC> , ::Flag_onNativeDefault<false>
    |      DEBUG[1]: lib_MqS__ARG_default                     -> >>> START:                          , at<ME_NI8_MK_I64> , av<value_out> , getter<getterC>
    |         DEBUG[1]: lib_MqS__ARG_default_init                -> >>> START:                          , at<ME_NI8_MK_I64> , av<value_out> , getter<getterC> , ::Flag_onNativeDefault<false>
    |DEBUG[1]: lib_MqC__funcLST_2_funcARY__styleC       -> >>> START: LevelProc                ,
    |   DEBUG[1]: LevelProc                                -> >>> START:                          ,
  
  /// @ingroup LcConfigC_Lookup_C_API
  mk_inline enum MkErrorE LcConfigLookupInt64 (LC_CFGN config, MK_STRN path, MK_I64 *value_out) {
    LC_INSTANCE_HDL(config);
      |DEBUG[1]: lib_MqC__funcLST_2_funcARY__styleC       -> >>> START: LevelInit                ,
      |   DEBUG[1]: LevelInit                                -> >>> START:                          ,
      |   DEBUG[1]: lib_MqC__CALL__styleC                    -> >>> START:                          , argv<{ME_CCN_LcConfigC config} {ME_PSN_MK_STRN path} {ME_NI8_MK_I64 value_out}>
      |DEBUG[1]: lib_MqC__funcLST_2_funcARY__styleC       -> >>> START: LevelCode                ,
      |   DEBUG[1]: LevelCode                                -> >>> START:                          ,
      |DEBUG[1]: lib_MqC__funcLST_2_funcARY__styleC       -> >>> START: SpecialArgument          , retVal<__retVal__L> , __NAME__<LcConfigLookupInt64>
      |DEBUG[1]: lib_MqC__funcLST_2_funcARY__styleC       -> >>> START: retVal definition        , retOM<ME_ENE_MkErrorE> , ::LibAllErrorType<^ME_ENE_MkErrorE> , retVal<__retVal__L> , CALL<(enum LcErrorE)config_lookup_int64(config->nat, path, value_out)>
      |DEBUG[1]: lib_MqC__funcLST_2_funcARY__styleC       -> 111                                 , ::attributeDEF<EMPTY>
    enum LcErrorE errVal = (enum LcErrorE)config_lookup_int64(config->nat, path, value_out);
      |   DEBUG[1]: lib_MqC__Raise_Error                     -> >>> START: RaiseError               , CONFIG(JUMP_ON_ERROR)
    LcErrorE_Check(config, errVal);
      |DEBUG[1]: lib_MqC__funcLST_2_funcARY__styleC       -> >>> START: return                   , retM<void> , retOM<ME_ENE_MkErrorE> , classM<ME_CCN_LcConfigC> , ty<omo> , CALL<errVal>
    return MK_OK;
  error:
    return MK_ERROR;
  }
#endif

  |DEBUG[1]: tcl::mathfunc::checkNotIgnore            -> allow<FUPU_S>                       ,
  |   DEBUG[1]: tcl::mathfunc::checkIgnore               -> allow<FUPU_S>                       ,
lib_ME__build_CLASS_index                -> print CLASS database -> CLASS<array|P|*>
                                         ->   CLASS = <array|P|*>
                                         ->     | LcConfig   | empty
                                         ->     | LcConfigC  | empty
                                         ->     | LcSettingC | empty
lib_ME__write_funcARY                    -> Xclass<LcConfigC>
::cache::cache_open                      -> CUM -> chORfn<LcConfigC> , ext<h> , args<{} §ClassC§ LcConfigC §NS_CLS§ LC_CFG>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/LcConfigC_lc.h>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LcConfigC_lc.h>
pInclude                                 -> id<LcConfigC-fupu> , cfn<rc0> , fn<NHI1_HOME/theConfig/c/LcConfigC_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
pInclude                                 -> WARNING: outTXT is empty -> id<LcConfigC-fupu>             , ext<->               , fn<NHI1_HOME/theConfig/c/LcConfigC_lc.h>
                                         ->   Stack[2]: pInclude LcConfigC-fupu rc0 -add no ...
                                         ->     Stack[1]: lib_ME__write_funcARY -array ::fupuARY -id %CLASS%-fupu -head ...
 

'c_Overload' - Add missig functions to the given API

An "overload" is a function that adds an additional function with the same or a similar name to an existing function to represent a "function" that does not exist in the original API.

"C" requires an "overload" for :

  1. The default-argument
  2. The runtime-argument
  3. Error Handling

The default-argument is implemented in "C" using the overload-language-extension to "C" that appends the postfix _X (X=0,1,2,3,...) to the original function name to identify the number of arguments in the "overload".

Example, From the managed-object API function :
  • void MyFunc(type1 arg1, type2 arg2 __parser_(default=xyz))
the common API function :
  • void MyFunc(type1 arg1, type2 arg2)
and the 'Overload' API function :
  • #define MyFunc_1(...) MyFunc(__VA_ARGS__,xyz)
are created

The following image shows the "overload" using the verbose -v mode :

 call: 'c_Overload.tcl' '-lc' '-v'


pInit                                    -> PINIT[#0] -> +++ use              : lang<c>         : api<Overload>        : top<c_Overload.tcl>
                                         -> PINIT[#0] -> argv<-lc -v>
                                         -> PINIT[>0] -> INIT(lang)<c> : INIT(Api)<Overload> : INIT(argv)<-i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta>
                                         -> PINIT[>0] -> CONFIG(FUNCEXPR)<§undef§> : CONFIG(CLASSEXPR)<§undef§>
                                         -> PINIT[=1] -> CONFIG(PRINT)<0> : CONFIG(ONFILTER)<0> : CONFIG(ONFILTER2)<0> : CONFIG(ONVERBOSE)<1>
                                         -> PINIT[=1] -> CONFIG(LIB_BASE_DIR)<NHI1_HOME/theConfig> : CONFIG(LIBDIR)<NHI1_HOME/theConfig/c>
                                         -> PINIT[>0] -> config load          : LIB<NHI1_HOME/theCompiler/src/lib_C.tcl>
                                         -> PINIT[>0] -> config load          : LIB<NHI1_HOME/theKernel/c/compiler.tcl>
                                         -> PINIT[>0] -> config load          : LIB<NHI1_HOME/theConfig/c/compiler.tcl>
                                         -> PINIT[#1] -> call init            : top<c_Overload.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/lib_MqS.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/lib_DX.tcl>
                                         -> PINIT[#1]            : LIST
                                         ->   | info                 : +++ use
                                         ->   | IGNORE(#ignore)      : <>
                                         ->   | IGNORE(#only)        : <>
                                         ->   | IGNORE(INTERNAL)     : 0
                                         -> PINIT[#1] -> IGNORE(HIDE)<0> : ::HIDE<> : ::KEEP<>
                                         -> PINIT[#1] -> imeta<NHI1_HOME/theConfig/c/gen/c_lcconfig.meta>
                                         -> PINIT[#1] -> getterL<alias:pGet_M2L> : getterS<alias:pGet_M2S> : getterC<alias:pGet_M2S>
pEVAL                                    -> +++000 -> try native
pEVAL                                    -> +++333 -> use imeta -> imeta<NHI1_HOME/theConfig/c/gen/nat_lcconfig.meta>
pEVAL                                    -> +++333 -> use cache -> cache<NHI1_BUILD/theConfig/c/gen/nat_lcconfig.meta.compile>
p_funcEND                                -> statistics -> p_funcDEF_all<139> , p_funcDEF_use<139> , p_funcDEF_skip<0> , p_funcDEF_internal<0> , p_funcDEF_hide<0>
p_funcEND                                -> use all '139' functions
::cache::cache_open                      -> CUM -> chORfn<gen/config_overload> , ext<h> , args<package_overload_lib>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/gen/config_overload_lc.h>
lib_ME__build_CLASS_index                -> print CLASS database -> CLASS<array|P|*>
                                         ->   CLASS = <array|P|*>
                                         ->     | LcConfig   | LcConfig-Enum
                                         ->     | LcConfigC  | LcConfigC-Class-Export LcConfigC-Class-Introspection LcConfigC-Lookup LcConfigC-Misc LcConfigC-Set LcConfigC-TOR
                                         ->     | LcSettingC | LcSettingC-Class-Export LcSettingC-Class-Introspection LcSettingC-Lookup LcSettingC-Misc LcSettingC-Set
lib_ME__write_funcARY                    -> Xclass<LcConfig>
pInclude                                 -> id<LcConfig> , cfn<rc0> , fn<NHI1_HOME/theConfig/c/gen/config_overload_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | yes
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
::cache::cache_open                      -> CUM -> chORfn<rc0> , ext<-> , args<{} -create>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/gen/config_overload_lc.h>
lib_ME__write_funcARY                    -> Xclass<LcConfigC>
pInclude                                 -> id<LcConfigC> , cfn<rc0> , fn<NHI1_HOME/theConfig/c/gen/config_overload_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | yes
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
::cache::cache_open                      -> CUM -> chORfn<rc0> , ext<-> , args<{} -create>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/gen/config_overload_lc.h>
lib_ME__write_funcARY                    -> Xclass<LcSettingC>
pInclude                                 -> id<LcSettingC> , cfn<rc0> , fn<NHI1_HOME/theConfig/c/gen/config_overload_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | yes
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
::cache::cache_open                      -> CUM -> chORfn<rc0> , ext<-> , args<{} -create>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/gen/config_overload_lc.h>
::cache::cache_open                      -> CUM -> chORfn<NHI1_HOME/theConfig/c/gen/overload.index> , ext<-> , args<-create>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/gen/overload.index>
cache_close                              -> keep file -> fn<NHI1_HOME/theConfig/c/gen/config_overload_lc.h>
cache_close                              -> keep file -> fn<NHI1_HOME/theConfig/c/gen/overload.index>
 

The following image shows the "overload" of the manged-object function LcConfigLog :

 call: 'c_Overload.tcl' '-lc' '-d' '-f' 'LcConfigLog'


pInit                                    -> PINIT[#0] -> +++ use              : lang<c>         : api<Overload>        : top<c_Overload.tcl>
                                         -> PINIT[#0] -> argv<-lc -d -f LcConfigLog>
                                         -> PINIT[>0] -> INIT(lang)<c> : INIT(Api)<Overload> : INIT(argv)<-i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta>
                                         -> PINIT[>0] -> CONFIG(FUNCEXPR)<LcConfigLog> : CONFIG(CLASSEXPR)<§undef§>
                                         -> PINIT[=1] -> CONFIG(PRINT)<1> : CONFIG(ONFILTER)<1> : CONFIG(ONFILTER2)<1> : CONFIG(ONVERBOSE)<1>
                                         -> PINIT[=1] -> CONFIG(LIB_BASE_DIR)<NHI1_HOME/theConfig> : CONFIG(LIBDIR)<NHI1_HOME/theConfig/c>
                                         -> PINIT[>0] -> config load          : LIB<NHI1_HOME/theCompiler/src/lib_C.tcl>
                                         -> PINIT[>0] -> config load          : LIB<NHI1_HOME/theKernel/c/compiler.tcl>
                                         -> PINIT[>0] -> config load          : LIB<NHI1_HOME/theConfig/c/compiler.tcl>
                                         -> PINIT[#1] -> call init            : top<c_Overload.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/lib_MqS.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/lib_DX.tcl>
                                         -> PINIT[#1]            : LIST
                                         ->   | info                 : +++ use
                                         ->   | IGNORE(#ignore)      : <>
                                         ->   | IGNORE(#only)        : <>
                                         ->   | IGNORE(INTERNAL)     : 0
                                         -> PINIT[#1] -> IGNORE(HIDE)<0> : ::HIDE<> : ::KEEP<>
                                         -> PINIT[#1] -> imeta<NHI1_HOME/theConfig/c/gen/c_lcconfig.meta>
                                         -> PINIT[#1] -> getterL<alias:pGet_M2L> : getterS<alias:pGet_M2S> : getterC<alias:pGet_M2S>
  |DEBUG[1]: pEVAL                                    -> >>> START:                          , CONFIG<array|P|*> , INIT<array|P|*>
  |DEBUG[1]:                                          ->   CONFIG = <array|P|*>
  |DEBUG[1]:                                          ->     | ALLOW_argv      | no                                   | ALWAYS_DEFAULT      | no
  |DEBUG[1]:                                          ->     | ARRAY_IS_VARARG | no                                   | BROKEN_C_NAME       | no
  |DEBUG[1]:                                          ->     | CLASSEXPR       | §undef§                              | CMD                 | c_Overload.tcl
  |DEBUG[1]:                                          ->     | CMT             | //                                   | CMT_DX              | ///
  |DEBUG[1]:                                          ->     | CNs             | LcNs                                 | CODEEXT_C           | c
  |DEBUG[1]:                                          ->     | CODEEXT_N       | c                                    | CODEEXT_S           | c
  |DEBUG[1]:                                          ->     | C_API           | yes                                  | DEBUG               | 1
  |DEBUG[1]:                                          ->     | DEPENDENCY      | no                                   | DOCID               | C
  |DEBUG[1]:                                          ->     | ERASE_ALL       | no                                   | FILTER              | yes
  |DEBUG[1]:                                          ->     | FORCE           | no                                   | FRAME_CLEANUP       | no
  |DEBUG[1]:                                          ->     | FRAME_GET_ALL   | no                                   | FRAME_INIT_STACK    | no
  |DEBUG[1]:                                          ->     | FUNCEXPR        | LcConfigLog                          | HAS_CLASS           | no
  |DEBUG[1]:                                          ->     | HAS_DEFAULT_ARG | no                                   | HAS_REF_POINTER     | no
  |DEBUG[1]:                                          ->     | HAS_TYPE_FIRST  | yes                                  | JUMP_ON_ERROR       | no
  |DEBUG[1]:                                          ->     | KEYWORDS        | <>                                   | LIBDIR              | NHI1_HOME/theConfig/c
  |DEBUG[1]:                                          ->     | LIB_BASE_DIR    | NHI1_HOME/theConfig | LONG                | lc
  |DEBUG[1]:                                          ->     | LngId           | c                                    | META_FILE_EXTENSION | <>
  |DEBUG[1]:                                          ->     | META_HIDE_BEGIN | #ifndef PARSE_C_HEADER_TO_META       | META_HIDE_END       | #endif
  |DEBUG[1]:                                          ->     | ONFILTER        | 1                                    | ONFILTER2           | 1
  |DEBUG[1]:                                          ->     | ONPROFILE       | false                                | ONVERBOSE           | 1
  |DEBUG[1]:                                          ->     | OVERLOAD        | no                                   | OVERLOAD_CALL       | yes
  |DEBUG[1]:                                          ->     | OVERLOAD_NAME   | yes                                  | PRINT               | 1
  |DEBUG[1]:                                          ->     | PRINT2          | 1                                    | PROFILE_KEY         | exclusiveRuntime
  |DEBUG[1]:                                          ->     | PROFILE_PAT     | *                                    | RCNs                | @RLcNs
  |DEBUG[1]:                                          ->     | SHOW_FILTER     | no                                   | SHOW_FILTER_DETAIL  | no
  |DEBUG[1]:                                          ->     | SILENT          | 0                                    | STDOUT              | 0
  |DEBUG[1]:                                          ->     | STYLE           | C                                    | TOPLEVEL            | NHI1_HOME/theCompiler/src/c_Overload.tcl
  |DEBUG[1]:                                          ->     | USE_CALLBACK    | no                                   | USE_FINAL_NAME      | false
  |DEBUG[1]:                                          ->     | USE_NS          | no                                   | VARARG_IS_ARRAY     | no
  |DEBUG[1]:                                          ->     | VERBOSE         | 1                                    | WARNING_AS_ERROR    | no
  |DEBUG[1]:                                          ->     | WRITE           | no                                   | lng_nspkg           | c_lcconfig
  |DEBUG[1]:                                          ->   INIT = <array|P|*>
  |DEBUG[1]:                                          ->     | Api  | Overload                                     | LANG      | C
  |DEBUG[1]:                                          ->     | Ns   | Lc                                           | Prefix    | c_Overload
  |DEBUG[1]:                                          ->     | argv | -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta | example   | no
  |DEBUG[1]:                                          ->     | lang | c                                            | langid    | c
  |DEBUG[1]:                                          ->     | ns   | lc                                           | overwrite | no
pEVAL                                    -> +++000 -> try native
pEVAL                                    -> +++333 -> use imeta -> imeta<NHI1_HOME/theConfig/c/gen/nat_lcconfig.meta>
pEVAL                                    -> +++333 -> use cache -> cache<NHI1_BUILD/theConfig/c/gen/nat_lcconfig.meta.compile>
  |      DEBUG[1]: tcl::mathfunc::checkIgnore               -> allow<FUNC_M>                       ,
  |         DEBUG[1]: tcl::mathfunc::checkIgnore               -> ignore<HIDE>                        ,
  |         DEBUG[1]: tcl::mathfunc::checkNotIgnore            -> ignore<INTERNAL>                    ,
p_filter                                 -> DEBUG[#1] -> use , __NAME__<LcConfigLog>
p_funcEND                                -> statistics -> p_funcDEF_all<139> , p_funcDEF_use<1> , p_funcDEF_skip<138> , p_funcDEF_internal<0> , p_funcDEF_hide<0>
p_funcEND                                -> skip '138' from '139' functions -> p_funcDEF_use<LcConfigLog>
pEVAL                                    -> funcDEF RESULT : LcConfigLog =========================================
pEVAL                                    -> ty<om_>                        , type0M<ME_CCN_LcConfigC>       , var0<cfg>                      ,
pEVAL                                    -> retM<void>                     , retC<void>                     , retOM<void>                    ,
pEVAL                                    -> class<LcConfigC>               , classM<ME_CCN_LcConfigC>       , classC<LcConfigC>              ,
pEVAL                                    -> prefix<LcConfig>               , prefixM<ME_CCN_LcConfigC>      , prefixC<LcConfigC>             ,
pEVAL                                    -> argv<{ME_CCN_LcConfigC cfg} {ME_CCN_MkObjectC fmtobj} {ME_NI4_MK_DBG debug} {ME_PSN_MK_STRN callfunc} {ME_NI4_MK_I32 lvl}> , RETURN_MAPPING<>
pEVAL                                    -> ===================================================================
::cache::cache_open                      -> CUM -> chORfn<gen/config_overload> , ext<h> , args<package_overload_lib>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/gen/config_overload_lc.h>
  |      DEBUG[1]: tcl::mathfunc::checkIgnore               -> allow<INSTANCE>                     ,
  |      DEBUG[1]: tcl::mathfunc::checkIgnore               -> allow<STATIC>                       ,
  |   DEBUG[1]: lib_DX__getDocParameterApi               -> >>> START:                          , __NAME__<LcConfigLog>
  |      DEBUG[1]: getDocR                                  -> >>> START: doc(R)                   , __NAME__<LcConfigLog> , cls<LcConfigC> , pfx<LcConfig>
  |   DEBUG[1]: lib_DX__getDocParameterApi               -> LIST
  |   DEBUG[1]:                                          ->   | __NAME__             : LcConfigLog
  |   DEBUG[1]:                                          ->   | isDocI               : 0
  |   DEBUG[1]:                                          ->   | dR                   : Misc
  |   DEBUG[1]:                                          ->   | dRA                  : LcConfigC-Misc
  |   DEBUG[1]:                                          ->   | dI                   : _ignore_
  |   DEBUG[1]:                                          ->   | dIA                  : LcConfigC-Misc
  |   DEBUG[1]:                                          ->   | clsR                 : LcConfigC
  |   DEBUG[1]:                                          ->   | dDA                  : LcConfigC_Misc_C_API
writeARY(LcConfigC,LcConfigC-Misc,om_) =   |DEBUG[1]: c_Overload__funcLST_2_overloadARY        -> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^~ ,
  |DEBUG[1]:                                          -> +++ START +++                       , __NAME__<LcConfigLog>
  |   DEBUG[1]: tcl::mathfunc::checkNotIgnore            -> allow<OVERLOAD_DEFAULT>             ,
#define LcConfigLog_NULL(...)                                        LcConfigLog_RT(MK_RT_CALL_NULL __VA_ARGS__)
#define LcConfigLog(...)                                             LcConfigLog_RT(MK_RT_CALL __VA_ARGS__)
  |DEBUG[1]:                                          -> i<5>       , last<5>              , xcall<cfg fmtobj de~ , xarg<cfg fmtobj debug callfunc lvl>
  |DEBUG[1]: c_Overload__funcLST_2_overloadARY        -> skip                                , i<5> , last<5> , xcall<cfg fmtobj debug callfunc lvl>
  |      DEBUG[1]: lib_MqS__default                         -> >>> START:                          , a<ME_NI4_MK_I32 lvl> , getter<getterS>
  |DEBUG[1]:                                          -> i<4>       , last<5>              , xcall<cfg fmtobj de~ , xarg<cfg fmtobj debug callfunc 0>
#define LcConfigLog_4(cfg,fmtobj,debug,callfunc)                     LcConfigLog(cfg,fmtobj,debug,callfunc,0)
  |      DEBUG[1]: lib_MqS__default                         -> >>> START:                          , a<ME_PSN_MK_STRN callfunc> , getter<getterS>
  |      DEBUG[1]: lib_MqS__default                         -> >>> START:                          , a<ME_NI4_MK_I32 lvl> , getter<getterS>
  |DEBUG[1]:                                          -> i<3>       , last<4>              , xcall<cfg fmtobj de~ , xarg<cfg fmtobj debug __func__ 0>
#define LcConfigLog_3(cfg,fmtobj,debug)                              LcConfigLog(cfg,fmtobj,debug,__func__,0)
  |      DEBUG[1]: lib_MqS__default                         -> >>> START:                          , a<ME_NI4_MK_DBG debug> , getter<getterS>
  |      DEBUG[1]: lib_MqS__default                         -> >>> START:                          , a<ME_PSN_MK_STRN callfunc> , getter<getterS>
  |      DEBUG[1]: lib_MqS__default                         -> >>> START:                          , a<ME_NI4_MK_I32 lvl> , getter<getterS>
  |DEBUG[1]:                                          -> i<2>       , last<3>              , xcall<cfg fmtobj>    , xarg<cfg fmtobj 0 __func__ 0>
#define LcConfigLog_2(cfg,fmtobj)                                    LcConfigLog(cfg,fmtobj,0,__func__,0)
  |      DEBUG[1]: lib_MqS__default                         -> >>> START:                          , a<ME_CCN_MkObjectC fmtobj> , getter<getterS>
  |      DEBUG[1]: lib_MqS__default                         -> >>> START:                          , a<ME_NI4_MK_DBG debug> , getter<getterS>
  |      DEBUG[1]: lib_MqS__default                         -> >>> START:                          , a<ME_PSN_MK_STRN callfunc> , getter<getterS>
  |      DEBUG[1]: lib_MqS__default                         -> >>> START:                          , a<ME_NI4_MK_I32 lvl> , getter<getterS>
  |DEBUG[1]:                                          -> i<1>       , last<2>              , xcall<cfg>           , xarg<cfg NULL 0 __func__ 0>
#define LcConfigLog_1(cfg)                                           LcConfigLog(cfg,NULL,0,__func__,0)
  |      DEBUG[1]: lib_MqS__default                         -> >>> START:                          , a<ME_CCN_MkObjectC fmtobj> , getter<getterS>
  |      DEBUG[1]: lib_MqS__default                         -> >>> START:                          , a<ME_NI4_MK_DBG debug> , getter<getterS>
  |      DEBUG[1]: lib_MqS__default                         -> >>> START:                          , a<ME_PSN_MK_STRN callfunc> , getter<getterS>
  |      DEBUG[1]: lib_MqS__default                         -> >>> START:                          , a<ME_NI4_MK_I32 lvl> , getter<getterS>
  |DEBUG[1]:                                          -> i<0>       , last<1>              , xcall<cfg>           , xarg<cfg NULL 0 __func__ 0>
  |DEBUG[1]: c_Overload__funcLST_2_overloadARY        -> skip                                , i<0> , last<1> , xcall<cfg>
  |   DEBUG[1]: tcl::mathfunc::checkNotIgnore            -> allow<OVERLOAD_ERROR>               ,

lib_ME__build_CLASS_index                -> print CLASS database -> CLASS<array|P|*>
                                         ->   CLASS = <array|P|*>
                                         ->     | LcConfig   | empty
                                         ->     | LcConfigC  | LcConfigC-Misc
                                         ->     | LcSettingC | empty
lib_ME__write_funcARY                    -> Xclass<LcConfigC>
lib_ME__doc_start                        -> DEBUG[#1] -> Xclass<LcConfigC> , doc(DA)<LcConfigC_Misc_C_API> , CONFIG(DOCID)<C> , PN<LcConfigC_Misc_C_API>
lib_ME__doc_start                        -> DEBUG[#1] -> doc<array|P|*>
                                         ->   doc = <array|P|*>
                                         ->     | DA    | LcConfigC_Misc_C_API
                                         ->     | I     | _ignore_
                                         ->     | IA    | LcConfigC-Misc
                                         ->     | N     | LcConfigC - LcConfigC_Misc_C_API
                                         ->     | NA    | LcConfigC_C_API
                                         ->     | R     | Misc
                                         ->     | RA    | LcConfigC-Misc
                                         ->     | clsR  | LcConfigC
                                         ->     | isIdx | 0
                                         ->     | isN   | 0
pInclude                                 -> id<LcConfigC> , cfn<rc0> , fn<NHI1_HOME/theConfig/c/gen/config_overload_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | yes
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
  
  /// @addtogroup LcConfigC_Misc_C_API
  /// @{
  /// @name LcConfigC - LcConfigC_Misc_C_API - overload
  /// @{
  
  // doc-key: LcConfigC,LcConfigC-Misc,om_
    |DEBUG[1]: c_Overload__funcLST_2_overloadARY        -> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^~ ,
    |DEBUG[1]:                                          -> +++ START +++                       , __NAME__<LcConfigLog>
    |   DEBUG[1]: tcl::mathfunc::checkNotIgnore            -> allow<OVERLOAD_DEFAULT>             ,
  #define LcConfigLog_NULL(...)                                        LcConfigLog_RT(MK_RT_CALL_NULL __VA_ARGS__)
  #define LcConfigLog(...)                                             LcConfigLog_RT(MK_RT_CALL __VA_ARGS__)
    |DEBUG[1]:                                          -> i<5>       , last<5>              , xcall<cfg fmtobj de~ , xarg<cfg fmtobj debug callfunc lvl>
    |DEBUG[1]: c_Overload__funcLST_2_overloadARY        -> skip                                , i<5> , last<5> , xcall<cfg fmtobj debug callfunc lvl>
    |      DEBUG[1]: lib_MqS__default                         -> >>> START:                          , a<ME_NI4_MK_I32 lvl> , getter<getterS>
    |DEBUG[1]:                                          -> i<4>       , last<5>              , xcall<cfg fmtobj de~ , xarg<cfg fmtobj debug callfunc 0>
  #define LcConfigLog_4(cfg,fmtobj,debug,callfunc)                     LcConfigLog(cfg,fmtobj,debug,callfunc,0)
    |      DEBUG[1]: lib_MqS__default                         -> >>> START:                          , a<ME_PSN_MK_STRN callfunc> , getter<getterS>
    |      DEBUG[1]: lib_MqS__default                         -> >>> START:                          , a<ME_NI4_MK_I32 lvl> , getter<getterS>
    |DEBUG[1]:                                          -> i<3>       , last<4>              , xcall<cfg fmtobj de~ , xarg<cfg fmtobj debug __func__ 0>
  #define LcConfigLog_3(cfg,fmtobj,debug)                              LcConfigLog(cfg,fmtobj,debug,__func__,0)
    |      DEBUG[1]: lib_MqS__default                         -> >>> START:                          , a<ME_NI4_MK_DBG debug> , getter<getterS>
    |      DEBUG[1]: lib_MqS__default                         -> >>> START:                          , a<ME_PSN_MK_STRN callfunc> , getter<getterS>
    |      DEBUG[1]: lib_MqS__default                         -> >>> START:                          , a<ME_NI4_MK_I32 lvl> , getter<getterS>
    |DEBUG[1]:                                          -> i<2>       , last<3>              , xcall<cfg fmtobj>    , xarg<cfg fmtobj 0 __func__ 0>
  #define LcConfigLog_2(cfg,fmtobj)                                    LcConfigLog(cfg,fmtobj,0,__func__,0)
    |      DEBUG[1]: lib_MqS__default                         -> >>> START:                          , a<ME_CCN_MkObjectC fmtobj> , getter<getterS>
    |      DEBUG[1]: lib_MqS__default                         -> >>> START:                          , a<ME_NI4_MK_DBG debug> , getter<getterS>
    |      DEBUG[1]: lib_MqS__default                         -> >>> START:                          , a<ME_PSN_MK_STRN callfunc> , getter<getterS>
    |      DEBUG[1]: lib_MqS__default                         -> >>> START:                          , a<ME_NI4_MK_I32 lvl> , getter<getterS>
    |DEBUG[1]:                                          -> i<1>       , last<2>              , xcall<cfg>           , xarg<cfg NULL 0 __func__ 0>
  #define LcConfigLog_1(cfg)                                           LcConfigLog(cfg,NULL,0,__func__,0)
    |      DEBUG[1]: lib_MqS__default                         -> >>> START:                          , a<ME_CCN_MkObjectC fmtobj> , getter<getterS>
    |      DEBUG[1]: lib_MqS__default                         -> >>> START:                          , a<ME_NI4_MK_DBG debug> , getter<getterS>
    |      DEBUG[1]: lib_MqS__default                         -> >>> START:                          , a<ME_PSN_MK_STRN callfunc> , getter<getterS>
    |      DEBUG[1]: lib_MqS__default                         -> >>> START:                          , a<ME_NI4_MK_I32 lvl> , getter<getterS>
    |DEBUG[1]:                                          -> i<0>       , last<1>              , xcall<cfg>           , xarg<cfg NULL 0 __func__ 0>
    |DEBUG[1]: c_Overload__funcLST_2_overloadARY        -> skip                                , i<0> , last<1> , xcall<cfg>
    |   DEBUG[1]: tcl::mathfunc::checkNotIgnore            -> allow<OVERLOAD_ERROR>               ,
  /// @}
  /// @}

::cache::cache_open                      -> CUM -> chORfn<NHI1_HOME/theConfig/c/gen/overload.index> , ext<-> , args<-create>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/gen/overload.index>
 

'c_MqS' - Add missing declarations to the Managed-Object-API

The c_MqS exists for every programming language, where the "c" is replaced by the respective language abbreviation (e.g. tcl_MqS.tcl) and is used to declare the api.

‍A declaration can be an object (e.g. enum) or a function.

The X_MqS really shows its importance with the NONE-"C" language connection, where, for example, the interpreter interface is defined using X_MqS or a translation layer for data types (C#).

Usually the X_MqS does not write any code but only code references or code declarations, the code itself is written in X_MqC.

 call: 'c_MqS.tcl' '-lc' '-v'


pInit                                    -> PINIT[#0] -> +++ use              : lang<c>         : api<MqS>             : top<c_MqS.tcl>
                                         -> PINIT[#0] -> argv<-lc -v>
                                         -> PINIT[>0] -> INIT(lang)<c> : INIT(Api)<MqS> : INIT(argv)<-i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta>
                                         -> PINIT[>0] -> CONFIG(FUNCEXPR)<§undef§> : CONFIG(CLASSEXPR)<§undef§>
                                         -> PINIT[=1] -> CONFIG(PRINT)<0> : CONFIG(ONFILTER)<0> : CONFIG(ONFILTER2)<0> : CONFIG(ONVERBOSE)<1>
                                         -> PINIT[=1] -> CONFIG(LIB_BASE_DIR)<NHI1_HOME/theConfig> : CONFIG(LIBDIR)<NHI1_HOME/theConfig/c>
                                         -> PINIT[>0] -> config load          : LIB<NHI1_HOME/theCompiler/src/lib_C.tcl>
                                         -> PINIT[>0] -> config load          : LIB<NHI1_HOME/theKernel/c/compiler.tcl>
                                         -> PINIT[>0] -> config load          : LIB<NHI1_HOME/theConfig/c/compiler.tcl>
                                         -> PINIT[#1] -> call init            : top<c_MqS.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/lib_MqS.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/lib_DX.tcl>
                                         -> PINIT[#1]            : LIST
                                         ->   | info                 : +++ use
                                         ->   | IGNORE(#ignore)      : <>
                                         ->   | IGNORE(#only)        : <>
                                         ->   | IGNORE(INTERNAL)     : 0
                                         -> PINIT[#1] -> IGNORE(HIDE)<0> : ::HIDE<> : ::KEEP<>
                                         -> PINIT[#1] -> imeta<NHI1_HOME/theConfig/c/gen/c_lcconfig.meta>
                                         -> PINIT[#1] -> getterL<alias:pGet_M2L> : getterS<alias:pGet_M2S> : getterC<alias:pGet_M2S>
pEVAL                                    -> +++000 -> try native
pEVAL                                    -> +++333 -> use imeta -> imeta<NHI1_HOME/theConfig/c/gen/nat_lcconfig.meta>
pEVAL                                    -> +++333 -> use cache -> cache<NHI1_BUILD/theConfig/c/gen/nat_lcconfig.meta.compile>
p_funcEND                                -> statistics -> p_funcDEF_all<126> , p_funcDEF_use<126> , p_funcDEF_skip<0> , p_funcDEF_internal<13> , p_funcDEF_hide<0>
p_funcEND                                -> use all '126' functions
::cache::cache_open                      -> CUM -> chORfn<LcEnum> , ext<h> , args<>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/LcEnum_lc.h>
pInclude                                 -> id<LcErrorTypeE> , cfn<rc0> , fn<NHI1_HOME/theConfig/c/LcEnum_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
::cache::cache_open                      -> CUM -> chORfn<rc0> , ext<-> , args<{}>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LcEnum_lc.h>
pInclude                                 -> id<LcConfigTypeE> , cfn<rc0> , fn<NHI1_HOME/theConfig/c/LcEnum_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
::cache::cache_open                      -> CUM -> chORfn<rc0> , ext<-> , args<{}>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LcEnum_lc.h>
pInclude                                 -> id<LcConfigOptionsEF> , cfn<rc0> , fn<NHI1_HOME/theConfig/c/LcEnum_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
::cache::cache_open                      -> CUM -> chORfn<rc0> , ext<-> , args<{}>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LcEnum_lc.h>
pInclude                                 -> id<LcErrorE> , cfn<rc0> , fn<NHI1_HOME/theConfig/c/LcEnum_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
::cache::cache_open                      -> CUM -> chORfn<rc0> , ext<-> , args<{}>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LcEnum_lc.h>
pInclude                                 -> id<LcConfigFormatE> , cfn<rc0> , fn<NHI1_HOME/theConfig/c/LcEnum_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
::cache::cache_open                      -> CUM -> chORfn<rc0> , ext<-> , args<{}>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LcEnum_lc.h>
cache_close                              -> keep file -> fn<NHI1_HOME/theConfig/c/LcEnum_lc.h>
 

The following image shows the "declaration" of the manged-object callback for enum LcConfigFormatE :

 call: 'c_MqS.tcl' '-lc' '-d' '-f' 'LcConfigFormatE'


pInit                                    -> PINIT[#0] -> +++ use              : lang<c>         : api<MqS>             : top<c_MqS.tcl>
                                         -> PINIT[#0] -> argv<-lc -d -f LcConfigFormatE>
                                         -> PINIT[>0] -> INIT(lang)<c> : INIT(Api)<MqS> : INIT(argv)<-i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta>
                                         -> PINIT[>0] -> CONFIG(FUNCEXPR)<LcConfigFormatE> : CONFIG(CLASSEXPR)<§undef§>
                                         -> PINIT[=1] -> CONFIG(PRINT)<1> : CONFIG(ONFILTER)<1> : CONFIG(ONFILTER2)<1> : CONFIG(ONVERBOSE)<1>
                                         -> PINIT[=1] -> CONFIG(LIB_BASE_DIR)<NHI1_HOME/theConfig> : CONFIG(LIBDIR)<NHI1_HOME/theConfig/c>
                                         -> PINIT[>0] -> config load          : LIB<NHI1_HOME/theCompiler/src/lib_C.tcl>
                                         -> PINIT[>0] -> config load          : LIB<NHI1_HOME/theKernel/c/compiler.tcl>
                                         -> PINIT[>0] -> config load          : LIB<NHI1_HOME/theConfig/c/compiler.tcl>
                                         -> PINIT[#1] -> call init            : top<c_MqS.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/lib_MqS.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/lib_DX.tcl>
                                         -> PINIT[#1]            : LIST
                                         ->   | info                 : +++ use
                                         ->   | IGNORE(#ignore)      : <>
                                         ->   | IGNORE(#only)        : <>
                                         ->   | IGNORE(INTERNAL)     : 0
                                         -> PINIT[#1] -> IGNORE(HIDE)<0> : ::HIDE<> : ::KEEP<>
                                         -> PINIT[#1] -> imeta<NHI1_HOME/theConfig/c/gen/c_lcconfig.meta>
                                         -> PINIT[#1] -> getterL<alias:pGet_M2L> : getterS<alias:pGet_M2S> : getterC<alias:pGet_M2S>
  |DEBUG[1]: pEVAL                                    -> >>> START:                          , CONFIG<array|P|*> , INIT<array|P|*>
  |DEBUG[1]:                                          ->   CONFIG = <array|P|*>
  |DEBUG[1]:                                          ->     | ALLOW_argv      | no                                   | ALWAYS_DEFAULT      | no
  |DEBUG[1]:                                          ->     | ARRAY_IS_VARARG | no                                   | BROKEN_C_NAME       | no
  |DEBUG[1]:                                          ->     | CLASSEXPR       | §undef§                              | CMD                 | c_MqS.tcl
  |DEBUG[1]:                                          ->     | CMT             | //                                   | CMT_DX              | ///
  |DEBUG[1]:                                          ->     | CNs             | LcNs                                 | CODEEXT_C           | c
  |DEBUG[1]:                                          ->     | CODEEXT_N       | c                                    | CODEEXT_S           | c
  |DEBUG[1]:                                          ->     | C_API           | yes                                  | DEBUG               | 1
  |DEBUG[1]:                                          ->     | DEPENDENCY      | no                                   | DOCID               | C
  |DEBUG[1]:                                          ->     | ERASE_ALL       | no                                   | FILTER              | yes
  |DEBUG[1]:                                          ->     | FORCE           | no                                   | FRAME_CLEANUP       | no
  |DEBUG[1]:                                          ->     | FRAME_GET_ALL   | no                                   | FRAME_INIT_STACK    | no
  |DEBUG[1]:                                          ->     | FUNCEXPR        | LcConfigFormatE                      | HAS_CLASS           | no
  |DEBUG[1]:                                          ->     | HAS_DEFAULT_ARG | no                                   | HAS_REF_POINTER     | no
  |DEBUG[1]:                                          ->     | HAS_TYPE_FIRST  | yes                                  | JUMP_ON_ERROR       | no
  |DEBUG[1]:                                          ->     | KEYWORDS        | <>                                   | LIBDIR              | NHI1_HOME/theConfig/c
  |DEBUG[1]:                                          ->     | LIB_BASE_DIR    | NHI1_HOME/theConfig | LONG                | lc
  |DEBUG[1]:                                          ->     | LngId           | c                                    | META_FILE_EXTENSION | <>
  |DEBUG[1]:                                          ->     | META_HIDE_BEGIN | #ifndef PARSE_C_HEADER_TO_META       | META_HIDE_END       | #endif
  |DEBUG[1]:                                          ->     | ONFILTER        | 1                                    | ONFILTER2           | 1
  |DEBUG[1]:                                          ->     | ONPROFILE       | false                                | ONVERBOSE           | 1
  |DEBUG[1]:                                          ->     | OVERLOAD        | no                                   | OVERLOAD_CALL       | yes
  |DEBUG[1]:                                          ->     | OVERLOAD_NAME   | yes                                  | PRINT               | 1
  |DEBUG[1]:                                          ->     | PRINT2          | 1                                    | PROFILE_KEY         | exclusiveRuntime
  |DEBUG[1]:                                          ->     | PROFILE_PAT     | *                                    | RCNs                | @RLcNs
  |DEBUG[1]:                                          ->     | SHOW_FILTER     | no                                   | SHOW_FILTER_DETAIL  | no
  |DEBUG[1]:                                          ->     | SILENT          | 0                                    | STDOUT              | 0
  |DEBUG[1]:                                          ->     | STYLE           | C                                    | TOPLEVEL            | NHI1_HOME/theCompiler/src/c_MqS.tcl
  |DEBUG[1]:                                          ->     | USE_CALLBACK    | no                                   | USE_FINAL_NAME      | false
  |DEBUG[1]:                                          ->     | USE_NS          | no                                   | VARARG_IS_ARRAY     | no
  |DEBUG[1]:                                          ->     | VERBOSE         | 1                                    | WARNING_AS_ERROR    | no
  |DEBUG[1]:                                          ->     | WRITE           | no                                   | lng_nspkg           | c_lcconfig
  |DEBUG[1]:                                          ->   INIT = <array|P|*>
  |DEBUG[1]:                                          ->     | Api  | MqS                                          | LANG      | C
  |DEBUG[1]:                                          ->     | Ns   | Lc                                           | Prefix    | c_MqS
  |DEBUG[1]:                                          ->     | argv | -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta | example   | no
  |DEBUG[1]:                                          ->     | lang | c                                            | langid    | c
  |DEBUG[1]:                                          ->     | ns   | lc                                           | overwrite | no
pEVAL                                    -> +++000 -> try native
pEVAL                                    -> +++333 -> use imeta -> imeta<NHI1_HOME/theConfig/c/gen/nat_lcconfig.meta>
pEVAL                                    -> +++333 -> use cache -> cache<NHI1_BUILD/theConfig/c/gen/nat_lcconfig.meta.compile>
  |            DEBUG[1]: tcl::mathfunc::checkIgnore               -> allow<ENUM_S>                       ,
p_filter                                 -> DEBUG[#1] -> use , __NAME__<LcConfigFormatE>
  |      DEBUG[1]: tcl::mathfunc::checkIgnore               -> allow<FUNC_M>                       ,
  |         DEBUG[1]: tcl::mathfunc::checkIgnore               -> ignore<HIDE>                        ,
  |         DEBUG[1]: tcl::mathfunc::checkNotIgnore            -> allow<INTERNAL>                     ,
p_filter                                 -> DEBUG[#1] -> use , __NAME__<LcConfigFormatE_FromInt>
p_filter                                 -> DEBUG[#1] -> use , __NAME__<LcConfigFormatE_ToInt>
p_filter                                 -> DEBUG[#1] -> use , __NAME__<LcConfigFormatE_ToString>
p_funcEND                                -> statistics -> p_funcDEF_all<126> , p_funcDEF_use<3> , p_funcDEF_skip<123> , p_funcDEF_internal<13> , p_funcDEF_hide<0>
p_funcEND                                -> skip '123' from '126' functions -> p_funcDEF_use<LcConfigFormatE_FromInt LcConfigFormatE_ToInt LcConfigFormatE_ToString>
pEVAL                                    -> funcDEF RESULT : LcConfigFormatE_FromInt =========================================
pEVAL                                    -> ty<sco>                        , type0M<ME_NI4_MK_I32>          , var0<value>                    ,
pEVAL                                    -> retM<ME_ENE_MkErrorE>          , retC<MkErrorE>                 , retOM<ME_ENE_MkErrorE>         ,
pEVAL                                    -> class<LcConfig>                , classM<LcConfig>               , classC<LcConfig>               ,
pEVAL                                    -> prefix<EnumFunc>               , prefixM<LcConfig>              , prefixC<EnumFuncC>             ,
pEVAL                                    -> argv<{ME_NI4_MK_I32 value} {ME_ENE_LcConfigFormatE value_out}> , RETURN_MAPPING<>
pEVAL                                    -> ===================================================================
pEVAL                                    -> funcDEF RESULT : LcConfigFormatE_ToInt =========================================
pEVAL                                    -> ty<sm_>                        , type0M<ME_ENE_LcConfigFormatE~ , var0<value>                    ,
pEVAL                                    -> retM<ME_NI4_MK_I32>            , retC<MK_I32>                   , retOM<ME_NI4_MK_I32>           ,
pEVAL                                    -> class<LcConfig>                , classM<LcConfig>               , classC<LcConfig>               ,
pEVAL                                    -> prefix<EnumFunc>               , prefixM<LcConfig>              , prefixC<EnumFuncC>             ,
pEVAL                                    -> argv<{ME_ENE_LcConfigFormatE value}> , RETURN_MAPPING<>
pEVAL                                    -> ===================================================================
pEVAL                                    -> funcDEF RESULT : LcConfigFormatE_ToString =========================================
pEVAL                                    -> ty<sm_>                        , type0M<ME_ENE_LcConfigFormatE~ , var0<value>                    ,
pEVAL                                    -> retM<ME_PSN_MK_STRN>           , retC<MK_STRN>                  , retOM<ME_PSN_MK_STRN>          ,
pEVAL                                    -> class<LcConfig>                , classM<LcConfig>               , classC<LcConfig>               ,
pEVAL                                    -> prefix<EnumFunc>               , prefixM<LcConfig>              , prefixC<EnumFuncC>             ,
pEVAL                                    -> argv<{ME_ENE_LcConfigFormatE value}> , RETURN_MAPPING<>
pEVAL                                    -> ===================================================================
  |DEBUG[1]: tcl::mathfunc::checkNotIgnore            -> allow<ENUM_S>                       ,
::cache::cache_open                      -> CUM -> chORfn<LcEnum> , ext<h> , args<>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/LcEnum_lc.h>
pInclude                                 -> id<LcConfigFormatE> , cfn<rc0> , fn<NHI1_HOME/theConfig/c/LcEnum_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>

/// @ingroup LcConfig_Enum_C_API
/// @brief return the @RLcNs{ConfigFormatE} as string …
__parser__(doc-group=Enum,doc-index=_ignore_,class=LcConfig,no-rpc,prefix=EnumFunc,return-type-default-no)
LC_EXTERN MK_STRN MK_DECL LcConfigFormatE_ToString  ( enum LcConfigFormatE value ) LC_ATTR_CLASS ;

/// @ingroup LcConfig_Enum_C_API
/// @brief return the @RLcNs{ConfigFormatE} as integer …
__parser__(doc-group=Enum,doc-index=_ignore_,class=LcConfig,no-rpc,prefix=EnumFunc,return-type-default-no)
LC_ATTR_CLASS
mk_inline MK_I32 LcConfigFormatE_ToInt ( enum LcConfigFormatE value ) {
  return (MK_I32) value;
}

/// @ingroup LcConfig_Enum_C_API
/// @brief return the @RLcNs{ConfigFormatE} from integer …
__parser__(doc-group=Enum,doc-index=_ignore_,class=LcConfig,no-rpc,prefix=EnumFunc)
LC_EXTERN enum MkErrorE LcConfigFormatE_FromInt ( MK_I32 const value, enum LcConfigFormatE * value_out ) LC_ATTR_CLASS ;


 

'c_MqC' - Add missing wrapper-source-code to the Managed-Object-API

The c_MqC exists for every programming language, whereby the "c" is replaced by the respective language abbreviation (e.g. tcl_MqC.tcl).

The c_MqC is used to write the wrapper source code.

The wrapper-source-code ultimately has the task of integrating the managed-object-api-function into the target-language so that the namespace of the managed-object is valid for input and the namespace for the target-language is valid for output.

‍The integration includes the data type or the type-cast as well as the error handling.

Usually the X_MqC write wrapper-source-code :

 call: 'c_MqC.tcl' '-lc' '-v'


pInit                                    -> PINIT[#0] -> +++ use              : lang<c>         : api<MqC>             : top<c_MqC.tcl>
                                         -> PINIT[#0] -> argv<-lc -v>
                                         -> PINIT[>0] -> INIT(lang)<c> : INIT(Api)<MqC> : INIT(argv)<-i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta>
                                         -> PINIT[>0] -> CONFIG(FUNCEXPR)<§undef§> : CONFIG(CLASSEXPR)<§undef§>
                                         -> PINIT[=1] -> CONFIG(PRINT)<0> : CONFIG(ONFILTER)<0> : CONFIG(ONFILTER2)<0> : CONFIG(ONVERBOSE)<1>
                                         -> PINIT[=1] -> CONFIG(LIB_BASE_DIR)<NHI1_HOME/theConfig> : CONFIG(LIBDIR)<NHI1_HOME/theConfig/c>
                                         -> PINIT[>0] -> config load          : LIB<NHI1_HOME/theCompiler/src/lib_C.tcl>
                                         -> PINIT[>0] -> config load          : LIB<NHI1_HOME/theKernel/c/compiler.tcl>
                                         -> PINIT[>0] -> config load          : LIB<NHI1_HOME/theConfig/c/compiler.tcl>
                                         -> PINIT[#1] -> call init            : top<c_MqC.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/lib_MqC.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/lib_MqC_type_C.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/c_MqS.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/lib_MqS.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/lib_DX.tcl>
                                         -> PINIT[#1]            : LIST
                                         ->   | info                 : +++ use
                                         ->   | IGNORE(#ignore)      : <>
                                         ->   | IGNORE(#only)        : <>
                                         ->   | IGNORE(INTERNAL)     : 0
                                         -> PINIT[#1] -> IGNORE(HIDE)<0> : ::HIDE<> : ::KEEP<>
                                         -> PINIT[#1] -> imeta<NHI1_HOME/theConfig/c/gen/c_lcconfig.meta>
                                         -> PINIT[#1] -> getterL<alias:pGet_M2L> : getterS<alias:pGet_M2S> : getterC<alias:pGet_M2S>
pEVAL                                    -> +++000 -> try native
pEVAL                                    -> +++333 -> use imeta -> imeta<NHI1_HOME/theConfig/c/gen/nat_lcconfig.meta>
File_HasChanged                          -> invalid prerequisite -> chk1<2158071567 150714 NHI1_HOME/theConfig/c/gen/nat_lcconfig.meta>
pEVAL                                    -> invalid cache -> call: lng_Compile.tcl -i NHI1_HOME/theConfig/c/gen/nat_lcconfig.meta
pInit                                    -> PINIT[#0] -> +++ use              : lang<lng>       : api<Compile>         : top<lng_Compile.tcl>
                                         -> PINIT[#0] -> argv<-i NHI1_HOME/theConfig/c/gen/nat_lcconfig.meta>
GLOBAL                                   -> imeta<NHI1_HOME/theConfig/c/gen/nat_lcconfig.meta>
GLOBAL                                   -> rebuild -> cache<NHI1_BUILD/theConfig/c/gen/nat_lcconfig.meta.compile>
p_funcEND                                -> statistics -> p_funcDEF_all<139> , p_funcDEF_use<139> , p_funcDEF_skip<0> , p_funcDEF_internal<0> , p_funcDEF_hide<0>
cache_close                              -> write file -> fn<NHI1_BUILD/theConfig/c/gen/nat_lcconfig.meta.compile>
pEVAL                                    -> +++333 -> use cache -> cache<NHI1_BUILD/theConfig/c/gen/nat_lcconfig.meta.compile>
p_funcEND                                -> statistics -> p_funcDEF_all<126> , p_funcDEF_use<126> , p_funcDEF_skip<0> , p_funcDEF_internal<13> , p_funcDEF_hide<0>
p_funcEND                                -> use all '126' functions
::cache::cache_open                      -> CUM -> chORfn<LcConfig> , ext<c> , args<LibNsPkg_lib>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.c>
pInclude                                 -> id<Enum-ToString> , cfn<rc0> , fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.c> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
::cache::cache_open                      -> CUM -> chORfn<rc0> , ext<-> , args<{}>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.c>
pInclude                                 -> id<Enum-FromInt> , cfn<rc0> , fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.c> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
::cache::cache_open                      -> CUM -> chORfn<rc0> , ext<-> , args<{}>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.c>
::cache::cache_open                      -> CUM -> chORfn<gen/config_inline> , ext<h> , args<package_inline_lib>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/gen/config_inline_lc.h>
::cache::cache_open                      -> CUM -> chORfn<tempfile> , ext<1> , args<>
lib_ME__build_CLASS_index                -> print CLASS database -> CLASS<array|P|*>
                                         ->   CLASS = <array|P|*>
                                         ->     | LcConfig   | LcConfig-Enum
                                         ->     | LcConfigC  | LcConfigC-Class-Define LcConfigC-Class-Export LcConfigC-Class-Introspection LcConfigC-Class-Misc LcConfigC-Error LcConfigC-Get LcConfigC-Lookup LcConfigC-Misc LcConfigC-Set LcConfigC-TOR
                                         ->     | LcSettingC | LcSettingC-Class-Define LcSettingC-Class-Export LcSettingC-Class-Introspection LcSettingC-Class-Misc LcSettingC-Get LcSettingC-Is LcSettingC-Lookup LcSettingC-Misc LcSettingC-Set LcSettingC-TOR
lib_ME__write_funcARY                    -> Xclass<LcConfig>
pInclude                                 -> id<LcConfig> , cfn<rc4> , fn<tempfile-1> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | yes
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
::cache::cache_open                      -> CUM -> chORfn<rc4> , ext<-> , args<{} -create>
cache_open                               -> open from cache -> fn<tempfile-1>
lib_ME__write_funcARY                    -> Xclass<LcConfigC>
pInclude                                 -> id<LcConfigC> , cfn<rc4> , fn<tempfile-1> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | yes
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
::cache::cache_open                      -> CUM -> chORfn<rc4> , ext<-> , args<{} -create>
cache_open                               -> open from cache -> fn<tempfile-1>
lib_ME__write_funcARY                    -> Xclass<LcSettingC>
pInclude                                 -> id<LcSettingC> , cfn<rc4> , fn<tempfile-1> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | yes
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
::cache::cache_open                      -> CUM -> chORfn<rc4> , ext<-> , args<{} -create>
cache_open                               -> open from cache -> fn<tempfile-1>
pInclude                                 -> id<inline> , cfn<rc2> , fn<NHI1_HOME/theConfig/c/gen/config_inline_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
::cache::cache_open                      -> CUM -> chORfn<rc2> , ext<-> , args<{}>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/gen/config_inline_lc.h>
::cache::cache_open                      -> CUM -> chORfn<gen/config_inline> , ext<c> , args<package_inline_lib §header§ config_inline_lc.h>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/gen/config_inline_lc.c>
::cache::cache_open                      -> CUM -> chORfn<tempfile> , ext<1> , args<>
lib_ME__build_CLASS_index                -> print CLASS database -> CLASS<array|P|*>
                                         ->   CLASS = <array|P|*>
                                         ->     | LcConfig   | LcConfig-Enum
                                         ->     | LcConfigC  | LcConfigC-Class-Define LcConfigC-Class-Export LcConfigC-Class-Introspection LcConfigC-Class-Misc LcConfigC-Error LcConfigC-Get LcConfigC-Lookup LcConfigC-Misc LcConfigC-Set LcConfigC-TOR
                                         ->     | LcSettingC | LcSettingC-Class-Define LcSettingC-Class-Export LcSettingC-Class-Introspection LcSettingC-Class-Misc LcSettingC-Get LcSettingC-Is LcSettingC-Lookup LcSettingC-Misc LcSettingC-Set LcSettingC-TOR
lib_ME__write_funcARY                    -> Xclass<LcConfig>
pInclude                                 -> id<LcConfig> , cfn<rc8> , fn<tempfile-1> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | yes
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
::cache::cache_open                      -> CUM -> chORfn<rc8> , ext<-> , args<{} -create>
cache_open                               -> open from cache -> fn<tempfile-1>
lib_ME__write_funcARY                    -> Xclass<LcConfigC>
pInclude                                 -> id<LcConfigC> , cfn<rc8> , fn<tempfile-1> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | yes
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
::cache::cache_open                      -> CUM -> chORfn<rc8> , ext<-> , args<{} -create>
cache_open                               -> open from cache -> fn<tempfile-1>
lib_ME__write_funcARY                    -> Xclass<LcSettingC>
pInclude                                 -> id<LcSettingC> , cfn<rc8> , fn<tempfile-1> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | yes
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
::cache::cache_open                      -> CUM -> chORfn<rc8> , ext<-> , args<{} -create>
cache_open                               -> open from cache -> fn<tempfile-1>
pInclude                                 -> id<inline> , cfn<rc6> , fn<NHI1_HOME/theConfig/c/gen/config_inline_lc.c> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
::cache::cache_open                      -> CUM -> chORfn<rc6> , ext<-> , args<{}>
cache_open                               -> open from cache -> fn<NHI1_HOME/theConfig/c/gen/config_inline_lc.c>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/private_lc.h>
tmpl_make_from_file                      -> keep file -> fn<NHI1_HOME/theConfig/c/private_lc.h>
cache_close                              -> keep file -> fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.c>
cache_close                              -> keep file -> fn<NHI1_HOME/theConfig/c/gen/config_inline_lc.h>
cache_close                              -> keep file -> fn<NHI1_HOME/theConfig/c/gen/config_inline_lc.c>
 

The following image shows the C-wrapper-source-code of the manged-object LcConfigLookupInt64 :

 call: 'c_MqC.tcl' '-lc' '-d' '-f' 'LcConfigLookupInt64'


pInit                                    -> PINIT[#0] -> +++ use              : lang<c>         : api<MqC>             : top<c_MqC.tcl>
                                         -> PINIT[#0] -> argv<-lc -d -f LcConfigLookupInt64>
                                         -> PINIT[>0] -> INIT(lang)<c> : INIT(Api)<MqC> : INIT(argv)<-i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta>
                                         -> PINIT[>0] -> CONFIG(FUNCEXPR)<LcConfigLookupInt64> : CONFIG(CLASSEXPR)<§undef§>
                                         -> PINIT[=1] -> CONFIG(PRINT)<1> : CONFIG(ONFILTER)<1> : CONFIG(ONFILTER2)<1> : CONFIG(ONVERBOSE)<1>
                                         -> PINIT[=1] -> CONFIG(LIB_BASE_DIR)<NHI1_HOME/theConfig> : CONFIG(LIBDIR)<NHI1_HOME/theConfig/c>
                                         -> PINIT[>0] -> config load          : LIB<NHI1_HOME/theCompiler/src/lib_C.tcl>
                                         -> PINIT[>0] -> config load          : LIB<NHI1_HOME/theKernel/c/compiler.tcl>
                                         -> PINIT[>0] -> config load          : LIB<NHI1_HOME/theConfig/c/compiler.tcl>
                                         -> PINIT[#1] -> call init            : top<c_MqC.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/lib_MqC.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/lib_MqC_type_C.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/c_MqS.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/lib_MqS.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/lib_DX.tcl>
                                         -> PINIT[#1]            : LIST
                                         ->   | info                 : +++ use
                                         ->   | IGNORE(#ignore)      : <>
                                         ->   | IGNORE(#only)        : <>
                                         ->   | IGNORE(INTERNAL)     : 0
                                         -> PINIT[#1] -> IGNORE(HIDE)<0> : ::HIDE<> : ::KEEP<>
                                         -> PINIT[#1] -> imeta<NHI1_HOME/theConfig/c/gen/c_lcconfig.meta>
                                         -> PINIT[#1] -> getterL<alias:pGet_M2L> : getterS<alias:pGet_M2S> : getterC<alias:pGet_M2S>
  |DEBUG[1]: pEVAL                                    -> >>> START:                          , CONFIG<array|P|*> , INIT<array|P|*>
  |DEBUG[1]:                                          ->   CONFIG = <array|P|*>
  |DEBUG[1]:                                          ->     | ALLOW_argv      | no                                   | ALWAYS_DEFAULT      | no
  |DEBUG[1]:                                          ->     | ARRAY_IS_VARARG | no                                   | BROKEN_C_NAME       | no
  |DEBUG[1]:                                          ->     | CLASSEXPR       | §undef§                              | CMD                 | c_MqC.tcl
  |DEBUG[1]:                                          ->     | CMT             | //                                   | CMT_DX              | ///
  |DEBUG[1]:                                          ->     | CNs             | LcNs                                 | CODEEXT_C           | c
  |DEBUG[1]:                                          ->     | CODEEXT_N       | c                                    | CODEEXT_S           | c
  |DEBUG[1]:                                          ->     | C_API           | yes                                  | DEBUG               | 1
  |DEBUG[1]:                                          ->     | DEPENDENCY      | no                                   | DOCID               | C
  |DEBUG[1]:                                          ->     | ERASE_ALL       | no                                   | FILTER              | yes
  |DEBUG[1]:                                          ->     | FORCE           | no                                   | FRAME_CLEANUP       | no
  |DEBUG[1]:                                          ->     | FRAME_GET_ALL   | no                                   | FRAME_INIT_STACK    | no
  |DEBUG[1]:                                          ->     | FUNCEXPR        | LcConfigLookupInt64                  | HAS_CLASS           | no
  |DEBUG[1]:                                          ->     | HAS_DEFAULT_ARG | no                                   | HAS_REF_POINTER     | no
  |DEBUG[1]:                                          ->     | HAS_TYPE_FIRST  | yes                                  | JUMP_ON_ERROR       | no
  |DEBUG[1]:                                          ->     | KEYWORDS        | <>                                   | LIBDIR              | NHI1_HOME/theConfig/c
  |DEBUG[1]:                                          ->     | LIB_BASE_DIR    | NHI1_HOME/theConfig | LONG                | lc
  |DEBUG[1]:                                          ->     | LngId           | c                                    | META_FILE_EXTENSION | <>
  |DEBUG[1]:                                          ->     | META_HIDE_BEGIN | #ifndef PARSE_C_HEADER_TO_META       | META_HIDE_END       | #endif
  |DEBUG[1]:                                          ->     | ONFILTER        | 1                                    | ONFILTER2           | 1
  |DEBUG[1]:                                          ->     | ONPROFILE       | false                                | ONVERBOSE           | 1
  |DEBUG[1]:                                          ->     | OVERLOAD        | no                                   | OVERLOAD_CALL       | yes
  |DEBUG[1]:                                          ->     | OVERLOAD_NAME   | yes                                  | PRINT               | 1
  |DEBUG[1]:                                          ->     | PRINT2          | 1                                    | PROFILE_KEY         | exclusiveRuntime
  |DEBUG[1]:                                          ->     | PROFILE_PAT     | *                                    | RCNs                | @RLcNs
  |DEBUG[1]:                                          ->     | SHOW_FILTER     | no                                   | SHOW_FILTER_DETAIL  | no
  |DEBUG[1]:                                          ->     | SILENT          | 0                                    | STDOUT              | 0
  |DEBUG[1]:                                          ->     | STYLE           | C                                    | TOPLEVEL            | NHI1_HOME/theCompiler/src/c_MqC.tcl
  |DEBUG[1]:                                          ->     | USE_CALLBACK    | no                                   | USE_FINAL_NAME      | false
  |DEBUG[1]:                                          ->     | USE_NS          | no                                   | VARARG_IS_ARRAY     | no
  |DEBUG[1]:                                          ->     | VERBOSE         | 1                                    | WARNING_AS_ERROR    | no
  |DEBUG[1]:                                          ->     | WRITE           | no                                   | lng_nspkg           | c_lcconfig
  |DEBUG[1]:                                          ->   INIT = <array|P|*>
  |DEBUG[1]:                                          ->     | Api  | MqC                                          | LANG      | C
  |DEBUG[1]:                                          ->     | Ns   | Lc                                           | Prefix    | c_MqC
  |DEBUG[1]:                                          ->     | argv | -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta | example   | no
  |DEBUG[1]:                                          ->     | lang | c                                            | langid    | c
  |DEBUG[1]:                                          ->     | ns   | lc                                           | overwrite | no
pEVAL                                    -> +++000 -> try native
pEVAL                                    -> +++333 -> use imeta -> imeta<NHI1_HOME/theConfig/c/gen/nat_lcconfig.meta>
pEVAL                                    -> +++333 -> use cache -> cache<NHI1_BUILD/theConfig/c/gen/nat_lcconfig.meta.compile>
  |            DEBUG[1]: tcl::mathfunc::checkIgnore               -> allow<ENUM_S>                       ,
  |      DEBUG[1]: tcl::mathfunc::checkIgnore               -> allow<FUNC_M>                       ,
  |         DEBUG[1]: tcl::mathfunc::checkIgnore               -> ignore<HIDE>                        ,
  |         DEBUG[1]: tcl::mathfunc::checkNotIgnore            -> allow<INTERNAL>                     ,
p_filter                                 -> DEBUG[#1] -> use , __NAME__<LcConfigLookupInt64>
p_funcEND                                -> statistics -> p_funcDEF_all<126> , p_funcDEF_use<1> , p_funcDEF_skip<125> , p_funcDEF_internal<13> , p_funcDEF_hide<0>
p_funcEND                                -> skip '125' from '126' functions -> p_funcDEF_use<LcConfigLookupInt64>
pEVAL                                    -> funcDEF RESULT : LcConfigLookupInt64 =========================================
pEVAL                                    -> ty<omo>                        , type0M<ME_CCN_LcConfigC>       , var0<config>                   ,
pEVAL                                    -> retM<ME_ENE_MkErrorE>          , retC<MkErrorE>                 , retOM<ME_ENE_MkErrorE>         ,
pEVAL                                    -> class<LcConfigC>               , classM<ME_CCN_LcConfigC>       , classC<LcConfigC>              ,
pEVAL                                    -> prefix<LcConfig>               , prefixM<ME_CCN_LcConfigC>      , prefixC<LcConfigC>             ,
pEVAL                                    -> argv<{ME_CCN_LcConfigC config} {ME_PSN_MK_STRN path} {ME_NI8_MK_I64 value_out}> , RETURN_MAPPING<>
pEVAL                                    -> ===================================================================
  |DEBUG[1]: tcl::mathfunc::checkNotIgnore            -> allow<ENUM_S>                       ,
::cache::cache_open                      -> CUM -> chORfn<LcConfig> , ext<c> , args<LibNsPkg_lib>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.c>
  |DEBUG[1]: tcl::mathfunc::checkNotIgnore            -> allow<FUNC_S>                       ,
  |      DEBUG[1]: tcl::mathfunc::checkIgnore               -> allow<INSTANCE>                     ,
  |      DEBUG[1]: tcl::mathfunc::checkIgnore               -> allow<STATIC>                       ,
  |DEBUG[1]: c_MqC__funcLST_2_inlineARY_and_headerARY -> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^~ ,
  |DEBUG[1]:                                          -> +++ START +++                       , __NAME__<LcConfigLookupInt64>
  |   DEBUG[1]: lib_DX__getDocParameterApi               -> >>> START:                          , __NAME__<LcConfigLookupInt64>
  |      DEBUG[1]: getDocR                                  -> >>> START: doc(R)                   , __NAME__<LcConfigLookupInt64> , cls<LcConfigC> , pfx<LcConfig>
  |   DEBUG[1]: lib_DX__getDocParameterApi               -> LIST
  |   DEBUG[1]:                                          ->   | __NAME__             : LcConfigLookupInt64
  |   DEBUG[1]:                                          ->   | isDocI               : 0
  |   DEBUG[1]:                                          ->   | dR                   : Lookup
  |   DEBUG[1]:                                          ->   | dRA                  : LcConfigC-Lookup
  |   DEBUG[1]:                                          ->   | dI                   : _ignore_
  |   DEBUG[1]:                                          ->   | dIA                  : LcConfigC-Lookup
  |   DEBUG[1]:                                          ->   | clsR                 : LcConfigC
  |   DEBUG[1]:                                          ->   | dDA                  : LcConfigC_Lookup_C_API
c_MqC__funcLST_2_inlineARY_and_headerARY -> DEBUG[#1] -> my(__NAME__)<LcConfigLookupInt64> , isVoid<0>  , isRuntime~ , Oret<enum MkErrorE>  , Oargs<LC_CFGN config, MK_STRN path, MK_I64 *value_out>
::cache::cache_open                      -> CUM -> chORfn<gen/config_inline> , ext<h> , args<package_inline_lib>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/gen/config_inline_lc.h>
::cache::cache_open                      -> CUM -> chORfn<tempfile> , ext<1> , args<>
writeARY(LcConfigC,LcConfigC-Lookup,omo) = __parser__global__(LcConfigLookupInt64:value_out:out:yes);
/// @brief Non-inline replacement for @RLcNs{ConfigLookupInt64} …
__parser__(inline=LcConfigLookupInt64,DEFAULT-ARGS=value_out,const=yes,instance=config,alias=LcConfigLookupInt64)
LC_EXTERN enum MkErrorE MK_DECL LcConfigLookupInt64P (LC_CFGN config, MK_STRN path, MK_I64 *value_out);

lib_ME__build_CLASS_index                -> print CLASS database -> CLASS<array|P|*>
                                         ->   CLASS = <array|P|*>
                                         ->     | LcConfig   | empty
                                         ->     | LcConfigC  | LcConfigC-Lookup
                                         ->     | LcSettingC | empty
lib_ME__write_funcARY                    -> Xclass<LcConfigC>
lib_ME__doc_start                        -> DEBUG[#1] -> Xclass<LcConfigC> , doc(DA)<LcConfigC_Lookup_C_API> , CONFIG(DOCID)<C> , PN<LcConfigC_Lookup_C_API>
lib_ME__doc_start                        -> DEBUG[#1] -> doc<array|P|*>
                                         ->   doc = <array|P|*>
                                         ->     | DA    | LcConfigC_Lookup_C_API
                                         ->     | I     | _ignore_
                                         ->     | IA    | LcConfigC-Lookup
                                         ->     | N     | LcConfigC - LcConfigC_Lookup_C_API
                                         ->     | NA    | LcConfigC_C_API
                                         ->     | R     | Lookup
                                         ->     | RA    | LcConfigC-Lookup
                                         ->     | clsR  | LcConfigC
                                         ->     | isIdx | 0
                                         ->     | isN   | 0
pInclude                                 -> id<LcConfigC> , cfn<rc4> , fn<tempfile-1> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | yes
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
  
  /// @addtogroup LcConfigC_Lookup_C_API
  /// @{
  /// @name LcConfigC - LcConfigC_Lookup_C_API - function
  /// @{
  
  // doc-key: LcConfigC,LcConfigC-Lookup,omo
  __parser__global__(LcConfigLookupInt64:value_out:out:yes);
  /// @brief Non-inline replacement for @RLcNs{ConfigLookupInt64} …
  __parser__(inline=LcConfigLookupInt64,DEFAULT-ARGS=value_out,const=yes,instance=config,alias=LcConfigLookupInt64)
  LC_EXTERN enum MkErrorE MK_DECL LcConfigLookupInt64P (LC_CFGN config, MK_STRN path, MK_I64 *value_out);
  /// @}
  /// @}

pInclude                                 -> id<inline> , cfn<rc2> , fn<NHI1_HOME/theConfig/c/gen/config_inline_lc.h> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
pInclude                                 -> WARNING: outTXT is empty -> id<inline>                     , ext<->               , fn<NHI1_HOME/theConfig/c/gen/config_inline_lc.h>
                                         ->   Stack[2]: pInclude inline rc2 ...
                                         ->     Stack[1]: lib_ME__write_funcARY__compress inline rc2 -array headerARY ...
::cache::cache_open                      -> CUM -> chORfn<gen/config_inline> , ext<c> , args<package_inline_lib §header§ config_inline_lc.h>
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/gen/config_inline_lc.c>
::cache::cache_open                      -> CUM -> chORfn<tempfile> , ext<1> , args<>
cache_open                               -> open from cache -> fn<tempfile-1>
writeARY(LcConfigC,LcConfigC-Lookup,omo) =   |   DEBUG[1]: lib_MqS__ARG                             -> >>> START:                          , __NAME__<LcConfigLookupInt64> , ty<omo> , argv<{ME_CCN_LcConfigC config} {ME_PSN_MK_STRN path} {ME_NI8_MK_I64 value_out}> , getter<getterC> , formater<Filter_arg_in>
  |      DEBUG[1]: lib_MqS__ARG_default_init                -> >>> START:                          , at<ME_CCN_LcConfigC> , av<config> , getter<getterC> , ::Flag_onNativeDefault<false>
  |      DEBUG[1]: lib_MqS__ARG_default_init                -> >>> START:                          , at<ME_PSN_MK_STRN> , av<path> , getter<getterC> , ::Flag_onNativeDefault<false>
  |      DEBUG[1]: lib_MqS__ARG_default                     -> >>> START:                          , at<ME_NI8_MK_I64> , av<value_out> , getter<getterC>
  |         DEBUG[1]: lib_MqS__ARG_default_init                -> >>> START:                          , at<ME_NI8_MK_I64> , av<value_out> , getter<getterC> , ::Flag_onNativeDefault<false>
  |DEBUG[1]: c_MqC__funcLST_2_inlineARY_and_headerARY -> XargsSave<LC_CFGN config, MK_STRN ~ ,

enum MkErrorE LcConfigLookupInt64P (LC_CFGN config, MK_STRN path, MK_I64 *value_out) {
    |   DEBUG[1]: lib_MqC__CALL__styleC                    -> >>> START:                          , argv<{ME_CCN_LcConfigC config} {ME_PSN_MK_STRN path} {ME_NI8_MK_I64 value_out}>
  return LcConfigLookupInt64(config, path, value_out);
}

lib_ME__build_CLASS_index                -> print CLASS database -> CLASS<array|P|*>
                                         ->   CLASS = <array|P|*>
                                         ->     | LcConfig   | empty
                                         ->     | LcConfigC  | LcConfigC-Lookup
                                         ->     | LcSettingC | empty
lib_ME__write_funcARY                    -> Xclass<LcConfigC>
pInclude                                 -> id<LcConfigC> , cfn<rc4> , fn<tempfile-1> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | yes
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
  
  // doc-key: LcConfigC,LcConfigC-Lookup,omo
    |   DEBUG[1]: lib_MqS__ARG                             -> >>> START:                          , __NAME__<LcConfigLookupInt64> , ty<omo> , argv<{ME_CCN_LcConfigC config} {ME_PSN_MK_STRN path} {ME_NI8_MK_I64 value_out}> , getter<getterC> , formater<Filter_arg_in>
    |      DEBUG[1]: lib_MqS__ARG_default_init                -> >>> START:                          , at<ME_CCN_LcConfigC> , av<config> , getter<getterC> , ::Flag_onNativeDefault<false>
    |      DEBUG[1]: lib_MqS__ARG_default_init                -> >>> START:                          , at<ME_PSN_MK_STRN> , av<path> , getter<getterC> , ::Flag_onNativeDefault<false>
    |      DEBUG[1]: lib_MqS__ARG_default                     -> >>> START:                          , at<ME_NI8_MK_I64> , av<value_out> , getter<getterC>
    |         DEBUG[1]: lib_MqS__ARG_default_init                -> >>> START:                          , at<ME_NI8_MK_I64> , av<value_out> , getter<getterC> , ::Flag_onNativeDefault<false>
    |DEBUG[1]: c_MqC__funcLST_2_inlineARY_and_headerARY -> XargsSave<LC_CFGN config, MK_STRN ~ ,
  
  enum MkErrorE LcConfigLookupInt64P (LC_CFGN config, MK_STRN path, MK_I64 *value_out) {
      |   DEBUG[1]: lib_MqC__CALL__styleC                    -> >>> START:                          , argv<{ME_CCN_LcConfigC config} {ME_PSN_MK_STRN path} {ME_NI8_MK_I64 value_out}>
    return LcConfigLookupInt64(config, path, value_out);
  }

pInclude                                 -> id<inline> , cfn<rc6> , fn<NHI1_HOME/theConfig/c/gen/config_inline_lc.c> , opts<array|P|*>
                                         ->   opts = <array|P|*>
                                         ->     | -add          | no
                                         ->     | -ext          | -
                                         ->     | -null-allowed | no
                                         ->     | -tmpl         | <>
                                         ->     | -tmpl-args    | <>
pInclude                                 -> WARNING: outTXT is empty -> id<inline>                     , ext<->               , fn<NHI1_HOME/theConfig/c/gen/config_inline_lc.c>
                                         ->   Stack[2]: pInclude inline rc6 ...
                                         ->     Stack[1]: lib_ME__write_funcARY__compress inline rc6 -array inlineARY ...
pFILENAME                                -> use file -> fn<NHI1_HOME/theConfig/c/private_lc.h>
tmpl_make_from_file                      -> keep file -> fn<NHI1_HOME/theConfig/c/private_lc.h>
 

example - compile manged-object-api-function into C# api function

The example in the alc-compiler C# backend shows the debugging of the MkBufferAppendSTR function.

This function is from the library LibMkKernel_mk.h or mk for short and is a method of the class MkBufferC .

 call: 'cs_MqC.tcl' '-mk' '-d' '-d' '-f' 'MkBufferAppendSTR'


pInit                                    -> PINIT[#0] -> +++ use              : lang<cs>        : api<MqC>             : top<cs_MqC.tcl>
                                         -> PINIT[#0] -> argv<-mk -d -d -f MkBufferAppendSTR>
                                         -> PINIT[>0] -> INIT(lang)<cs> : INIT(Api)<MqC> : INIT(argv)<-i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta>
                                         -> PINIT[>0] -> CONFIG(FUNCEXPR)<MkBufferAppendSTR> : CONFIG(CLASSEXPR)<§undef§>
                                         -> PINIT[>0] -> config load          : LIB<NHI1_HOME/theCompiler/src/lib_CS.tcl>
GLOBAL                                   -> PINIT[#2] -> CS overwrite from    : imeta<NHI1_HOME/theKernel/c/gen/c_mkkernel.meta> : header<NHI1_HOME/theKernel/c/kernel_mk.h>
GLOBAL                                   -> PINIT[#2] -> CS overwrite to      : imeta<NHI1_HOME/theKernel/cs/.LibMkKernel_cs.meta> : header<NHI1_HOME/theKernel/cs/LibMkKernel_cs.h>
                                         -> PINIT[>0] -> config load          : LIB<NHI1_HOME/theKernel/c/compiler.tcl>
                                         -> PINIT[>0] -> config NOT found     : LIB<NHI1_HOME/theKernel/cs/compiler.tcl>
                                         -> PINIT[#1] -> call init            : top<cs_MqC.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/lib_MqC.tcl>
pInit                                    -> PINIT[#2] -> +++ skip             : lang<no>   : api<MqC>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/lib_MqC_type_C.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/cs_MqS.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/lib_MqS.tcl>
pInit                                    -> PINIT[#2] -> +++ skip             : lang<no>   : api<MqS>
pInit                                    -> PINIT[#2] -> +++ skip             : lang<cs>   : api<MqS>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/lib_DX.tcl>
pInit                                    -> PINIT[#2] -> +++ skip             : lang<no>   : api<DOC>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/lib_MqS_type_C.tcl>
pSource                                  -> source file -> src<NHI1_HOME/theCompiler/src/lib_RpcPost.tcl>
pInit                                    -> PINIT[#2] -> +++ skip             : lang<no>   : api<Rpc>
                                         -> PINIT[#1]            : LIST
                                         ->   | info                 : +++ use
                                         ->   | IGNORE(#ignore)      : <>
                                         ->   | IGNORE(#only)        : <>
                                         ->   | IGNORE(INTERNAL)     : 0
                                         -> PINIT[#1] -> IGNORE(HIDE)<0> : ::HIDE<> : ::KEEP<>
                                         -> PINIT[#1] -> imeta<NHI1_HOME/theKernel/cs/.LibMkKernel_cs.meta>
                                         -> PINIT[#1] -> getterL<alias:pGet_M2S> : getterS<alias:pGet_M2S> : getterC<alias:pGet_M2C>
  |DEBUG[1]: pEVAL                                    -> >>> START:                          , CONFIG<array|P|*> , INIT<array|P|*>
  |DEBUG[1]:                                          ->   CONFIG = <array|P|*>
  |DEBUG[1]:                                          ->     | ALLOW_argv      | no                                   | ALWAYS_DEFAULT      | no
  |DEBUG[1]:                                          ->     | ARRAY_IS_VARARG | no                                   | BROKEN_C_NAME       | no
  |DEBUG[1]:                                          ->     | CLASSEXPR       | §undef§                              | CMD                 | cs_MqC.tcl
  |DEBUG[1]:                                          ->     | CMT             | //                                   | CMT_DX              | ///
  |DEBUG[1]:                                          ->     | CNs             | MkNs                                 | CODEEXT_C           | cs
  |DEBUG[1]:                                          ->     | CODEEXT_N       | cs                                   | CODEEXT_S           | cs
  |DEBUG[1]:                                          ->     | C_API           | no                                   | DEBUG               | 2
  |DEBUG[1]:                                          ->     | DEPENDENCY      | no                                   | DOCID               | CS
  |DEBUG[1]:                                          ->     | ERASE_ALL       | no                                   | FILTER              | yes
  |DEBUG[1]:                                          ->     | FORCE           | no                                   | FRAME_CLEANUP       | no
  |DEBUG[1]:                                          ->     | FRAME_GET_ALL   | yes                                  | FRAME_INIT_STACK    | no
  |DEBUG[1]:                                          ->     | FUNCEXPR        | MkBufferAppendSTR                    | HAS_CLASS           | yes
  |DEBUG[1]:                                          ->     | HAS_DEFAULT_ARG | yes                                  | HAS_REF_POINTER     | no
  |DEBUG[1]:                                          ->     | HAS_TYPE_FIRST  | yes                                  | JUMP_ON_ERROR       | no
  |DEBUG[1]:                                          ->     | KEYWORDS        | <>                                   | LIBDIR              | NHI1_HOME/theKernel/cs
  |DEBUG[1]:                                          ->     | LIB_BASE_DIR    | NHI1_HOME/theKernel | LONG                | csharp
  |DEBUG[1]:                                          ->     | LngId           | cs                                   | META_FILE_EXTENSION | <>
  |DEBUG[1]:                                          ->     | META_HIDE_BEGIN | #ifndef PARSE_C_HEADER_TO_META       | META_HIDE_END       | #endif
  |DEBUG[1]:                                          ->     | ONFILTER        | 1                                    | ONFILTER2           | 1
  |DEBUG[1]:                                          ->     | ONPROFILE       | false                                | ONVERBOSE           | 1
  |DEBUG[1]:                                          ->     | OVERLOAD        | yes                                  | OVERLOAD_CALL       | yes
  |DEBUG[1]:                                          ->     | OVERLOAD_NAME   | yes                                  | PRINT               | 1
  |DEBUG[1]:                                          ->     | PRINT2          | 1                                    | PROFILE_KEY         | exclusiveRuntime
  |DEBUG[1]:                                          ->     | PROFILE_PAT     | *                                    | RCNs                | @RMkNs
  |DEBUG[1]:                                          ->     | SHOW_FILTER     | no                                   | SHOW_FILTER_DETAIL  | no
  |DEBUG[1]:                                          ->     | SILENT          | 0                                    | STDOUT              | 0
  |DEBUG[1]:                                          ->     | STYLE           | C                                    | TOPLEVEL            | NHI1_HOME/theCompiler/src/cs_MqC.tcl
  |DEBUG[1]:                                          ->     | USE_CALLBACK    | yes                                  | USE_FINAL_NAME      | yes
  |DEBUG[1]:                                          ->     | USE_NS          | no                                   | VARARG_IS_ARRAY     | yes
  |DEBUG[1]:                                          ->     | VERBOSE         | 2                                    | WARNING_AS_ERROR    | no
  |DEBUG[1]:                                          ->     | WRITE           | no                                   | lng_nspkg           | cs_mkkernel
  |DEBUG[1]:                                          ->   INIT = <array|P|*>
  |DEBUG[1]:                                          ->     | Api  | MqC                                            | LANG      | CS
  |DEBUG[1]:                                          ->     | Ns   | Mk                                             | Prefix    | cs_MqC
  |DEBUG[1]:                                          ->     | argv | -i NHI1_HOME/theKernel/cs/.LibMkKernel_cs.meta | example   | no
  |DEBUG[1]:                                          ->     | lang | cs                                             | langid    | cs
  |DEBUG[1]:                                          ->     | ns   | mk                                             | overwrite | no
pEVAL                                    -> +++333 -> use imeta -> imeta<NHI1_HOME/theKernel/cs/.LibMkKernel_cs.meta>
File_HasChanged                          -> Error: RAISE -> source file does NOT exists , srcF<NHI1_HOME/theKernel/cs/.LibMkKernel_cs.meta>
                                         ->   Stack[2]: File_HasChanged /dev/shm/dev1usr/Main/x86_64-suse-linux-gnu/d ...
                                         ->     Stack[1]: pEVAL ...
    invoked from within
"Error "source file does NOT exists" srcF"
    (procedure "File_HasChanged" line 12)
    invoked from within
"File_HasChanged $cache.chk $imeta [file join $::libdir lib_ME.tcl]"
    (procedure "pEVAL" line 34)
    invoked from within
"pEVAL"
    ("uplevel" body line 6)
    invoked from within
"uplevel $script"
    (procedure "pMain" line 57)
    invoked from within
"pMain {

  # source metadata
  # M2S switch the CS.meta from ALIAS to ORIG name → discard all ALIAS definitions from attributeDEF
  #pEVAL   {^.*att..."
    (file "NHI1_HOME/theCompiler/src/cs_MqC.tcl" line 483)
 

example - compile an entire project with the "BuildNhi1.bash' tool

 call: 'BuildNhi1.bash' '-lc' '-f' '-c'


[Nhi1Env] setup=debug:
  > NHI1_BUILD/env-build.sh

  +++ [ BuildNhi1  : jobId=BuildNhi1:doG:lc:c             : jobs= 1 : sec= 0 : pid=39165 ] JOB START

  +++ [ BuildNhi1  : jobId=BuildNhi1:doG:lc:c             : jobs= 1 : sec= 0 : pid=39165 ] JOB START caller=proc_lib_and_lng

  Nhi1Make -v -do-j -predir NHI1_HOME/theConfig/c --silent clean
  > make --no-builtin-rules --no-builtin-variables -l 32 -j -C NHI1_BUILD/theConfig/c --silent clean
make[3]: Verzeichnis „NHI1_BUILD/theConfig/c“ wird betreten
  INFO → c : lc : config ======================
Making clean in tests
make[4]: Verzeichnis „NHI1_BUILD/theConfig/c/tests“ wird betreten
make[4]: Verzeichnis „NHI1_BUILD/theConfig/c/tests“ wird verlassen
make[4]: Verzeichnis „NHI1_BUILD/theConfig/c“ wird betreten
  INFO → c : lc : config ======================
rm -f ./so_locations
make[4]: Verzeichnis „NHI1_BUILD/theConfig/c“ wird verlassen
make[3]: Verzeichnis „NHI1_BUILD/theConfig/c“ wird verlassen
  Nhi1Make -v -no-j -predir NHI1_HOME/theConfig/c --silent MqC
  > make --no-builtin-rules --no-builtin-variables -C NHI1_BUILD/theConfig/c --silent MqC
make[3]: Verzeichnis „NHI1_BUILD/theConfig/c“ wird betreten
  INFO → c : lc : config ======================
  make: NHI1_HOME/theCompiler/src/c_Meta.tcl -lc
pInit                                    -> PINIT[#0] -> +++ use              : lang<c>         : api<Meta>            : top<c_Meta.tcl>
                                         -> PINIT[#0] -> argv<-lc>
c_Meta__Main                             -> LIST
                                         ->   | imk                  : NHI1_HOME/theKernel/c
                                         ->   | header               : NHI1_HOME/theConfig/c/config_lc.h
WriteMeta                                -> LIST
                                         ->   | metaf                : NHI1_HOME/theConfig/c/gen/nat_lcconfig.meta
                                         ->   | indexF               : NHI1_HOME/theConfig/c/gen/nat_lcconfig.index
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/nat_lcconfig.meta
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/nat_lcconfig.index
WriteMeta                                -> LIST
                                         ->   | metaf                : NHI1_HOME/theConfig/c/gen/c_lcconfig.meta
                                         ->   | indexF               : NHI1_HOME/theConfig/c/gen/c_lcconfig.index
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/c_lcconfig.meta
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/c_lcconfig.index
  make: NHI1_HOME/theCompiler/src/c_Overload.tcl -lc 
pInit                                    -> PINIT[#0] -> +++ use              : lang<c>         : api<Overload>        : top<c_Overload.tcl>
                                         -> PINIT[#0] -> argv<-lc>
pEVAL                                    -> +++000 -> try native
pEVAL                                    -> +++333 -> use imeta -> imeta<NHI1_HOME/theConfig/c/gen/nat_lcconfig.meta>
pEVAL                                    -> +++111 -> NO cache -> CONFIG(FORCE)<yes>
p_funcEND                                -> statistics -> p_funcDEF_all<139> , p_funcDEF_use<139> , p_funcDEF_skip<0> , p_funcDEF_internal<0> , p_funcDEF_hide<0>
cache_close                              -> keep file -> fn<NHI1_HOME/theConfig/c/gen/config_overload_lc.h>
cache_close                              -> keep file -> fn<NHI1_HOME/theConfig/c/gen/overload.index>
  make: NHI1_HOME/theCompiler/src/c_Native.tcl -lc 
pInit                                    -> PINIT[#0] -> +++ use              : lang<c>         : api<Native>          : top<c_Native.tcl>
                                         -> PINIT[#0] -> argv<-lc>
pEVAL                                    -> +++000 -> try native
pEVAL                                    -> +++333 -> use imeta -> imeta<NHI1_HOME/theConfig/c/gen/nat_lcconfig.meta>
pEVAL                                    -> +++111 -> NO cache -> CONFIG(FORCE)<yes>
p_funcEND                                -> statistics -> p_funcDEF_all<126> , p_funcDEF_use<126> , p_funcDEF_skip<0> , p_funcDEF_internal<13> , p_funcDEF_hide<0>
cache_close                              -> keep file -> fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.h>
cache_close                              -> keep file -> fn<NHI1_HOME/theConfig/c/LcConfigC_lc.h>
cache_close                              -> keep file -> fn<NHI1_HOME/theConfig/c/LcSettingC_lc.h>
  make: NHI1_HOME/theCompiler/src/c_MqS.tcl -lc 
pInit                                    -> PINIT[#0] -> +++ use              : lang<c>         : api<MqS>             : top<c_MqS.tcl>
                                         -> PINIT[#0] -> argv<-lc>
pEVAL                                    -> +++000 -> try native
pEVAL                                    -> +++333 -> use imeta -> imeta<NHI1_HOME/theConfig/c/gen/nat_lcconfig.meta>
pEVAL                                    -> +++111 -> NO cache -> CONFIG(FORCE)<yes>
p_funcEND                                -> statistics -> p_funcDEF_all<126> , p_funcDEF_use<126> , p_funcDEF_skip<0> , p_funcDEF_internal<13> , p_funcDEF_hide<0>
cache_close                              -> keep file -> fn<NHI1_HOME/theConfig/c/LcEnum_lc.h>
  make: NHI1_HOME/theCompiler/src/c_MqC.tcl -lc 
pInit                                    -> PINIT[#0] -> +++ use              : lang<c>         : api<MqC>             : top<c_MqC.tcl>
                                         -> PINIT[#0] -> argv<-lc>
pEVAL                                    -> +++000 -> try native
pEVAL                                    -> +++333 -> use imeta -> imeta<NHI1_HOME/theConfig/c/gen/nat_lcconfig.meta>
pEVAL                                    -> +++111 -> NO cache -> CONFIG(FORCE)<yes>
p_funcEND                                -> statistics -> p_funcDEF_all<126> , p_funcDEF_use<126> , p_funcDEF_skip<0> , p_funcDEF_internal<13> , p_funcDEF_hide<0>
tmpl_make_from_file                      -> keep file -> fn<NHI1_HOME/theConfig/c/private_lc.h>
cache_close                              -> keep file -> fn<NHI1_HOME/theConfig/c/LibLcConfig_lc.c>
cache_close                              -> keep file -> fn<NHI1_HOME/theConfig/c/gen/config_inline_lc.h>
cache_close                              -> keep file -> fn<NHI1_HOME/theConfig/c/gen/config_inline_lc.c>
  make:  NHI1_HOME/theConfig/c/.makefile_index.bash 
make[3]: Verzeichnis „NHI1_BUILD/theConfig/c“ wird verlassen
  Nhi1Make -v -no-j -predir NHI1_HOME/theConfig/c --silent RpcServer
  > make --no-builtin-rules --no-builtin-variables -C NHI1_BUILD/theConfig/c --silent RpcServer
make[3]: Verzeichnis „NHI1_BUILD/theConfig/c“ wird betreten
  INFO → c : lc : config ======================
 cd NHI1_HOME && /bin/bash NHI1_HOME/missing automake-1.15 --gnu theConfig/c/Makefile
 cd ../.. && /bin/bash ./config.status theConfig/c/Makefile depfiles
config.status: creating theConfig/c/Makefile
config.status: executing depfiles commands
  INFO → c : lc : config ======================
  make: NHI1_HOME/theCompiler/src/c_RpcServer.tcl -lc 
pInit                                    -> PINIT[#0] -> +++ use              : lang<c>         : api<RpcServer>       : top<c_RpcServer.tcl>
                                         -> PINIT[#0] -> argv<-lc>
pEVAL                                    -> +++333 -> use imeta -> imeta<NHI1_HOME/theConfig/c/gen/c_lcconfig.meta>
pEVAL                                    -> +++111 -> NO cache -> CONFIG(FORCE)<yes>
p_funcEND                                -> statistics -> p_funcDEF_all<110> , p_funcDEF_use<110> , p_funcDEF_skip<0> , p_funcDEF_internal<13> , p_funcDEF_hide<15>
p_funcEND                                -> WARNING: skip broken function possibly caused by broken 'attribute' -> __NAME__<LcConfigSetSettingDeleteFunc> , attributeDEF,*<array|P|*>
                                         ->   attributeDEF,* = <array|P|*>
                                         ->     | attributeDEF,DEFAULT-ARGS                           | fSettingDeleteCall fSettingDeleteData fSettingDeleteFree
                                         ->     | attributeDEF,callback-name                          | SettingDelete
                                         ->     | attributeDEF,fSettingDeleteCall,CALLBACK-NULL-CHECK | fSettingDeleteData
                                         ->     | attributeDEF,fSettingDeleteCall,callback-call       | yes
                                         ->     | attributeDEF,fSettingDeleteCall,internal            | yes
                                         ->     | attributeDEF,fSettingDeleteData,CALLBACK-NULL-CHECK | fSettingDeleteCall
                                         ->     | attributeDEF,fSettingDeleteData,callback            | SettingDelete
                                         ->     | attributeDEF,fSettingDeleteData,callback-data       | yes
                                         ->     | attributeDEF,fSettingDeleteFree,callback-free       | yes
                                         ->     | attributeDEF,fSettingDeleteFree,internal            | yes
                                         ->     | attributeDEF,mkrt,internal                          | yes
                                         ->     | attributeDEF,no-alias                               | yes
                                         ->     | attributeDEF,runtime                                | LcConfigSetSettingDeleteFunc_RT
                                         ->     | attributeDEF,runtime-ns                             | MK
cache_close                              -> keep file -> fn<NHI1_HOME/example/c/LibLcConfigRpcServer.c>
cache_close                              -> keep file -> fn<NHI1_HOME/example/c/LibLcConfigRpcServer.h>
make[3]: Verzeichnis „NHI1_BUILD/theConfig/c“ wird verlassen
  Nhi1Make -v -no-j -predir NHI1_HOME/theConfig/c --silent RpcClient
  > make --no-builtin-rules --no-builtin-variables -C NHI1_BUILD/theConfig/c --silent RpcClient
make[3]: Verzeichnis „NHI1_BUILD/theConfig/c“ wird betreten
  INFO → c : lc : config ======================
  make: NHI1_HOME/theCompiler/src/c_RpcClient.tcl -lc 
make[3]: Verzeichnis „NHI1_BUILD/theConfig/c“ wird verlassen

  +++ [ BuildNhi1  : jobId=BuildNhi1:doG:lc:c             : jobs= 1 : sec= 3 : pid=39165 ] JOB END
  +++ [ BuildNhi1  : jobId=BuildNhi1:doD:lc:c             : jobs= 1 : sec= 3 : pid=39839 ] JOB START

  +++ [ BuildNhi1  : jobId=BuildNhi1:doD:lc:c             : jobs= 1 : sec= 3 : pid=39839 ] JOB START caller=proc_lib_and_lng

  Nhi1Make -v -no-j -predir NHI1_HOME/theConfig/c --silent DOC DOCARGS=
  > make --no-builtin-rules --no-builtin-variables -C NHI1_BUILD/theConfig/c --silent DOC DOCARGS=
make[3]: Verzeichnis „NHI1_BUILD/theConfig/c“ wird betreten
  INFO → c : lc : config ======================
  make: NHI1_HOME/theCompiler/src/c_Meta.tcl -lc
  make: NHI1_HOME/theConfig/c/libconfig_2_docdb.tcl NHI1_HOME/theConfig/c/libconfig.texi
pInit                                    -> PINIT[#0] -> +++ use              : lang<c>         : api<Meta>            : top<c_Meta.tcl>
                                         -> PINIT[#0] -> argv<-lc>
c_Meta__Main                             -> LIST
                                         ->   | imk                  : NHI1_HOME/theKernel/c
                                         ->   | header               : NHI1_HOME/theConfig/c/config_lc.h
pInit                                    -> PINIT[#0] -> +++ use              : lang<c>         : api<DocParser>       : top<libconfig_2_docdb.tcl>
                                         -> PINIT[#0] -> argv<-lc -lc -srcfile NHI1_HOME/theConfig/c/libconfig.texi -dbdir NHI1_HOME/theConfig/c/gen/doc_db.dir>
GLOBAL                                   -> LIST
                                         ->   | outdir               : NHI1_HOME/theConfig/c/gen/doc_db.dir
                                         ->   | srcfle               : NHI1_HOME/theConfig/c/libconfig.texi
pEVAL                                    -> +++000 -> try native
pEVAL                                    -> +++333 -> use imeta -> imeta<NHI1_HOME/theConfig/c/gen/nat_lcconfig.meta>
pEVAL                                    -> +++111 -> NO cache -> CONFIG(FORCE)<yes>
p_funcEND                                -> statistics -> p_funcDEF_all<139> , p_funcDEF_use<139> , p_funcDEF_skip<0> , p_funcDEF_internal<0> , p_funcDEF_hide<0>
WriteMeta                                -> LIST
                                         ->   | metaf                : NHI1_HOME/theConfig/c/gen/nat_lcconfig.meta
                                         ->   | indexF               : NHI1_HOME/theConfig/c/gen/nat_lcconfig.index
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/nat_lcconfig.meta
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/nat_lcconfig.index
WriteMeta                                -> LIST
                                         ->   | metaf                : NHI1_HOME/theConfig/c/gen/c_lcconfig.meta
                                         ->   | indexF               : NHI1_HOME/theConfig/c/gen/c_lcconfig.index
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/section-Why Another Configuration File Library?
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/section-Multithreading Issues
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/section-Internationalization Issues
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/chapter-Introduction-section-list
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/c_lcconfig.meta
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/c_lcconfig.index
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/chapter-Introduction
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/section-Settings
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/section-Groups
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/section-Arrays
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/section-Lists
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/section-Integer Values
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/section-64-bit Integer Values
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/section-Floating Point Values
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/section-Boolean Values
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/section-String Values
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/section-Comments
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/section-Include Directives
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/chapter-Configuration Files-section-list
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/chapter-Configuration Files
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigInit
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigDestroy
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigClear
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigRead
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigReadFile
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigReadString
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigWrite
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigWriteFile
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigErrorText
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigErrorFile
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigErrorLine
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigErrorType
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSetIncludeDir
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigGetIncludeDir
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSetIncludeFunc
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigGetFloatPrecision
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSetFloatPrecision
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigGetOptions
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSetOptions
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigGetOption
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSetOption
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigGetAutoConvert
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSetAutoConvert
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigGetDefaultFormat
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSetDefaultFormat
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigGetTabWidth
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSetTabWidth
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigLookupInt
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigLookupInt64
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigLookupFloat
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigLookupBool
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigLookupString
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigLookup
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingLookup
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingGetInt
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingGetInt64
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingGetFloat
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingGetBool
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingGetString
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingSetInt
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingSetInt64
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingSetFloat
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingSetBool
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingSetString
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingLookupInt
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingLookupInt64
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingLookupFloat
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingLookupBool
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingLookupString
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingGetFormat
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingSetFormat
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingGetMember
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingGetElem
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingGetIntElem
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingGetInt64Elem
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingGetFloatElem
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingGetBoolElem
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingGetStringElem
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingSetIntElem
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingSetInt64Elem
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingSetFloatElem
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingSetBoolElem
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingSetStringElem
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingAdd
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingRemove
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingRemoveElem
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigRootSetting
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingName
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingParent
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingIsRoot
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingIndex
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingLength
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingType
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingIsGroup
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingIsArray
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingIsList
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingIsAggregate
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingIsScalar
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingIsNumber
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingSourceFile
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingSourceLine
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSetHook
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigGetHook
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingSetHook
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSettingGetHook
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/func-LcConfigSetDestructor
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/chapter-The C API-func-list
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/chapter-The C API
File_Write                               -> keep file -> NHI1_HOME/theConfig/c/gen/doc_db.dir/chapter-list
  make: NHI1_HOME/theCompiler/src/c_DocMeta.tcl -lc 
  make: NHI1_HOME/theCompiler/src/c_NativeDoc.tcl -lc 
pInit                                    -> PINIT[#0] -> +++ use              : lang<c>         : api<DocMeta>         : top<c_DocMeta.tcl>
pInit                                    -> PINIT[#0] -> +++ use              : lang<c>         : api<Native>          : top<c_NativeDoc.tcl>
                                         -> PINIT[#0] -> argv<-lc>
                                         -> PINIT[#0] -> argv<-lc>
lib_DX__Init                             -> add DX attributes
pEVAL                                    -> +++000 -> try native
pEVAL                                    -> +++333 -> use imeta -> imeta<NHI1_HOME/theConfig/c/gen/nat_lcconfig.meta>
pEVAL                                    -> +++111 -> NO cache -> CONFIG(FORCE)<yes>
pEVAL                                    -> +++000 -> try native
pEVAL                                    -> +++333 -> use imeta -> imeta<NHI1_HOME/theConfig/c/gen/nat_lcconfig.meta>
pEVAL                                    -> +++111 -> NO cache -> CONFIG(FORCE)<yes>
p_funcEND                                -> statistics -> p_funcDEF_all<139> , p_funcDEF_use<139> , p_funcDEF_skip<0> , p_funcDEF_internal<0> , p_funcDEF_hide<0>
p_funcEND                                -> statistics -> p_funcDEF_all<126> , p_funcDEF_use<126> , p_funcDEF_skip<0> , p_funcDEF_internal<13> , p_funcDEF_hide<0>
pWrite                                   -> keep file -> fn<NHI1_HOME/theConfig/docs/gen/c_lcconfig_meta.config>
cache_close                              -> keep file -> fn<NHI1_HOME/theConfig/c/gen/LcConfigC_lc.doc>
cache_close                              -> keep file -> fn<NHI1_HOME/theConfig/c/gen/LcSettingC_lc.doc>
cache_close                              -> keep file -> fn<NHI1_HOME/theConfig/c/gen/LibLcConfig_lc.doc>
  make: NHI1_HOME/theCompiler/src/c_DOC.tcl -lc 
pInit                                    -> PINIT[#0] -> +++ use              : lang<c>         : api<DOC>             : top<c_DOC.tcl>
                                         -> PINIT[#0] -> argv<-lc>
lib_DX__Init                             -> add DX attributes
pEVAL                                    -> +++000 -> try native
pEVAL                                    -> +++333 -> use imeta -> imeta<NHI1_HOME/theConfig/c/gen/nat_lcconfig.meta>
pEVAL                                    -> +++111 -> NO cache -> CONFIG(FORCE)<yes>
p_funcEND                                -> statistics -> p_funcDEF_all<126> , p_funcDEF_use<126> , p_funcDEF_skip<0> , p_funcDEF_internal<13> , p_funcDEF_hide<0>
cache_close                              -> keep file -> fn<NHI1_HOME/theConfig/docs/gen/c_lcconfig.doc>
cache_close                              -> keep file -> fn<NHI1_HOME/theConfig/docs/gen/c_lcconfig_main.doc>
cache_close                              -> keep file -> fn<NHI1_HOME/theConfig/docs/public/c_lcconfig.config>
make[3]: Verzeichnis „NHI1_BUILD/theConfig/c“ wird verlassen

  +++ [ BuildNhi1  : jobId=BuildNhi1:doD:lc:c             : jobs= 1 : sec= 4 : pid=39839 ] JOB END
  +++ [ BuildNhi1  : jobId=main                           : jobs= 0 : sec= 4 : pid=39161 ] FINISH
 

back

theCompiler