@microtronics/studio-cli 0.57.0 → 0.59.0

package/dist/studio-cli.d.ts

@@ -1766,6 +1766,7 @@ export declare namespace DefaultFiles {
         autoUplinkInc: string;
         autoDdeInc: string;
         mainDdeInc: string;
+        autoLocalDataInc: string;
         legacyAutoInc: string;
         legacyAutoDdeInc: string;
         legacyAutoUplinkInc: string;
@@ -1782,6 +1783,7 @@ export declare namespace DefaultFiles {
                     autoInc: string;
                     defaultInc: string;
                     autoUplinkInc: string;
+                    autoLocalDataInc: string;
                     autoDdeInc: string;
                     mainDdeInc: string;
                     legacyAutoInc: string;

package/out/dde/coreDefinitions.js

@@ -307,7 +307,7 @@ var DDE_Core;
             ...DDE_Core.TDEF_NUMBER,
             rdef: 1,
             xml: { type: 'u8' },
-            pwn: { rwfunc: 'u8', htype: 's32' },
+            pwn: { rwfunc: 'u8', htype: 's32', printf: '%d' },
             openApi: { type: 'number', minimum: 0 }
         },
         u16: {
@@ -317,7 +317,7 @@ var DDE_Core;
             ...DDE_Core.TDEF_NUMBER,
             rdef: 1,
             xml: { type: 'u16' },
-            pwn: { rwfunc: 'u16', htype: 's32' },
+            pwn: { rwfunc: 'u16', htype: 's32', printf: '%d' },
             openApi: { type: 'number', minimum: 0 }
         },
         u32: {
@@ -327,7 +327,7 @@ var DDE_Core;
             ...DDE_Core.TDEF_NUMBER,
             rdef: 1,
             xml: { type: 'u32' },
-            pwn: { rwfunc: 'u32', htype: 's32' },
+            pwn: { rwfunc: 'u32', htype: 's32', printf: '%d' },
             openApi: { type: 'number', minimum: 0 }
         },
         // u64 - does not exist / not supported by backend
@@ -338,7 +338,7 @@ var DDE_Core;
             ...DDE_Core.TDEF_NUMBER,
             rdef: 1,
             xml: { type: 's8' },
-            pwn: { rwfunc: 's8', htype: 's32' },
+            pwn: { rwfunc: 's8', htype: 's32', printf: '%d' },
             openApi: { type: 'number' }
         },
         s16: {
@@ -348,7 +348,7 @@ var DDE_Core;
             ...DDE_Core.TDEF_NUMBER,
             rdef: 1,
             xml: { type: 's16' },
-            pwn: { rwfunc: 's16', htype: 's32' },
+            pwn: { rwfunc: 's16', htype: 's32', printf: '%d' },
             openApi: { type: 'number' }
         },
         s32: {
@@ -358,7 +358,7 @@ var DDE_Core;
             ...DDE_Core.TDEF_NUMBER,
             rdef: 1,
             xml: { type: 's32' },
-            pwn: { rwfunc: 's32' },
+            pwn: { rwfunc: 's32', printf: '%d' },
             openApi: { type: 'number' }
         },
         s64: {
@@ -368,7 +368,7 @@ var DDE_Core;
             ...DDE_Core.TDEF_NUMBER,
             rdef: 1,
             xml: { type: 's64' },
-            pwn: { rwfunc: 's64', rwp: '%n{%l}', htype: '{%l}' },
+            pwn: { rwfunc: 's64', rwp: '%n{%l}', htype: '{%l}', printf: '%d' },
             openApi: { type: 'number' }
         },
         f16: {
@@ -378,7 +378,7 @@ var DDE_Core;
             ...DDE_Core.TDEF_NUMBER,
             rdef: 1,
             xml: { type: 'floatm16' },
-            pwn: { rwfunc: 'f16', rwp: 'Float:%n', htype: 'f32' },
+            pwn: { rwfunc: 'f16', rwp: 'Float:%n', htype: 'f32', printf: '%f' },
             openApi: { type: 'number' }
         },
         f32: {
@@ -388,7 +388,7 @@ var DDE_Core;
             ...DDE_Core.TDEF_NUMBER,
             rdef: 1,
             xml: { type: 'f32' },
-            pwn: { rwfunc: 'f32', rwp: 'Float:%n' },
+            pwn: { rwfunc: 'f32', rwp: 'Float:%n', printf: '%f' },
             openApi: { type: 'number' }
         },
         f64: {
@@ -398,7 +398,7 @@ var DDE_Core;
             ...DDE_Core.TDEF_NUMBER,
             rdef: 0,
             xml: { type: 'f64' },
-            pwn: { rwfunc: 'f64', rwp: '%n{%l}', htype: '{%l}' },
+            pwn: { rwfunc: 'f64', rwp: '%n{%l}', htype: '{%l}', printf: '%f' },
             openApi: { type: 'number' }
         },
         stamp32: {
@@ -408,7 +408,7 @@ var DDE_Core;
             ...TDEF_STAMP,
             rdef: 0,
             xml: { type: 'stamp4' },
-            pwn: { rwfunc: 'stamp32' },
+            pwn: { rwfunc: 'stamp32', printf: '%s', printfFormat: 'stampToISOString' },
             openApi: { type: 'string', format: 'YYYYMMDDhhmmssSSS', description: 'UTC' }
         },
         stamp40: {
@@ -418,7 +418,7 @@ var DDE_Core;
             ...TDEF_STAMP,
             rdef: 0,
             xml: { type: 'stamp' },
-            pwn: { rwfunc: 'stamp40', rwp: '%n{%l}', htype: '{%l}' },
+            pwn: { rwfunc: 'stamp40', rwp: '%n{%l}', htype: '{%l}', printf: '%s', printfFormat: 'stampToISOString' },
             openApi: { type: 'string', format: 'YYYYMMDDhhmmssSSS', description: 'UTC' }
         },
         bin: {
@@ -428,7 +428,7 @@ var DDE_Core;
             rdef: 0,
             lenUnits: 'byte',
             xml: { type: 'string', editmask: '%HEX%' },
-            pwn: { rwfunc: 'bin', rwlen: 1, rwp: '%n{%l}', htype: '{%l}' },
+            pwn: { rwfunc: 'bin', rwlen: 1, rwp: '%n{%l}', htype: '{%l}', printf: null, printfFormat: 'memtostr' },
             openApi: { type: 'string', description: 'HEX string' }
         },
         astr: {
@@ -438,7 +438,7 @@ var DDE_Core;
             rdef: 1,
             lenUnits: 'char',
             xml: { type: 'string', param1: 'nocodepage' },
-            pwn: { rwfunc: 'astr', rwlen: 1, rwp: '%n{%l+1}', htype: '{%l+1}' },
+            pwn: { rwfunc: 'astr', rwlen: 1, rwp: '%n{%l+1}', htype: '{%l+1}', printf: '%s' },
             openApi: { type: 'string' }
         },
         nstr: {
@@ -448,7 +448,7 @@ var DDE_Core;
             rdef: 1,
             lenUnits: 'byte',
             xml: { type: 'string' },
-            pwn: { rwfunc: 'nstr', rwlen: 1, rwp: '%n{%l+1}', htype: '{%l+1}' },
+            pwn: { rwfunc: 'nstr', rwlen: 1, rwp: '%n{%l+1}', htype: '{%l+1}', printf: '%s' },
             openApi: { type: 'string' }
         },
         wstr: {
@@ -458,7 +458,7 @@ var DDE_Core;
             rdef: 1,
             lenUnits: 'byte',
             xml: { type: 'string' },
-            pwn: { rwfunc: 'wstr', rwlen: 1, rwp: '%n[%l+1]', htype: '[%l+1]' },
+            pwn: { rwfunc: 'wstr', rwlen: 1, rwp: '%n[%l+1]', htype: '[%l+1]', printf: '%s' },
             openApi: { type: 'string' }
         },
         ustr: {
@@ -468,7 +468,7 @@ var DDE_Core;
             rdef: 0,
             lenUnits: 'byte',
             xml: { type: 'string' },
-            pwn: { rwfunc: 'ustr', rwlen: 1, rwp: '%n{%l+1}', htype: '{%l+1}' },
+            pwn: { rwfunc: 'ustr', rwlen: 1, rwp: '%n{%l+1}', htype: '{%l+1}', printf: '%s' },
             openApi: { type: 'string' }
         },
         cstr: {
@@ -478,7 +478,7 @@ var DDE_Core;
             rdef: 1,
             lenUnits: 'char',
             xml: { type: 'string', editmask: '%HEX%' },
-            pwn: { rwfunc: 'cstr', rwlen: 1, rwp: '%n{%l+1}', htype: '{%l+1}' },
+            pwn: { rwfunc: 'cstr', rwlen: 1, rwp: '%n{%l+1}', htype: '{%l+1}', printf: '%s' },
             openApi: { type: 'string' }
         },
         //                                                                                                                                          ^^^

