@microtronics/studio-cli 0.60.0 → 0.62.0

package/out/dde/fileGenerators/dlo.js

@@ -1,1007 +0,0 @@
-"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.getPawnTypeDefinition = getPawnTypeDefinition;
-exports.generateAutoIncFromMap = generateAutoIncFromMap;
-exports.generateAutoUplinkIncFromMap = generateAutoUplinkIncFromMap;
-exports.generateMainDDEIncFromMap = generateMainDDEIncFromMap;
-exports.buildDefaultInc = buildDefaultInc;
-const semver = __importStar(require("semver"));
-const coreDefinitions_1 = require("../coreDefinitions");
-const DeviceProfiles_1 = require("../../DeviceProfiles");
-const manifest_1 = require("../../manifest");
-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;
-const vscode_uri_1 = require("vscode-uri");
-const defaultFiles_1 = require("../../defaultFiles");
-const dependencies_1 = require("../../dependencies");
-var isNumeric = helper_1.Helper.isNumeric;
-const apm_1 = require("../../package/apm");
-/** 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;
-}
-const MICROTRONICS_DLO_CORE = 'Microtronics/dlo-core';
-function getIncludedDloCoreVersion(manifest) {
-    if (manifest_1.Manifest.isLibrary(manifest) && manifest.name === 'dlo-core') {
-        return manifest.version;
-    }
-    else if (manifest.libraryDependencies && Object.hasOwn(manifest.libraryDependencies, MICROTRONICS_DLO_CORE)) {
-        return dependencies_1.Dependencies.rangeToVersion(manifest.libraryDependencies[MICROTRONICS_DLO_CORE]);
-    }
-    else if (manifest.libraryDevDependencies && Object.hasOwn(manifest.libraryDevDependencies, MICROTRONICS_DLO_CORE)) {
-        return dependencies_1.Dependencies.rangeToVersion(manifest.libraryDevDependencies[MICROTRONICS_DLO_CORE]);
-    }
-    return null;
-}
-function getApmVersion(manifest) {
-    const requiredVersion = getIncludedDloCoreVersion(manifest);
-    if (requiredVersion === null || semver.gte(requiredVersion, '0.3.0')) {
-        return semver.valid(manifest.version) ? manifest.version : semver.coerce(`${manifest.version}`);
-    }
-    else {
-        return semver.coerce(manifest.version)?.major;
-    }
-}
-/**
- * Determines if the dlo-core library version described in the provided manifest supports live data functionality.
- *
- * @param {Manifest.Manifest} manifest - The manifest object containing details about the DLO core.
- * @return {boolean} Returns true if the dlo-core version supports live data, otherwise false.
- */
-function dloCoreSupportsFlags(manifest) {
-    const requiredVersion = getIncludedDloCoreVersion(manifest);
-    if (requiredVersion === null) {
-        return false;
-    }
-    const releaseVersion = semver.coerce(requiredVersion);
-    return semver.gte(releaseVersion, '1.1.0');
-}
-// eslint-disable-next-line sonarjs/cognitive-complexity
-function generateAutoIncFromMap(ddeMap, resolvedConfig, 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');
-    function addDefinition(name, value, noString = false) {
-        let quotes = isNumeric(value) ? '' : '"';
-        if (noString) {
-            quotes = '';
-        }
-        pwn(`#define ${name} ${quotes}${value}${quotes}`);
-    }
-    const { dpid, registry } = manifest;
-    if (!dpid) {
-        throw new Error('Setting "dpid" is required to generate dlo files');
-    }
-    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 || ''); //
-    const currVersion = getApmVersion(manifest);
-    addDefinition(`APM_VERSION`, `${currVersion}`); // 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
-     */
-    const globalDefines = resolvedConfig.flat;
-    const { definesWithSource } = resolvedConfig;
-    pwn_section('GLOBAL DEFINES');
-    for (const [define, value] of Object.entries(globalDefines)) {
-        const comment = definesWithSource[define]?.comment;
-        if (comment) {
-            const lines = comment.split('\n');
-            if (lines.length === 1) {
-                pwn(`/** ${lines[0]} */`);
-            }
-            else {
-                pwn('/**');
-                for (const line of lines) {
-                    pwn(` * ${line}`);
-                }
-                pwn(' */');
-            }
-        }
-        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 {
-    manifest;
-    ddeMap;
-    context;
-    globalVariables = [];
-    pawnGlobalSource = [];
-    pawnHelperSource = [];
-    timeSeriesSource = [];
-    readWriteSource = [];
-    definesSource = [];
-    defaultDefinesSource = [];
-    knownDefines = [];
-    pawnIndent = 0;
-    sourceType;
-    constructor(manifest, ddeMap, context) {
-        this.manifest = manifest;
-        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(`${variableName}_scale`, field.scale);
-        }
-        if (field.offset !== undefined) {
-            this.addDefine(`${variableName}_offset`, 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`;
-        const timeseriesFlags = dloCoreSupportsFlags(this.manifest) ? ', flags' : '';
-        const timeseriesOrAlohaArguments = isTimeseriesContainer ? `stamp${timeseriesFlags}` : '';
-        const funcWriteFlags = dloCoreSupportsFlags(this.manifest) ? 'const stamp=0, const flags=0' : 'const stamp=0';
-        this.pawn('>', `stock ${funcWrite}(${isTimeseriesContainer ? funcWriteFlags : ''}) {`);
-        // 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(${timeseriesOrAlohaArguments});`); // "	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}(${timeseriesOrAlohaArguments});`);
-        }
-        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) {
-        const timeseriesFlags = dloCoreSupportsFlags(this.manifest) ? ', const flags=0' : '';
-        return isTimeseriesContainer
-            ? `const stamp=0${timeseriesFlags}`
-            : 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`);
-    }
-}
-/**
- * Default INC handling
- */
-/**
- * Generate the default.inc file
- * @param cwd
- * @param fs
- */
-async function buildDefaultInc(cwd, fs) {
-    const fileContent = [];
-    const dloLibs = await dependencies_1.Dependencies.getApmPartDependencies(cwd, fs, apm_1.APM.Part.dlo);
-    await addInclude(cwd, fs, fileContent, defaultFiles_1.DefaultFiles.fileNames.autoInc);
-    const autoDdeIncs = await getAutoDDEIncludes(cwd, fs, dloLibs);
-    for (const dloLib of dloLibs) {
-        // todo use relative path as include?
-        if (dloLib.name === 'local-data-interface') {
-            await addInclude(cwd, fs, fileContent, defaultFiles_1.DefaultFiles.fileNames.autoLocalDataInc);
-        }
-        fileContent.push(`#include <${dloLib.name}>`);
-        if (dloLib.name === 'dlo-core') {
-            fileContent.push(...autoDdeIncs);
-            await addInclude(cwd, fs, fileContent, defaultFiles_1.DefaultFiles.fileNames.autoDdeInc.replace('X', 'app'));
-            await addInclude(cwd, fs, fileContent, defaultFiles_1.DefaultFiles.fileNames.autoDdeInc.replace('X', 'main'));
-            await addInclude(cwd, fs, fileContent, defaultFiles_1.DefaultFiles.fileNames.autoUplinkInc);
-        }
-    }
-    return fileContent.join('\n');
-}
-/**
- * Get all <library-name>-dde.inc files
- * @param cwd
- * @param fs
- * @param dependencies
- */
-async function getAutoDDEIncludes(cwd, fs, dependencies) {
-    const includes = [];
-    for (const dependency of dependencies) {
-        const includePath = defaultFiles_1.DefaultFiles.filePaths.studio.auto.dlo.autoDdeInc.replace('X', dependency.name);
-        if (await fs.stat(vscode_uri_1.Utils.joinPath(cwd, includePath))) {
-            includes.push(`#include "${defaultFiles_1.DefaultFiles.fileNames.autoDdeInc.replace('X', dependency.name)}"`);
-        }
-    }
-    return includes;
-}
-/**
- * Validate if the given file exist within the .studio/auto/dlo directory
- */
-async function addInclude(cwd, fs, fileContent, fileName) {
-    const basePath = vscode_uri_1.Utils.joinPath(cwd, defaultFiles_1.DefaultFiles.filePaths.studio.auto.dlo.path, fileName);
-    if (await fs.stat(basePath)) {
-        fileContent.push(`#include "${fileName}"`);
-    }
-}
-//# sourceMappingURL=dlo.js.map