@microtronics/studio-cli 0.4.1 → 0.5.1

package/out/dde/fileGenerators/dlo.js

@@ -0,0 +1,883 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoDDEGenerator = void 0;
+exports.generateAutoIncFromMap = generateAutoIncFromMap;
+exports.generateAutoUplinkIncFromMap = generateAutoUplinkIncFromMap;
+exports.generateMainDDEIncFromMap = generateMainDDEIncFromMap;
+const semver = __importStar(require("semver"));
+const coreDefinitions_1 = require("../coreDefinitions");
+const DeviceProfiles_1 = require("../../DeviceProfiles");
+const helper_1 = require("../../helper");
+var ContainerType = coreDefinitions_1.DDE_Core.ContainerType;
+var TransferDirection = coreDefinitions_1.DDE_Core.TransferDirection;
+var regexRelation = coreDefinitions_1.DDE_Core.regexRelation;
+var CONFIG_CONTAINER = coreDefinitions_1.DDE_Core.CONFIG_CONTAINER;
+var CONTAINER_DEF_DLO_CID_BASE = coreDefinitions_1.DDE_Core.CONTAINER_DEF_DLO_CID_BASE;
+var CONTAINER_DEFS = coreDefinitions_1.DDE_Core.CONTAINER_DEFS;
+var fieldTypeDefinitions = coreDefinitions_1.DDE_Core.fieldTypeDefinitions;
+/** get effective field type for pawn access (may be overriden or skipped using attribute dlorw=...)
+ * @return {*} | 'skip' | null - null=error occured
+ */
+function getPawnTypeDefinition(field) {
+    const tdef = fieldTypeDefinitions[field.type]; // just a shorthand
+    // supplement default values
+    if (!tdef.pwn.rwp) {
+        tdef.pwn.rwp = '%n';
+    }
+    if (!tdef.pwn.htype) {
+        tdef.pwn.htype = tdef.pwn.rwfunc;
+    }
+    // regular pawn access
+    return tdef.pwn;
+}
+// eslint-disable-next-line sonarjs/cognitive-complexity
+function generateAutoIncFromMap(ddeMap, globalDefines, manifest) {
+    const _pwn = []; // sample code output for pawn
+    const pwn = _pwn.push.bind(_pwn);
+    function pwn_section(s) {
+        pwn(`\n// === ${s} ===\n`);
+    }
+    /**
+     * generate PROJECT META definitions
+     */
+    pwn_section('PROJECT META');
+    const isNumeric = (v) => {
+        return !Array.isArray(v) && v - parseFloat(v) + 1 >= 0;
+    };
+    function addDefinition(name, value, noString = false) {
+        let quotes = isNumeric(value) ? '' : '"';
+        if (noString) {
+            quotes = '';
+        }
+        pwn(`#define ${name} ${quotes}${value}${quotes}`);
+    }
+    const { dpid, registry } = manifest;
+    const { auto_inc } = DeviceProfiles_1.DeviceProfiles[dpid];
+    addDefinition(`APM_DPID`, `${dpid}`);
+    addDefinition(`APM_DPID_${dpid}`, `1`);
+    addDefinition(`APM_DPID_${dpid.toUpperCase()}`, `1`);
+    addDefinition(`APM_ID`, registry?.id || ''); //
+    addDefinition(`APM_VERSION`, `${semver.coerce(manifest.version)?.major}`); // 1,
+    addDefinition(`APM_NAME`, `${manifest.name}`); // "project X",
+    addDefinition(`APM_AUTHOR`, `${manifest.publisher}`);
+    for (const [name, value] of Object.entries(auto_inc)) {
+        // quote all non-numeric values
+        if (!isNumeric(value)) {
+            addDefinition(name, `"${value}"`);
+        }
+        else {
+            addDefinition(name, `${value}`);
+        }
+    }
+    /**
+     * generate global dlo defines if there are any
+     */
+    pwn_section('GLOBAL DEFINES - parsed from /dlo/main.ini');
+    for (const [define, value] of Object.entries(globalDefines)) {
+        const valueIsDefine = Object.hasOwn(globalDefines, value);
+        addDefinition(define, `${value}`, valueIsDefine);
+    }
+    /**
+     * generate DDE-CORE definitions
+     */
+    let sz_max = 0; // maximum byte size over all configX and histdataX
+    const cx_szs = Array(10).fill(0); // configX byte size
+    let cx_isupm = 0; // configX upward - bitmask
+    let cx_isvolatilem = 0; // configX dlo-volatile - bitmask
+    let cx_isdnm = 0; // configX downward - bitmask
+    let cx_isvlm = 0; // configX variable length - bitmask
+    const cx_isrdef = 0; // configX variable length - bitmask
+    const hx_szs = Array(10).fill(0); // histdataX byte size
+    let hx_isvlm = 0; // histdataX variable length - bitmask
+    let aloha_varlen = undefined;
+    for (const [containerName, containerDefinition] of Object.entries(ddeMap.containers)) {
+        if (containerDefinition.containerType === ContainerType.cx &&
+            containerDefinition.transferDirection !== TransferDirection.backendOnly) {
+            const cx = parseInt(containerName.substring(6));
+            const cmsk = 1 << cx;
+            cx_szs[cx] = containerDefinition.size;
+            cx_isupm |= [
+                TransferDirection.both,
+                TransferDirection.none,
+                TransferDirection.deviceOnly,
+                TransferDirection.up,
+                TransferDirection.upPlus
+            ].includes(containerDefinition.transferDirection)
+                ? cmsk
+                : 0;
+            cx_isvolatilem |= containerDefinition.volatile ? cmsk : 0;
+            cx_isdnm |= [
+                TransferDirection.both,
+                TransferDirection.none,
+                TransferDirection.deviceOnly,
+                TransferDirection.down,
+                TransferDirection.downPlus
+            ].includes(containerDefinition.transferDirection)
+                ? cmsk
+                : 0;
+            cx_isvlm |= [TransferDirection.bothPlus, TransferDirection.upPlus, TransferDirection.downPlus].includes(containerDefinition.transferDirection)
+                ? cmsk
+                : 0;
+            // cx_isrdef |= cont.rdef ? 1 << cx : 0; //validation for down/down+ is don in the dde
+            sz_max = Math.max(sz_max, containerDefinition.size);
+        }
+        else if (containerDefinition.containerType === ContainerType.hx) {
+            const hx = parseInt(containerName.substring(8));
+            hx_szs[hx] = containerDefinition.size;
+            hx_isvlm |= [TransferDirection.upPlus].includes(containerDefinition.transferDirection) ? 1 << hx : 0;
+            sz_max = Math.max(sz_max, containerDefinition.size);
+        }
+        else if (containerDefinition.containerType === ContainerType.aloha) {
+            aloha_varlen = [TransferDirection.upPlus].includes(containerDefinition.transferDirection);
+            sz_max = Math.max(sz_max, containerDefinition.size);
+        }
+    }
+    pwn_section('DDE CORE');
+    pwn(`#define _DDE_BUF_BYTES (${sz_max}+10)`); // todo rem +10 ??? round to next multiple of 4 ???
+    pwn('');
+    pwn('//                                c0\tc1\tc2\tc3\tc4\tc5\tc6\tc7\tc8\tc9');
+    pwn(`stock _DDE_CONFIGS_size[] =[ ${cx_szs.join(',\t')}];`);
+    pwn(`#define _DDE_CONFIGS_upm     0b${cx_isupm.toString(2)} // ..is tolerant when reading back container with under-length`);
+    pwn(`#define _DDE_CONFIGS_volatilem 0b${cx_isvolatilem.toString(2)} // inits container as volatile`);
+    pwn(`#define _DDE_CONFIGS_downm   0b${cx_isdnm.toString(2)} // reading the container expects strict length`);
+    pwn(`#define _DDE_CONFIGS_varlenm 0b${cx_isvlm.toString(2)} // allow partial write (dde_wxxx)`);
+    pwn(`#define _DDE_CONFIGS_rdef    0b${cx_isrdef.toString(2)} // ..apply defaults reading a container with under-length`);
+    pwn('');
+    pwn('//                               h0\th1\th2\th3\th4\th5\th6\th7\th8\th9');
+    pwn(`stock _DDE_HISTS_size[]   =[ ${hx_szs.join(',\t')}];`);
+    pwn(`#define _DDE_HISTS_varlenm  0b${hx_isvlm.toString(2)} // allow partial write (dde_wxxx)`);
+    //see #RS-279 for more information about the _DDE_HISTS_maxsize
+    const szs = [...hx_szs];
+    if (Object.hasOwn(ddeMap, 'applog')) {
+        szs.push(125);
+    }
+    if (Object.hasOwn(ddeMap, 'alerts')) {
+        szs.push(13);
+    }
+    pwn(`#define _DDE_HISTS_maxsize  ${Math.max(...szs)}`);
+    pwn('');
+    if (aloha_varlen !== undefined) {
+        pwn(`#define _DDE_ALOHA_varlen ${aloha_varlen ? 1 : 0}`);
+        pwn('');
+    }
+    // generate
+    // #define DDE_xxx_id
+    // #define DDE_xxx_sz
+    // #define DDE_xxx_idx
+    for (const [containerName, containerDefinition] of Object.entries(ddeMap.containers)) {
+        //special handling for applog container is handled afterwards
+        if (containerDefinition.containerType === 'applog') {
+            continue;
+        }
+        pwn_section(`${containerDefinition.title.toUpperCase()} - ${containerDefinition.transferDirection} via #${containerName}`);
+        const cid_base = CONTAINER_DEF_DLO_CID_BASE(containerDefinition.containerType, containerDefinition.transferDirection);
+        if (!cid_base) {
+            pwn(`// ... container not available in DLO`);
+            continue;
+        }
+        const preAlias = `DDE_${containerDefinition.containerType === ContainerType.aloha ? ContainerType.aloha : containerDefinition.title}`;
+        const CDEF = CONTAINER_DEFS[containerName];
+        pwn(`// ${preAlias}_id - container identifier required for ${preAlias}_read/_write operations`);
+        pwn(`#define ${preAlias}_id (${cid_base}+${CDEF.cnum || 0})`);
+        pwn(`// ${preAlias}_sz - [byte] container total size`);
+        pwn(`#define ${preAlias}_sz ${containerDefinition.size}`);
+        if (CDEF.cnum !== undefined) {
+            pwn(`// ${preAlias}_idx - 0+ container index number`);
+            pwn(`#define ${preAlias}_idx ${CDEF.cnum}`);
+        }
+    }
+    // setup results
+    return _pwn.join('\n');
+}
+class AutoDDEGenerator {
+    ddeMap;
+    context;
+    globalVariables = [];
+    pawnGlobalSource = [];
+    pawnHelperSource = [];
+    timeSeriesSource = [];
+    readWriteSource = [];
+    definesSource = [];
+    defaultDefinesSource = [];
+    knownDefines = [];
+    pawnIndent = 0;
+    sourceType;
+    constructor(ddeMap, context) {
+        this.ddeMap = ddeMap;
+        this.context = context;
+        this.sourceType = 'pawnSource';
+    }
+    pawn(a, b) {
+        if (b && a === '<') {
+            this.pawnIndent--;
+        }
+        const sourceToPush = {
+            pawnSource: this.pawnGlobalSource,
+            globalVariables: this.globalVariables,
+            timeseries: this.timeSeriesSource,
+            readWrite: this.readWriteSource,
+            defines: this.definesSource,
+            defaultDefines: this.defaultDefinesSource
+        }[this.sourceType];
+        sourceToPush.push('\t'.repeat(this.pawnIndent) + (b || a));
+        if (b && a === '>') {
+            this.pawnIndent++;
+        }
+    }
+    generate() {
+        for (const [containerName, containerDefinition] of Object.entries(this.ddeMap.containers)) {
+            // check if the given library uses this container
+            if (this.context && !containerDefinition.libraries.includes(this.context)) {
+                continue;
+            }
+            const containerIdBase = CONTAINER_DEF_DLO_CID_BASE(containerDefinition.containerType, containerDefinition.transferDirection);
+            //container is not available in dlo or has any fields
+            if (!containerIdBase || !containerDefinition.fields) {
+                continue;
+            }
+            // only generate the apps rw functions if the app has defined fields
+            if (!this.context && !coreDefinitions_1.DDE_Core.hasContainerAppFields(containerDefinition)) {
+                continue;
+            }
+            const CONTDEF = CONTAINER_DEFS[containerName];
+            if (CONTDEF.ctype !== ContainerType.cx && this.context) {
+                continue;
+            }
+            this.generateGlobalVarsForContainer(containerDefinition);
+            this.generateReadWriteFunctions(containerDefinition);
+        }
+        this.mergeSourceTypes();
+        return { globals: this.pawnGlobalSource, helper: this.pawnHelperSource };
+    }
+    createGlobalVar(variableName, field) {
+        this.sourceType = 'globalVariables';
+        const varName = field ? this.variableNameForPawnDefinition(variableName, field) : variableName;
+        if (field) {
+            const comment = this.generateCommentForField(field);
+            if (comment) {
+                if (Array.isArray(comment)) {
+                    this.pawn('/**');
+                    comment.forEach(line => {
+                        this.pawn(` * ${line}`);
+                    });
+                    this.pawn(' */');
+                }
+                else {
+                    this.pawn(`// ${comment}`);
+                }
+            }
+        }
+        this.pawn(`stock ${varName};`);
+    }
+    insertSection(title) {
+        this.pawn('');
+        this.pawn('// =============================================================================');
+        this.pawn(`// ${title}`);
+        this.pawn('// =============================================================================');
+        this.pawn('');
+    }
+    mergeSourceTypes() {
+        this.sourceType = 'pawnSource';
+        if (this.definesSource.length) {
+            this.insertSection('Defines');
+            this.pawnGlobalSource.push(...this.definesSource);
+        }
+        if (this.defaultDefinesSource.length) {
+            this.insertSection('Field defaults');
+            this.pawnGlobalSource.push(...this.defaultDefinesSource);
+        }
+        if (this.globalVariables.length) {
+            this.insertSection('Global Variables');
+            this.pawnGlobalSource.push(...this.globalVariables);
+        }
+        if (this.readWriteSource.length) {
+            this.insertSection('Internal read/write calls');
+            this.pawnHelperSource.push(...this.readWriteSource);
+        }
+        this.pawn('');
+    }
+    generateGlobalVarsForContainer(containerDefinition) {
+        // this.globalVariables.push('// === Global variables ===');
+        this.sourceType = 'globalVariables';
+        this.pawn('');
+        this.pawn(`// Container '${containerDefinition.title.replace('_', ' ')}'`);
+        this.pawn('');
+        const pre = `DDE_${containerDefinition.title}`;
+        // defines for arrays
+        for (const arrayInfo of Object.values(containerDefinition.arrays)) {
+            if (this.context !== arrayInfo.library) {
+                continue;
+            }
+            const arrayDimension = `${pre}_${arrayInfo.name}_dim`;
+            this.sourceType = 'defines';
+            this.pawn(`#define ${arrayDimension} ${arrayInfo.length}`);
+            if (arrayInfo.fields) {
+                const fakeDDEContainer = {
+                    ...containerDefinition
+                };
+                fakeDDEContainer.fields = [];
+                arrayInfo.fields.forEach(field => {
+                    fakeDDEContainer.fields.push({
+                        arrayRef: null,
+                        shadowRef: null,
+                        byteOffset: 0,
+                        byteSize: field.byteSize,
+                        id: field.name,
+                        library: arrayInfo.library,
+                        name: field.name,
+                        type: field.type,
+                        title: null,
+                        index: 0
+                    });
+                });
+                const arrayStructure = `${pre}_${arrayInfo.name}_def`;
+                this.generateTypeDefinitions(fakeDDEContainer, arrayStructure);
+                this.createGlobalVar(`${pre}_${arrayInfo.name}[${arrayDimension}][${arrayStructure}]`);
+            }
+            else {
+                this.createGlobalVar(`${pre}_${arrayInfo.name}[${arrayDimension}]`);
+            }
+        }
+        for (const field of containerDefinition.fields) {
+            if (field.type === 'shadow' || field.shadowRef || field.library !== this.context) {
+                continue;
+            }
+            // generate defines for array fields
+            if (field.arrayRef !== null) {
+                const ref = containerDefinition.arrays[field.arrayRef.name];
+                let defineName = `${pre}_${field.arrayRef.name}`;
+                // this is a structured array, add the field name to the define
+                if (ref.fields?.length) {
+                    defineName += `_${field.name.split('.')[1]}`;
+                }
+                this.createDefaultDefineForField(defineName, field);
+                continue;
+            }
+            const variableName = this.generateFieldVariableName(pre, field);
+            this.createDefaultDefineForField(variableName, field);
+            this.createGlobalVar(`${variableName}`, field);
+        }
+    }
+    generateCommentForField(field) {
+        const fieldComment = [`@type ${field.type}`];
+        if (field.description) {
+            fieldComment.unshift(field.description);
+        }
+        if (field.defaultValue !== undefined) {
+            const { value, reason } = this.parseFieldDefault(field);
+            fieldComment.push(`@default ${value} ${reason || ''}`);
+        }
+        return fieldComment;
+    }
+    generateFieldVariableName(pre, field) {
+        const fieldVariableName = `${pre}_${field.name}`;
+        const isBlob = Object.hasOwn(fieldTypeDefinitions, field.type) && fieldTypeDefinitions[field.type].isBlob;
+        const dim = field.byteSize;
+        if (dim && isBlob) {
+            const loopVar = 'i';
+            this.sourceType = 'defines';
+            this.pawn(`#define ${pre}_${field.name}_dim    ${dim}`);
+            this.pawn(`#define ${pre}_${field.name}_iter() for(new ${loopVar}=0;${loopVar}<${dim};${loopVar}++)`);
+        }
+        this.sourceType = 'globalVariables';
+        return fieldVariableName;
+    }
+    // generate type declarations
+    // eslint-disable-next-line sonarjs/cognitive-complexity
+    generateTypeDefinitions(containerDefinition, base) {
+        this.sourceType = 'defines';
+        const xfields = containerDefinition.fields;
+        if (!xfields) {
+            return;
+        }
+        const knownArrays = [];
+        this.pawn('>', `#define ${base} [`);
+        for (const field of xfields) {
+            if (field.type === 'shadow' || field.shadowRef) {
+                continue;
+            }
+            // validate context of field
+            if (field.library !== this.context) {
+                continue;
+            }
+            // avoid creating multiple definitions if the field is part of an array
+            const arrayRef = field.arrayRef;
+            if (arrayRef) {
+                const arrayInfo = containerDefinition.arrays[arrayRef.name];
+                if (!knownArrays.includes(arrayRef.name) && !arrayInfo.fields) {
+                    knownArrays.push(arrayRef.name);
+                }
+                else {
+                    continue;
+                }
+            }
+            const fieldName = field.arrayRef ? field.arrayRef.name : field.name;
+            const fld_dim = field.arrayRef ? `[${base}_${fieldName}_dim]` : '';
+            // let comment = fld.xfields ? `${base}_${fld.name}` : fld.type; // original DDE field type as comment
+            let fld_def = '';
+            if (field.type === 'struct') {
+                fld_def = '// .' + fieldName + fld_dim; // comment out if it's a struct field
+            }
+            else {
+                const tdef_pwn = getPawnTypeDefinition(field);
+                if (!tdef_pwn) {
+                    continue;
+                } // error - do nothing
+                if (tdef_pwn === 'skip') {
+                    fld_def = `// skipped - .${fieldName}${fld_dim}`; // '.xyz[5]'
+                }
+                else {
+                    fld_def += tdef_pwn.rwp.replace('%n', `.${fieldName}${fld_dim}`).replace('%l', field.byteSize);
+                }
+            }
+            fld_def += ',';
+            // add library comment if the field comes from an library
+            if (field.library) {
+                fld_def += `\t // declared by ${field.library} library`;
+            }
+            this.pawn(fld_def);
+        }
+        this.pawn('<', ']');
+    }
+    variableNameForPawnDefinition(variableName, field) {
+        // variable name based on the pawn definitions
+        const pawnTypeDefinition = getPawnTypeDefinition(field);
+        if (pawnTypeDefinition && pawnTypeDefinition !== 'skip') {
+            return pawnTypeDefinition.rwp.replace('%n', `${variableName}`).replace('%l', field.byteSize);
+        }
+        return variableName;
+    }
+    createDefaultDefineForField(variableName, field) {
+        this.sourceType = 'defaultDefines';
+        if (field.scale !== undefined) {
+            this.addDefine(this.variableNameForPawnDefinition(`${variableName}_scale`, field), field.scale);
+        }
+        if (field.offset !== undefined) {
+            this.addDefine(this.variableNameForPawnDefinition(`${variableName}_offset`, field), field.offset);
+        }
+        if (field.defaultValue !== undefined) {
+            const { value, reason } = this.parseFieldDefault(field);
+            const defineName = `${variableName}_default`;
+            field.defaultDloDefine = defineName;
+            this.addDefine(defineName, value, reason);
+        }
+    }
+    /**
+     * Add given variable as define to the dlo source
+     * @param name of define
+     * @param value of define
+     * @param reason comment for define
+     * @private
+     */
+    addDefine(name, value, reason) {
+        const containerRelation = regexRelation.exec(`${value}`);
+        if (containerRelation) {
+            return;
+        }
+        if (!this.knownDefines.includes(name)) {
+            if (reason) {
+                this.pawn(`// ${reason}`);
+            }
+            this.pawn(`#define ${name} ${value}`);
+            this.knownDefines.push(name);
+        }
+    }
+    generateReadWriteFunctions(containerDefinition) {
+        const containerName = containerDefinition.name;
+        const CONTDEF = CONTAINER_DEFS[containerName];
+        const pre = `DDE_${containerDefinition.containerType === ContainerType.aloha ? ContainerType.aloha : containerDefinition.title}`;
+        // ---
+        // add write method - but for UP_ward containers only
+        // ---
+        if ([
+            TransferDirection.both,
+            TransferDirection.bothPlus,
+            TransferDirection.none,
+            TransferDirection.deviceOnly,
+            TransferDirection.up,
+            TransferDirection.upPlus
+        ].includes(containerDefinition.transferDirection)) {
+            this.generateWriteMethod(pre, containerDefinition);
+        }
+        // ---
+        // add read method - but for CONFIG0-9 containers only
+        // ---
+        if (CONTDEF.ctype === ContainerType.cx) {
+            this.generateReadMethod(pre, containerDefinition);
+        }
+    }
+    generateWriteMethod(pre, containerDefinition) {
+        this.sourceType = 'readWrite';
+        const containerID = `DDE_${containerDefinition.title}_id`;
+        const isTimeseriesOrAloha = [ContainerType.hx, ContainerType.aloha].includes(containerDefinition.containerType);
+        const isTimeseriesContainer = containerDefinition.containerType === ContainerType.hx;
+        const isAlohaContainer = containerDefinition.containerType === ContainerType.aloha;
+        const funcWrite = `_${pre}_write`;
+        this.pawn('>', `stock ${funcWrite}(${isTimeseriesContainer ? 'const stamp=0' : ''}) {`);
+        // only aloha and time series write directly to the container
+        if (isTimeseriesOrAloha) {
+            this.pawn(`dde_wbegin(DDE_${isAlohaContainer ? ContainerType.aloha : containerDefinition.title}_id);`); // "	dde_wbegin( DDE_status_id);"
+        }
+        this.generateRWFunctionBody(pre, containerDefinition, 'dde_w');
+        // only aloha and time series write directly to the container
+        if (isTimeseriesOrAloha) {
+            this.pawn(`return dde_wend(${isTimeseriesContainer ? 'stamp' : ''});`); // "	dde_wend();"
+        }
+        this.pawn('<', '}');
+        this.pawn('');
+        // flush function
+        this.sourceType = 'globalVariables';
+        const funcFlush = `${pre}_transfer`;
+        const funcPersist = `${pre}_persist`;
+        const funcArgs = this.functionArgumentsForDdeWrite(isTimeseriesContainer, isTimeseriesOrAloha);
+        this.pawn('>', `${this.context ? 'stock ' : ''}${funcFlush}(${funcArgs}) {`);
+        if (isTimeseriesOrAloha) {
+            this.pawn(`${funcWrite}(${isAlohaContainer ? '' : 'stamp'});`);
+        }
+        else {
+            const containerNumber = containerDefinition.name.slice(-1);
+            this.pawn(`dde_flush(${containerNumber}, immediate);`);
+        }
+        this.pawn('<', '}');
+        this.pawn('');
+        if (containerDefinition.volatile) {
+            // generate persist function declaration
+            this.pawn('>', `stock ${funcPersist}() {`);
+            this.pawn(`return rM2M_CfgFlush(${containerID});`);
+            this.pawn('<', '}');
+        }
+    }
+    /**
+     * if it's a timeseries container the argument is `const stamp=0`
+     * if it's a configuration container the argument is `bool:immediate=false`
+     * @param isTimeseriesContainer
+     * @param isTimeseriesOrAloha
+     * @private
+     */
+    functionArgumentsForDdeWrite(isTimeseriesContainer, isTimeseriesOrAloha) {
+        return isTimeseriesContainer ? 'const stamp=0' : isTimeseriesOrAloha ? '' : 'bool:immediate=false';
+    }
+    generateReadMethod(pre, containerDefinition) {
+        this.sourceType = 'readWrite';
+        // const containerID = `${pre}_id`;
+        // todo implement as "hidden" function
+        const funcRead = `_${pre}_read`;
+        this.pawn('>', `stock ${funcRead}() {`);
+        this.generateRWFunctionBody(pre, containerDefinition, 'dde_r');
+        this.pawn('<', '}');
+        this.pawn('');
+    }
+    generateRWFunctionBody(pre, containerDefinition, ddeFunc) {
+        const xfields = containerDefinition.fields;
+        for (const fld of xfields) {
+            // validate context of field
+            if (fld.type === 'shadow' || fld.shadowRef || fld.library !== this.context) {
+                continue;
+            }
+            // assert(!fld.xfields);
+            const tdef_pwn = getPawnTypeDefinition(fld); // pawn access methods to use
+            if (!tdef_pwn || tdef_pwn === 'skip') {
+                continue;
+            }
+            // set the byte offset for the next field
+            this.pawn(`_dde_idx = ${fld.byteOffset};`);
+            let s = ''; // resulting pawn line e.g. "	dde_wu32( o.live_trg);"
+            s += ddeFunc;
+            s += tdef_pwn.rwfunc;
+            const fieldName = `${pre}_${fld.name}`;
+            s += `(${fieldName}`;
+            if (tdef_pwn.rwlen) {
+                s += `, ${fld.byteSize}`;
+            } // add byte/cellcount on strings & buffers
+            // add the default field value to the read function only
+            if (fld.defaultDloDefine !== undefined && ddeFunc === 'dde_r') {
+                s += `, ${fld.defaultDloDefine}`;
+            }
+            this.pawn(s + `);`);
+        }
+    }
+    parseFieldDefault(field) {
+        const typeDefinitions = getPawnTypeDefinition(field);
+        let defaultValue = field.defaultValue;
+        function buildReturnObject(value, reason) {
+            return { value, reason };
+        }
+        //modify the default value based on the string type. Either " or '';
+        switch (field.type) {
+            case 'astring':
+            case 'nstring':
+            case 'cstring': {
+                return buildReturnObject(`"${defaultValue}"`);
+            }
+            case 'wstring': {
+                return buildReturnObject(`''${defaultValue}''`);
+            }
+            case 'ustring': {
+                return buildReturnObject(`/* default not supported: ${defaultValue} */`);
+            }
+            case 'binary': {
+                // convert hex value to byte array equivalent...
+                const splitted = defaultValue.substring(2).match(/.{1,2}/g) || [];
+                const byteArray = `{ 0x${splitted.join(', 0x')} }`;
+                return buildReturnObject(byteArray);
+            }
+        }
+        if (defaultValue === 'NaN') {
+            const dataType = typeDefinitions.rwfunc;
+            return buildReturnObject(`${dataType}_NaN`.toUpperCase());
+        }
+        const scaledDefault = this.parseFieldScaleOffset(field);
+        if (scaledDefault) {
+            return buildReturnObject(scaledDefault.calculated, scaledDefault.reason);
+        }
+        // add missing fractionDigits to float types
+        if (defaultValue !== undefined &&
+            !regexRelation.exec(`${defaultValue}`) &&
+            field.type.startsWith('float') &&
+            defaultValue % 1 === 0) {
+            defaultValue = defaultValue.toFixed(field.decimalPlaces || 1);
+        }
+        return buildReturnObject(`${defaultValue}`);
+    }
+    /**
+     * Try to calculate the default value based on scale and offset
+     * @param field
+     * @private
+     */
+    parseFieldScaleOffset(field) {
+        const defaultValue = field.defaultValue;
+        // validate if any of the given fields has a relation to another container
+        const isAnyRelation = !!regexRelation.exec(`${field.offset}`) ||
+            !!regexRelation.exec(`${field.scale}`) ||
+            !!regexRelation.exec(`${field.defaultValue}`);
+        // scale || offset is set
+        if (!isAnyRelation && (field.offset !== undefined || field.scale !== undefined)) {
+            const offset = field.offset !== undefined ? Number(field.offset) : 0;
+            const scale = field.scale !== undefined ? Number(field.scale) : 1;
+            // calculate the original value without scale and offset
+            let calculated = (Number(defaultValue) - offset) / scale;
+            let reason = `(defaultValue - offset) / scale -> (${defaultValue} - ${offset}) / ${scale}`;
+            // field type is no float - round to integer
+            if (!field.type.startsWith('float')) {
+                calculated = Math.round(calculated);
+                reason = `Rounded value of: ${reason}`;
+            }
+            else if (calculated % 1 === 0) {
+                calculated = calculated.toFixed(1);
+            }
+            return { calculated, reason };
+        }
+        return null;
+    }
+}
+exports.AutoDDEGenerator = AutoDDEGenerator;
+// eslint-disable-next-line sonarjs/cognitive-complexity
+function generateAutoUplinkIncFromMap(ddeMap, 
+/**
+ * The names of the included libraries
+ */
+includedLibNames) {
+    const _pwn = [];
+    const pwn = _pwn.push.bind(_pwn);
+    // collect containers to apply/restore23
+    const containerApply = [];
+    const containerRestore = [];
+    function buildUplinkApplyCall(applyName) {
+        const funcName = `onUplinkApply_${applyName}()`;
+        return `${funcName};`;
+    }
+    function buildLibraryRestoreApplyCall(cont, restoreApply) {
+        cont.libraries.forEach(libraryName => {
+            const hashedLib = helper_1.Helper.generateHashForLibraryName(libraryName);
+            pwn(`\t#ifdef _${hashedLib}${restoreApply}_${cont.title}`);
+            pwn(`\t\t_${hashedLib}${restoreApply}_${cont.title}();\t// ${libraryName}`);
+            pwn('\t#endif');
+        });
+    }
+    //generate onUplinkEvent dispatcher
+    pwn(`stock _onUplinkEvent(ev, param) {`);
+    // insert library calls...
+    includedLibNames.forEach(libraryName => {
+        const hashedName = helper_1.Helper.generateHashForLibraryName(libraryName);
+        const funcName = `_${hashedName}UplinkEvent`;
+        pwn(`\t#ifdef ${funcName}`);
+        pwn(`\t\t${funcName}(ev, param);`);
+        pwn(`\t#endif`);
+    });
+    pwn(`\tonUplinkEvent(ev, param);`);
+    pwn(`}`);
+    for (const [containerName, containerDefinition] of Object.entries(ddeMap.containers)) {
+        const CONTDEF = CONTAINER_DEFS[containerName];
+        if (CONTDEF.ctype !== ContainerType.cx) {
+            continue;
+        }
+        if ([TransferDirection.up, TransferDirection.upPlus, TransferDirection.deviceOnly].includes(containerDefinition.transferDirection)) {
+            containerRestore.push(containerDefinition);
+        }
+        if ([TransferDirection.bothPlus, TransferDirection.both, TransferDirection.downPlus, TransferDirection.down].includes(containerDefinition.transferDirection)) {
+            containerApply.push(containerDefinition);
+        }
+    }
+    if (containerRestore.length) {
+        pwn('');
+    }
+    // generate restore code
+    for (const cont of containerRestore) {
+        cont.knownNames.forEach((libAlias) => {
+            pwn(`forward onUplinkRestore_${libAlias}();`);
+        });
+        pwn('');
+        pwn(`stock restoreUplink${cont.name}() {`);
+        pwn(`\t_DDE_${cont.name}_read();`);
+        buildLibraryRestoreApplyCall(cont, 'Restore');
+        if (coreDefinitions_1.DDE_Core.hasContainerAppFields(cont)) {
+            pwn(`\tonUplinkRestore_${cont.title}();`);
+        }
+        pwn(`}`);
+    }
+    pwn(`#pragma warning push`);
+    pwn(`stock _onUplinkRestore(cfgId) {`);
+    if (containerRestore.length) {
+        pwn(`\tswitch(cfgId) {`);
+        for (const cont of containerRestore) {
+            pwn(`\t\tcase DDE_${cont.title}_id: restoreUplink${cont.name}(); // ${cont.name}`);
+        }
+        pwn(`\t}`);
+    }
+    else {
+        pwn(`\t#pragma warning disable 203`);
+        pwn(`\t// no containers to restore`);
+    }
+    pwn(`}`);
+    pwn(`#pragma warning pop`);
+    if (containerApply.length) {
+        pwn('');
+    }
+    // generate apply code
+    for (const cont of containerApply) {
+        cont.knownNames.forEach((libAlias) => {
+            pwn(`forward onUplinkApply_${libAlias}();`);
+        });
+        pwn('');
+        pwn(`stock applyUplink${cont.name}() {`);
+        pwn(`\t_DDE_${cont.name}_read();`);
+        buildLibraryRestoreApplyCall(cont, 'Apply');
+        if (coreDefinitions_1.DDE_Core.hasContainerAppFields(cont)) {
+            pwn(`\t${buildUplinkApplyCall(cont.title)}`);
+        }
+        pwn(`\treturn(OK);`);
+        pwn(`}`);
+    }
+    pwn(`#pragma warning push`);
+    pwn(`stock _onUplinkApply(cfgId) {`);
+    if (containerApply.length) {
+        pwn(`\tswitch(cfgId) {`);
+        for (const cont of containerApply) {
+            pwn(`\t\tcase DDE_${cont.title}_id: return applyUplink${cont.name}(); // ${cont.name}`);
+        }
+        pwn(`\t}`);
+        pwn(`\treturn ERROR;`);
+    }
+    else {
+        pwn(`\t#pragma warning disable 203`);
+        pwn(`\t// no containers to apply`);
+        pwn(`\treturn OK;`);
+    }
+    pwn(`}`);
+    pwn(`#pragma warning pop`);
+    return _pwn.join('\n');
+}
+const ALL_CONFIG_WRITE_NAMES = CONFIG_CONTAINER.map(containerName => `_DDE_${containerName}_write`);
+function generateMainDDEIncFromMap(ddeMap) {
+    const _pawnSource = [];
+    const pawnSource = _pawnSource.push.bind(_pawnSource);
+    const dummyWriteFunctions = [...ALL_CONFIG_WRITE_NAMES];
+    for (const [containerName, containerDefinition] of Object.entries(ddeMap.containers)) {
+        const cid_base = CONTAINER_DEF_DLO_CID_BASE(containerDefinition.containerType, containerDefinition.transferDirection);
+        const CONTDEF = CONTAINER_DEFS[containerName];
+        if (!cid_base || !containerDefinition.fields || CONTDEF.ctype !== ContainerType.cx) {
+            //container is not available in dlo
+            continue;
+        }
+        const pre = `DDE_${containerDefinition.name}`;
+        const containerID = `DDE_${containerDefinition.title}_id`;
+        // ---
+        // add write method - but for configuration UP_ward containers only
+        // ---
+        if ([
+            TransferDirection.both,
+            TransferDirection.bothPlus,
+            TransferDirection.none,
+            TransferDirection.deviceOnly,
+            TransferDirection.up,
+            TransferDirection.upPlus
+        ].includes(containerDefinition.transferDirection)) {
+            const funcWrite = `_${pre}_write`;
+            // pawnSource(`#define ${funcWrite}_def 01`);
+            pawnSource(`stock ${funcWrite}() {`);
+            pawnSource(`\tdde_wbegin(${containerID});`);
+            generateMainDDEFunctionBody(pawnSource, containerDefinition, 'write');
+            pawnSource(`\treturn dde_wend();`);
+            pawnSource(`}`);
+            // remove from dummy array
+            dummyWriteFunctions.splice(dummyWriteFunctions.indexOf(funcWrite), 1);
+        }
+        // ---
+        // add read method - but for CONFIG0-9 containers only
+        // ---
+        if (CONTDEF.ctype === ContainerType.cx) {
+            const funcRead = `_${pre}_read`;
+            pawnSource(`stock ${funcRead}() {`);
+            pawnSource(`\tif (dde_rbegin(${containerID})) return ERROR;`);
+            generateMainDDEFunctionBody(pawnSource, containerDefinition, 'read');
+            pawnSource(`\tdde_rend();`);
+            pawnSource('\treturn OK;');
+            pawnSource(`}`);
+        }
+    }
+    if (dummyWriteFunctions.length) {
+        pawnSource('');
+        pawnSource(`// Dummy functions needed by the dde library`);
+        for (const dummyFunc of dummyWriteFunctions) {
+            pawnSource(`stock ${dummyFunc}() { return OK; }`);
+        }
+    }
+    return _pawnSource.join('\n');
+}
+function generateMainDDEFunctionBody(pawnSource, containerDefinition, readWrite) {
+    containerDefinition.libraries.forEach(libraryName => {
+        const libraryHash = helper_1.Helper.generateHashForLibraryName(libraryName);
+        pawnSource(`\t#ifdef __${libraryHash}${containerDefinition.title}_${readWrite}`);
+        pawnSource(`\t\t__${libraryHash}${containerDefinition.title}_${readWrite}();`);
+        pawnSource(`\t#endif`);
+    });
+    if (coreDefinitions_1.DDE_Core.hasContainerAppFields(containerDefinition)) {
+        pawnSource(`\t#ifdef _DDE_${containerDefinition.title}_${readWrite}`);
+        pawnSource(`\t\t_DDE_${containerDefinition.title}_${readWrite}();`);
+        pawnSource(`\t#endif`);
+    }
+}
+//# sourceMappingURL=dlo.js.map