package/out/dde/dde.js

@@ -44,6 +44,7 @@ const api_1 = require("./fileGenerators/api");
 const helper_1 = require("../helper");
 const registryAPI_1 = require("../registryAPI");
 var yamlRangeToLineInformation = helper_1.Helper.yamlRangeToLineInformation;
+const dloLocalData_1 = require("./fileGenerators/dloLocalData");
 exports.DDE_PATH = defaultFiles_1.DefaultFiles.filePaths.dde.path;
 // create file cache.
 // yaml & json
@@ -413,12 +414,16 @@ var DDE;
         }
         const mainDDEInc = (0, dlo_1.generateMainDDEIncFromMap)(ddeJSON);
         const autoUplink = (0, dlo_1.generateAutoUplinkIncFromMap)(ddeJSON, dependencies.map(dep => dep.libraryName));
+        const autoLocalData = (0, dloLocalData_1.generateDloLocalDataIncFromMap)(ddeJSON);
         const autoIncPath = vscode_uri_1.Utils.joinPath(cwd, defaultFiles_1.DefaultFiles.filePaths.studio.auto.dlo.autoInc);
         await fs.writeFile(autoIncPath, autoInc);
         logger.log(`Generated`, defaultFiles_1.DefaultFiles.filePaths.studio.auto.dlo.autoInc);
         const autoUplinkIncPath = vscode_uri_1.Utils.joinPath(cwd, defaultFiles_1.DefaultFiles.filePaths.studio.auto.dlo.autoUplinkInc);
         await fs.writeFile(autoUplinkIncPath, autoUplink);
         logger.log(`Generated`, defaultFiles_1.DefaultFiles.filePaths.studio.auto.dlo.autoUplinkInc);
+        const autoLocalDataIncPath = vscode_uri_1.Utils.joinPath(cwd, defaultFiles_1.DefaultFiles.filePaths.studio.auto.dlo.autoLocalDataInc);
+        await fs.writeFile(autoLocalDataIncPath, autoLocalData);
+        logger.log(`Generated`, defaultFiles_1.DefaultFiles.filePaths.studio.auto.dlo.autoLocalDataInc);
         const autoDdeAppPath = vscode_uri_1.Utils.joinPath(cwd, defaultFiles_1.DefaultFiles.filePaths.studio.auto.dlo.autoDdeInc.replace('X', 'app'));
         await fs.writeFile(autoDdeAppPath, [...appDDEInc.globals, ...appDDEInc.helper].join('\n'));
         logger.log('Generated', defaultFiles_1.DefaultFiles.filePaths.studio.auto.dlo.autoDdeInc.replace('X', 'app'));

package/out/dde/fileGenerators/dlo.js

@@ -24,6 +24,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AutoDDEGenerator = void 0;
+exports.getPawnTypeDefinition = getPawnTypeDefinition;
 exports.generateAutoIncFromMap = generateAutoIncFromMap;
 exports.generateAutoUplinkIncFromMap = generateAutoUplinkIncFromMap;
 exports.generateMainDDEIncFromMap = generateMainDDEIncFromMap;
@@ -535,10 +536,10 @@ class AutoDDEGenerator {
     createDefaultDefineForField(variableName, field) {
         this.sourceType = 'defaultDefines';
         if (field.scale !== undefined) {
-            this.addDefine(this.variableNameForPawnDefinition(`${variableName}_scale`, field), field.scale);
+            this.addDefine(`${variableName}_scale`, field.scale);
         }
         if (field.offset !== undefined) {
-            this.addDefine(this.variableNameForPawnDefinition(`${variableName}_offset`, field), field.offset);
+            this.addDefine(`${variableName}_offset`, field.offset);
         }
         if (field.defaultValue !== undefined) {
             const { value, reason } = this.parseFieldDefault(field);
@@ -965,6 +966,9 @@ async function buildDefaultInc(cwd, fs) {
     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);

package/out/dde/fileGenerators/dloLocalData.js

@@ -0,0 +1,384 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDloLocalDataIncFromMap = generateDloLocalDataIncFromMap;
+const coreDefinitions_1 = require("../coreDefinitions");
+var TransferDirection = coreDefinitions_1.DDE_Core.TransferDirection;
+const dlo_1 = require("./dlo");
+const helper_1 = require("../../helper");
+const PAWN_SZTEMP_DECL = '\tnew szTemp{64};';
+const PAWN_STRCAT_RETURN = '\treturn strcat(aData, szTemp, sizeof(szTemp));';
+/**
+ * Determines if a field type can use a format helper function, and which one.
+ * Returns null if the field type needs inline code (packed types, wstring, etc.)
+ */
+function getHelperFormatType(tdefPwn) {
+    // Binary (memtostr) fields - check before printf since printf is null for binary
+    if (!tdefPwn.printf && tdefPwn.printfFormat === 'memtostr') {
+        return 'bin';
+    }
+    if (!tdefPwn.printf) {
+        return null;
+    }
+    const rwp = tdefPwn.rwp || '%n';
+    const hasCellArray = rwp.includes('[');
+    const hasPackedArray = rwp.includes('{');
+    const isComplex = hasPackedArray || hasCellArray;
+    if (tdefPwn.printfFormat === 'stampToISOString') {
+        return isComplex ? null : 'stamp';
+    }
+    switch (tdefPwn.printf) {
+        case '%d':
+            return isComplex ? null : 'd';
+        case '%f':
+            return isComplex ? null : 'f';
+        case '%s':
+            return hasCellArray ? null : 's';
+        default:
+            return null;
+    }
+}
+/**
+ * Gets the format type for a field, handling shadow/skip filtering.
+ * Returns null if the field should be skipped or needs inline code.
+ */
+function getFieldFormatType(field) {
+    if (field.type === 'shadow' || field.shadowRef) {
+        return null;
+    }
+    const tdefPwn = (0, dlo_1.getPawnTypeDefinition)(field);
+    if (!tdefPwn || tdefPwn === 'skip') {
+        return null;
+    }
+    return getHelperFormatType(tdefPwn);
+}
+/**
+ * Checks if a container is device-side (hx or cx) and not backend-only.
+ */
+function isDeviceContainer(containerDefinition) {
+    return ([coreDefinitions_1.DDE_Core.ContainerType.hx, coreDefinitions_1.DDE_Core.ContainerType.cx].includes(containerDefinition.containerType) &&
+        containerDefinition.transferDirection !== TransferDirection.backendOnly);
+}
+/**
+ * Checks if a field is valid for code generation (not shadow, not skipped).
+ */
+function isValidField(field) {
+    if (field.type === 'shadow' || field.shadowRef) {
+        return false;
+    }
+    const tdefPwn = (0, dlo_1.getPawnTypeDefinition)(field);
+    return !!tdefPwn && tdefPwn !== 'skip';
+}
+/**
+ * Adds an array field to the appropriate group in the group map.
+ */
+function addFieldToGroup(field, formatType, groupMap) {
+    const bracketEnd = field.name.indexOf(']');
+    const subField = bracketEnd >= 0 ? field.name.substring(bracketEnd + 1) : '';
+    const groupKey = `${field.arrayRef.name}|${subField}|${formatType}`;
+    if (!groupMap.has(groupKey)) {
+        groupMap.set(groupKey, { fields: [], formatType });
+    }
+    groupMap.get(groupKey).fields.push(field);
+}
+/**
+ * Classifies fields into array-groupable and standalone categories.
+ */
+function classifyFields(fields) {
+    const standaloneFields = [];
+    const groupMap = new Map();
+    const usedFormats = new Set();
+    let hasInlineFields = false;
+    for (const field of fields) {
+        if (!isValidField(field)) {
+            continue;
+        }
+        const formatType = getFieldFormatType(field);
+        if (field.arrayRef && formatType) {
+            addFieldToGroup(field, formatType, groupMap);
+        }
+        else {
+            standaloneFields.push(field);
+            if (formatType) {
+                usedFormats.add(formatType);
+            }
+            else {
+                hasInlineFields = true;
+            }
+        }
+    }
+    return { standaloneFields, groupMap, usedFormats, hasInlineFields };
+}
+/**
+ * Converts a group map entry into an ArrayFieldGroup if it has consistent stepping.
+ * Returns null if the group should be treated as standalone fields.
+ */
+function tryBuildArrayGroup(containerTitle, groupKey, groupFields) {
+    groupFields.sort((a, b) => a.arrayRef.index - b.arrayRef.index);
+    const offsets = groupFields.map(f => f.byteOffset);
+    const step = offsets[1] - offsets[0];
+    const isConsistent = step > 0 && offsets.every((o, i) => i === 0 || o - offsets[i - 1] === step);
+    if (!isConsistent) {
+        return null;
+    }
+    const [arrayName, subField] = groupKey.split('|');
+    const fieldNamePrefix = groupFields[0].library
+        ? `_${helper_1.Helper.generateHashForLibraryName(groupFields[0].library)}`
+        : 'DDE_';
+    return {
+        arrayName,
+        subField,
+        fields: groupFields,
+        startOffset: offsets[0],
+        endOffset: offsets[offsets.length - 1],
+        step,
+        formatType: getFieldFormatType(groupFields[0]),
+        pawnVarBase: `${fieldNamePrefix}${containerTitle}_${arrayName}`
+    };
+}
+/**
+ * Analyzes container fields and groups array elements that can be collapsed
+ * into arithmetic if-blocks for reduced AMX binary size.
+ */
+function analyzeContainerFields(containerTitle, fields) {
+    const { standaloneFields, groupMap, usedFormats, hasInlineFields } = classifyFields(fields);
+    const arrayGroups = [];
+    for (const [groupKey, groupData] of groupMap) {
+        const { fields: groupFields, formatType } = groupData;
+        if (groupFields.length < 2) {
+            standaloneFields.push(...groupFields);
+            usedFormats.add(formatType);
+            continue;
+        }
+        const group = tryBuildArrayGroup(containerTitle, groupKey, groupFields);
+        if (group) {
+            usedFormats.add(formatType);
+            arrayGroups.push(group);
+        }
+        else {
+            standaloneFields.push(...groupFields);
+            usedFormats.add(formatType);
+        }
+    }
+    standaloneFields.sort((a, b) => a.byteOffset - b.byteOffset);
+    return { arrayGroups, standaloneFields, usedFormats, hasInlineFields };
+}
+/**
+ * Scans all eligible container fields to determine which helper format types are needed.
+ */
+function collectUsedFormats(ddeMap) {
+    const usedFormats = new Set();
+    for (const [, containerDefinition] of Object.entries(ddeMap.containers)) {
+        if (!isDeviceContainer(containerDefinition)) {
+            continue;
+        }
+        for (const field of containerDefinition.fields) {
+            const formatType = getFieldFormatType(field);
+            if (formatType) {
+                usedFormats.add(formatType);
+            }
+        }
+    }
+    return usedFormats;
+}
+/**
+ * Generates Pawn helper functions that encapsulate the sprintf+strcat pattern.
+ * Only generates the helpers that are actually used, reducing dead code.
+ * Each helper replaces 3 lines of repeated code per field with a single call.
+ */
+function buildHelperFunctions(pawnSource, usedFormats) {
+    if (usedFormats.has('d')) {
+        pawnSource('stock _DDE_fmt_d(aData{}, value) {');
+        pawnSource(PAWN_SZTEMP_DECL);
+        pawnSource('\tsprintf(szTemp, _, "%d", value);');
+        pawnSource(PAWN_STRCAT_RETURN);
+        pawnSource('}');
+    }
+    if (usedFormats.has('f')) {
+        pawnSource('');
+        pawnSource('stock _DDE_fmt_f(aData{}, Float:value) {');
+        pawnSource(PAWN_SZTEMP_DECL);
+        pawnSource('\tsprintf(szTemp, _, "%.3f", value);');
+        pawnSource(PAWN_STRCAT_RETURN);
+        pawnSource('}');
+    }
+    if (usedFormats.has('s')) {
+        pawnSource('');
+        pawnSource('stock _DDE_fmt_s(aData{}, value{}) {');
+        pawnSource(PAWN_SZTEMP_DECL);
+        pawnSource('\tsprintf(szTemp, _, "%s", value);');
+        pawnSource(PAWN_STRCAT_RETURN);
+        pawnSource('}');
+    }
+    if (usedFormats.has('stamp')) {
+        pawnSource('');
+        pawnSource('stock _DDE_fmt_stamp(aData{}, value) {');
+        pawnSource(PAWN_SZTEMP_DECL);
+        pawnSource('\tsprintf(szTemp, _, "%s", (stampToISOString(value)));');
+        pawnSource(PAWN_STRCAT_RETURN);
+        pawnSource('}');
+    }
+    if (usedFormats.has('bin')) {
+        pawnSource('');
+        pawnSource('stock _DDE_fmt_bin(aData{}, mem{}, dim) {');
+        pawnSource(PAWN_SZTEMP_DECL);
+        pawnSource('\tmemtostr(szTemp, mem, 0, dim);');
+        pawnSource('\treturn dim;');
+        pawnSource('}');
+    }
+}
+/**
+ * Builds the Pawn index expression for accessing an array element by byte offset.
+ */
+function buildIndexExpression(startOffset, step) {
+    if (step === 1) {
+        return startOffset === 0 ? 'idx' : `idx - ${startOffset}`;
+    }
+    return startOffset === 0 ? `idx / ${step}` : `(idx - ${startOffset}) / ${step}`;
+}
+/**
+ * Builds the Pawn condition for matching a byte offset to an array group.
+ */
+function buildConditionExpression(startOffset, endOffset, step) {
+    const rangeCheck = `idx >= ${startOffset} && idx <= ${endOffset}`;
+    if (step === 1) {
+        return rangeCheck;
+    }
+    const modCheck = startOffset === 0 ? `idx % ${step} == 0` : `(idx - ${startOffset}) % ${step} == 0`;
+    return `${rangeCheck} && ${modCheck}`;
+}
+/**
+ * Generates an if-block that collapses an array group into arithmetic index calculation.
+ */
+function buildArrayGroupBlock(pawnSource, group) {
+    const { startOffset, endOffset, step, formatType, pawnVarBase, subField } = group;
+    const indexExpr = buildIndexExpression(startOffset, step);
+    const condition = buildConditionExpression(startOffset, endOffset, step);
+    pawnSource(`\tif (${condition}) {`);
+    if (formatType === 'bin') {
+        const fieldAccess = `${pawnVarBase}[${indexExpr}]${subField}`;
+        pawnSource(`\t\treturn _DDE_fmt_bin(aData, ${fieldAccess}, ${fieldAccess}_dim);`);
+    }
+    else {
+        pawnSource(`\t\treturn _DDE_fmt_${formatType}(aData, ${pawnVarBase}[${indexExpr}]${subField});`);
+    }
+    pawnSource(`\t}`);
+}
+/**
+ * Builds a case statement for a standalone field.
+ * Uses compact helper function calls when available, falls back to inline code
+ * for packed types (s64, f64, stamp40) and memtostr (binary).
+ */
+function buildOptimizedCaseForField(pawnSource, containerTitle, field) {
+    if (field.type === 'shadow' || field.shadowRef) {
+        return;
+    }
+    const tdefPwn = (0, dlo_1.getPawnTypeDefinition)(field);
+    if (!tdefPwn || tdefPwn === 'skip') {
+        return;
+    }
+    const fieldNamePrefix = field.library ? `_${helper_1.Helper.generateHashForLibraryName(field.library)}` : 'DDE_';
+    const ddeFieldName = `${fieldNamePrefix}${containerTitle}_${field.name}`;
+    const formatType = getHelperFormatType(tdefPwn);
+    if (formatType === 'bin') {
+        // Compact single-line case using binary helper function
+        pawnSource(`\t\tcase ${field.byteOffset}: return _DDE_fmt_bin(aData, ${ddeFieldName}, ${ddeFieldName}_dim);`);
+    }
+    else if (formatType) {
+        // Compact single-line case using helper function
+        pawnSource(`\t\tcase ${field.byteOffset}: return _DDE_fmt_${formatType}(aData, ${ddeFieldName});`);
+    }
+    else {
+        // Fall back to inline code (packed types, wstring, etc.)
+        pawnSource(`\t\tcase ${field.byteOffset}: {`);
+        if (tdefPwn.printf) {
+            let printfInsert = ddeFieldName;
+            if (tdefPwn.printfFormat) {
+                printfInsert = `(${tdefPwn.printfFormat}(${printfInsert}))`;
+            }
+            pawnSource(`\t\t\tsprintf(szTemp, _, "${tdefPwn.printf}", ${printfInsert});`);
+            pawnSource(`\t\t\treturn (strcat(aData, szTemp, sizeof(szTemp)));`);
+        }
+        pawnSource(`\t\t}`);
+    }
+}
+function buildCaseForContainerName(pawnSource, containerName, containerDefinition) {
+    pawnSource(`\t\t\tcase '${containerName.at(-1)}': {`);
+    pawnSource(`\t\t\t\treturn _DDE_local_${containerDefinition.title}(aData, idx);`);
+    pawnSource(`\t\t\t}`);
+}
+function buildIfWithSwitchForContainerType(pawnSource, ddeMap, type) {
+    const cname0 = type === coreDefinitions_1.DDE_Core.ContainerType.cx ? 'c' : 'h';
+    const nameFilter = type === coreDefinitions_1.DDE_Core.ContainerType.cx ? 'config' : 'histdata';
+    pawnSource(`\tif(cname{0} == '${cname0}'){`);
+    pawnSource(`\t\tswitch(cname{1}) {`);
+    for (const [containerName, containerDefinition] of Object.entries(ddeMap.containers)) {
+        if (type === containerDefinition.containerType &&
+            containerName.startsWith(nameFilter) &&
+            containerDefinition.transferDirection !== TransferDirection.backendOnly) {
+            buildCaseForContainerName(pawnSource, containerName, containerDefinition);
+        }
+    }
+    pawnSource(`\t\t\tdefault:`);
+    pawnSource(`\t\t\t\treturn OK;`);
+    pawnSource(`\t\t}`);
+    pawnSource(`\t\treturn OK;`);
+    pawnSource(`\t}`);
+}
+/**
+ * Generates an optimized per-container local data return function.
+ * Uses if-blocks for collapsed array groups and a switch for standalone fields.
+ * Only declares szTemp when inline (non-helper) fields are present.
+ */
+function buildOptimizedLocalDataReturnFunction(pawnSource, containerDefinition) {
+    const analysis = analyzeContainerFields(containerDefinition.title, containerDefinition.fields);
+    pawnSource('');
+    pawnSource(`stock _DDE_local_${containerDefinition.title}(aData{}, idx) {`);
+    // Declare szTemp only if there are inline fields that need it
+    if (analysis.hasInlineFields) {
+        pawnSource(`\tnew szTemp{64};`);
+    }
+    // Generate if-blocks for array groups (before the switch)
+    for (const group of analysis.arrayGroups) {
+        buildArrayGroupBlock(pawnSource, group);
+    }
+    // Generate switch for standalone fields
+    if (analysis.standaloneFields.length > 0) {
+        pawnSource(`\tswitch(idx) {`);
+        for (const field of analysis.standaloneFields) {
+            buildOptimizedCaseForField(pawnSource, containerDefinition.title, field);
+        }
+        pawnSource(`\t\tdefault:`);
+        pawnSource(`\t\t\treturn OK;`);
+        pawnSource(`\t}`);
+    }
+    pawnSource(`\treturn OK;`);
+    pawnSource(`}`);
+}
+function buildOptimizedLocalDataReturnFunctions(pawnSource, ddeMap) {
+    for (const [, containerDefinition] of Object.entries(ddeMap.containers)) {
+        if (!isDeviceContainer(containerDefinition)) {
+            continue;
+        }
+        buildOptimizedLocalDataReturnFunction(pawnSource, containerDefinition);
+    }
+}
+function generateDloLocalDataIncFromMap(ddeMap) {
+    const _pwn = [];
+    const pwn = _pwn.push.bind(_pwn);
+    // Generate helper functions based on which format types are actually used
+    const usedFormats = collectUsedFormats(ddeMap);
+    buildHelperFunctions(pwn, usedFormats);
+    // Generate main dispatch function
+    if (usedFormats.size > 0) {
+        pwn('');
+    }
+    pwn(`stock DDE_get_local_data(cname{}, aData{}, idx) {`);
+    buildIfWithSwitchForContainerType(pwn, ddeMap, coreDefinitions_1.DDE_Core.ContainerType.cx);
+    buildIfWithSwitchForContainerType(pwn, ddeMap, coreDefinitions_1.DDE_Core.ContainerType.hx);
+    pwn(`\treturn OK;`);
+    pwn(`}`);
+    // Generate optimized per-container functions
+    buildOptimizedLocalDataReturnFunctions(pwn, ddeMap);
+    return _pwn.join('\n');
+}
+//# sourceMappingURL=dloLocalData.js.map

package/out/defaultFiles.js

@@ -22,6 +22,7 @@ var DefaultFiles;
         autoUplinkInc: 'app-uplink.inc',
         autoDdeInc: 'X-dde.inc',
         mainDdeInc: 'main-dde.inc',
+        autoLocalDataInc: 'auto-local-data.inc',
         legacyAutoInc: 'legacy-auto.inc',
         legacyAutoDdeInc: 'legacy-auto-dde.inc',
         legacyAutoUplinkInc: 'legacy-auto-uplink.inc',
@@ -43,6 +44,7 @@ var DefaultFiles;
                     autoInc: `${studioAutoDloPath}${DefaultFiles.fileNames.autoInc}`,
                     defaultInc: `${studioAutoDloPath}${DefaultFiles.fileNames.defaultInc}`,
                     autoUplinkInc: `${studioAutoDloPath}${DefaultFiles.fileNames.autoUplinkInc}`,
+                    autoLocalDataInc: `${studioAutoDloPath}${DefaultFiles.fileNames.autoLocalDataInc}`,
                     autoDdeInc: `${studioAutoDloPath}${DefaultFiles.fileNames.autoDdeInc}`,
                     mainDdeInc: `${studioAutoDloPath}${DefaultFiles.fileNames.mainDdeInc}`,
                     legacyAutoInc: `${studioAutoDloPath}${DefaultFiles.fileNames.legacyAutoInc}`,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@microtronics/studio-cli",
-	"version": "0.57.0",
+	"version": "0.59.0",
 	"description": "Microtronics Studio CLI Tool",
 	"main": "./out/api.js",
 	"typings": "./dist/studio-cli.d.ts",