27void FT_SetName(DOS_FCB *p_fcb, const char *p_name) {
 28  char i, j;
 29  Mem_Set(0, p_fcb, sizeof(DOS_FCB));
 30  for (i = 0; i < 11; i++) {
 31    p_fcb->Name[i] = ' ';
 32  }
 33  for (i = 0; (i < 8) && (p_name[i] != 0) && (p_name[i] != '.'); i++) {
 34    p_fcb->Name[i] = p_name[i];
 35  }
 36  if (p_name[i] == '.') {
 37    i++;
 38    for (j = 0; (j < 3) && (p_name[i + j] != 0) && (p_name[i + j] != '.');
 39         j++) {
 40      p_fcb->Name[8 + j] = p_name[i + j];
 41    }
 42  }
 43}
            

 45void main(){
 46  VDP_SetMode(VDP_MODE_TEXT2);
 47
 48  VDP_SetColor(0xF0);
 49	VDP_FillVRAM_16K(0, 0x0000, 0x4000); // Clear VRAM
 50	
 51	Print_SetTextFont(g_Font_MGL_Std3, 1);
 52	Print_SetColor(0xF, 0x0);
 53
 54  DOSMapper_Init();
 55  DEBUG_INIT();

            

 57	Print_SetPosition(0, 0);
 58	Print_DrawText("We write value 1 to the starting segment");
 59  for (u16 j=0; j<0x3fff; j++) {
 60    array[j] = 1;
 61  }
 62  Print_DrawText("\nValue written.\n");
 63
 64	Print_DrawCharX('-', g_PrintData.ScreenWidth);
 65  Print_DrawText("\nNow we add a new segment and we put it on page 1");
 66  startingSeg = DOSMapper_GetPage(1);
 67  DEBUG_LOGNUM("startingSeg number, value returned by alloc: ", startingSeg);
 68
 69  newSeg = DOSMapper_Alloc(DOS_ALLOC_USER, DOS_SEGSLOT_PRIM, &g_newSeg);
 70  DEBUG_LOGNUM("newSeg number, value returned by alloc: ", newSeg);
 71  DEBUG_LOGNUM("g_newSeg number", g_newSeg.Number);
 72
 73  DOSMapper_SetPage(1, g_newSeg.Number);
 74  Print_DrawText("\nSegment changed. Now we write value 2");
 75  for (u16 j=0; j<0x3FFf; j++) {
 76    array[j] = 2;
 77  }
 78  Print_DrawText("\nDone.\n");
 79  DEBUG_LOG("Written value 2 to segment g_newSeg 2");
 80
 81	Print_DrawCharX('-', g_PrintData.ScreenWidth);
 82  Print_DrawText("\nNow we add a new segment and we put it again on page 1");
 83  newSeg2 = DOSMapper_Alloc(DOS_ALLOC_USER, DOS_SEGSLOT_PRIM, &g_newSeg2);
 84  DEBUG_LOGNUM("newSeg2 value returned by alloc", newSeg2);
 85  newSeg = DOSMapper_GetPage1(); 
 86  DEBUG_LOGNUM("newSeg value returned by getPage", newSeg);
 87  DOSMapper_SetPage(1, g_newSeg2.Number);
 88  DEBUG_LOG("set in page 1 g_newSeg2");
 89  Print_DrawText("\nSegment changed. Now we write value 3");
 90  for (u16 j=0; j<0x3FFf; j++) {
 91    array[j] = 3;
 92  }
 93  Print_DrawText("\nDone");
            

 96  DOSMapper_SetPage(1, g_newSeg.Number);
 97  Print_DrawText("Changed segment g_newSeg , read value: ");
 98  Print_DrawInt(array[3]);
 99  DEBUG_LOGNUM("Changed segment g_newSeg: ", array[3]);
            

101  DOSMapper_Alloc(DOS_ALLOC_USER, DOS_SEGSLOT_PRIM, &g_func1);
102  DOSMapper_Alloc(DOS_ALLOC_USER, DOS_SEGSLOT_PRIM, &g_func2);
103
104  DOSMapper_SetPage(1, g_func1.Number);
105
106  Print_DrawText("\n");
107  Print_DrawCharX('-', g_PrintData.ScreenWidth);
108  Print_DrawText("\nReading file funcio1.bin. ");
109  DEBUG_LOG("Reading file funcio1.bin");
110  FT_SetName(&g_File, "funcio1.bin");
111  DOS_OpenFCB(&g_File);
112  for (u16 i=0; i<g_File.Size; i+=128) {
113    DOS_SetTransferAddr(&array[i]);
114    DOS_SequentialReadFCB(&g_File);
115  }
116  res_func1 = 4;
117  DEBUG_LOGNUM("Value before func1: ", res_func1);
118  Print_DrawText("\nBefore func1: ");
119  Print_DrawInt(res_func1);
120  res_func1 = funcio1();
121  DEBUG_LOGNUM("Value after calling func1: ", res_func1);
122  Print_DrawText("\nAfter func1: ");
123  Print_DrawInt(res_func1);
124
125  Print_DrawText("\nReading file funcio2.bin. ");
126  DEBUG_LOG("Reading file funcio2.bin");
127  DOSMapper_SetPage(2, g_func2.Number);
128  FT_SetName(&g_File, "funcio2.bin");
129  DOS_OpenFCB(&g_File);
130  for (u16 i=0; i<g_File.Size; i+=128) {
131    DOS_SetTransferAddr(&array[i]); // Els he de guardar a array, llegir directament a allà
132    DOS_SequentialReadFCB(&g_File);
133  }
134
135  res_func2 = 16;
136  DEBUG_LOGNUM("\nBefore func2: ", res_func2);
137  Print_DrawText("Before func2: ");
138  Print_DrawInt(res_func2);
139  res_func2 = funcio2();
140  DEBUG_LOGNUM("After func2: ", res_func2);
141  Print_DrawText("\nAfter func2: ");
142  Print_DrawInt(res_func2);
143
144  Print_DrawText("\nWe have run the two function in different pages");
145  Print_DrawText("\nYou can debug the memory page in openmsx debugger");
146
147  Print_DrawText("\nPress space to go back to DOS");
148  while (!Keyboard_IsKeyPressed(KEY_SPACE));
149
150  Bios_Exit(0);
151}
            

1#pragma codeseg funcio1
2
3extern void DEBUG_LOG(const char* msg);
4
5unsigned char funcio1(){
6  DEBUG_LOG("funcio1 has been called");
7  return 0x5;
8}


1#pragma codeseg funcio2
2
3extern void DEBUG_LOG(const char* msg);
4
5unsigned char funcio2(){
6  DEBUG_LOG("funcio2 has been called");
7  return 0xde;
8}


            

            
231//-- Command lines to be executed before the build process (array)
232PreBuildScripts = [	"node build_pagination.js pre" ];
233
234//-- Command lines to be executed after the build process (array)
235PostBuildScripts = [ "node build_pagination.js post" ];
            
        

  1#!/usr/bin/env node
  2// ____________________________
  3// ██▀▀█▀▀██▀▀▀▀▀▀▀█▀▀█        │   ▄▄▄                ▄▄
  4// ██  ▀  █▄  ▀██▄ ▀ ▄█ ▄▀▀ █  │  ▀█▄  ▄▀██ ▄█▄█ ██▀▄ ██  ▄███
  5// █  █ █  ▀▀  ▄█  █  █ ▀▄█ █▄ │  ▄▄█▀ ▀▄██ ██ █ ██▀  ▀█▄ ▀█▄▄
  6// ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀────────┘
  7// DOS2 Pagination Build Handler - Pre & Post Build Steps
  8
  9const fs = require('fs');
 10const path = require('path');
 11const { execSync } = require('child_process');
 12
 13const PROJECT_DIR = __dirname;
 14const OUT_DIR = path.join(PROJECT_DIR, 'out');
 15const EMUL_DIR = path.join(PROJECT_DIR, 'emul', 'dos2');
 16
 17// Load PaginatedFunctions from project_config.js
 18let PaginatedFunctions = [];
 19try {
 20    // Create a context object to capture the PaginatedFunctions variable
 21    const configCode = fs.readFileSync(path.join(PROJECT_DIR, 'project_config.js'), 'utf-8');
 22    const configModule = {};
 23    // Execute the config file in a controlled context
 24    const vm = require('vm');
 25    const context = vm.createContext({ PaginatedFunctions: [] });
 26    vm.runInContext(configCode, context);
 27    PaginatedFunctions = context.PaginatedFunctions;
 28
 29    if (!PaginatedFunctions || PaginatedFunctions.length === 0) {
 30        console.error('PaginatedFunctions not found or empty in project_config.js');
 31        process.exit(1);
 32    }
 33} catch (err) {
 34    console.error(`Error loading PaginatedFunctions from project_config.js: ${err.message}`);
 35    process.exit(1);
 36}
 37
 38const SDCC_PATH = '/home/jepsuse/MSX/MSXgl/tools/sdcc/bin';
 39const MSXHEX = '/home/jepsuse/MSX/MSXgl/tools/MSXtk/bin/MSXhex';
 40
 41const colors = {
 42    reset: '\x1b[0m',
 43    green: '\x1b[32m',
 44    yellow: '\x1b[33m',
 45    red: '\x1b[31m',
 46    blue: '\x1b[36m'
 47};
 48
 49function log(msg, color = 'reset') {
 50    console.log(`${colors[color]}${msg}${colors.reset}`);
 51}
 52
 53function exec(command, description) {
 54    log(`  ${description}...`, 'yellow');
 55    try {
 56        execSync(command, {
 57            cwd: PROJECT_DIR,
 58            stdio: 'pipe'
 59        });
 60        log(`  ✓ Done`, 'green');
 61    } catch (error) {
 62        log(`  ✗ Failed: ${error.message}`, 'red');
 63        throw error;
 64    }
 65}

 69function preBuild() {
 70    log('\n╔════════════════════════════════════════════════╗', 'blue');
 71    log('║   DOS2 Pagination - PRE-BUILD                  ║', 'blue');
 72    log('║   Step 1: Compile paginated functions          ║', 'blue');
 73    log('╚════════════════════════════════════════════════╝\n', 'blue');
 74
 75    if (!PaginatedFunctions || PaginatedFunctions.length === 0) {
 76        log('No paginated functions configured. Skipping pagination pre-build.\n', 'yellow');
 77        return;
 78    }
 79
 80    log('Compiling paginated functions:', 'yellow');
 81
 82    // Create out directory if it doesn't exist
 83    if (!fs.existsSync(OUT_DIR)) {
 84        fs.mkdirSync(OUT_DIR, { recursive: true });
 85    }
 86
 87    for (const func of PaginatedFunctions) {
 88        const file = `${func.name}.c`;
 89        if (!fs.existsSync(path.join(PROJECT_DIR, file))) {
 90            log(`  ✗ ${file} not found`, 'red');
 91            continue;
 92        }
 93        const cmd = `"${SDCC_PATH}/sdcc" -mz80 -c "${file}" -o "${OUT_DIR}/${func.name}.rel"`;
 94        exec(cmd, `  ${func.name}.c → out/${func.name}.rel`);
 95    }
 96
 97    log('\n✓ Pre-build complete. Main build will now process paginated functions.\n', 'green');
 98}

100/**
101 * Extract extern function declarations from a C source file and its includes.
102 * Looks for patterns like: extern void FUNCTION_NAME(...);
103 */
104function extractExternFunctions(filePath) {
105    const externFuncs = [];
106    const processedFiles = new Set();
107
108    function processFile(currentPath) {
109        // Avoid processing the same file twice
110        if (processedFiles.has(currentPath)) {
111            return;
112        }
113        processedFiles.add(currentPath);
114
115        if (!fs.existsSync(currentPath)) {
116            return;
117        }
118
119        const content = fs.readFileSync(currentPath, 'utf-8');
120
121        // Extract extern declarations: extern <return_type> FUNCTION_NAME(...)
122        const externRegex = /extern\s+\w+[\s\*]+(\w+)\s*\(/g;
123        let match;
124
125        while ((match = externRegex.exec(content)) !== null) {
126            const funcName = match[1];
127            if (!externFuncs.includes(funcName)) {
128                externFuncs.push(funcName);
129            }
130        }
131
132        // Extract #include directives and process them
133        const includeRegex = /#include\s+["<]([^"<>]+)[">]/g;
134        while ((match = includeRegex.exec(content)) !== null) {
135            const includePath = match[1];
136            // Try to find the included file in the project directory
137            const fullPath = path.join(PROJECT_DIR, includePath);
138            processFile(fullPath);
139        }
140    }
141
142    processFile(filePath);
143    return externFuncs;
144}
145
146/**
147 * Find symbol address in MAP file by function name.
148 * Looks for patterns like:
149 *   00001AA5  _DEBUG_LOG                         debug
150 */
151function findSymbolInMap(mapFile, funcName) {
152    const content = fs.readFileSync(mapFile, 'utf-8');
153    const lines = content.split('\n');
154
155    // Look for the symbol with underscore prefix: _FUNCNAME
156    const symbolName = '_' + funcName;
157
158    for (const line of lines) {
159        // Match: ADDRESS  _SYMBOL_NAME  module
160        const match = line.match(/^\s*([0-9A-Fa-f]+)\s+_[\w]+\s+/);
161        if (match && line.includes(symbolName)) {
162            const addr = '0x' + match[1];
163            return addr;
164        }
165    }
166
167    return null;
168}
169
170function postBuild() {
171    log('\n╔════════════════════════════════════════════════╗', 'blue');
172    log('║   DOS2 Pagination - POST-BUILD                 ║', 'blue');
173    log('║   Step 2: Relink & convert paginated functions ║', 'blue');
174    log('╚════════════════════════════════════════════════╝\n', 'blue');
175
176    if (!PaginatedFunctions || PaginatedFunctions.length === 0) {
177        log('No paginated functions configured. Skipping pagination post-build.\n', 'yellow');
178        return;
179    }
180
181    // Step 2a: Verify MAP file exists
182    log('Step 2a: Checking for main program MAP file...', 'yellow');
183    const mapFile = path.join(OUT_DIR, 'paginate.map');
184
185    if (!fs.existsSync(mapFile)) {
186        log(`  ✗ MAP file not found at ${mapFile}`, 'red');
187        log('     The main program must be linked first to generate the MAP file.\n', 'red');
188        return;
189    }
190    log('  ✓ MAP file found\n', 'green');
191
192    // Step 2b: Relink each paginated function at specified address with required symbols
193    log('Step 2b: Relinking paginated functions at specified addresses...', 'yellow');
194
195    for (const func of PaginatedFunctions) {
196        const name = func.name;
197        const pageAddr = typeof func.page === 'string' ? parseInt(func.page, 16) : func.page;
198        const codeLoc = `0x${pageAddr.toString(16).toUpperCase()}`;
199        const relFile = path.join(OUT_DIR, `${name}.rel`);
200
201        if (!fs.existsSync(relFile)) {
202            log(`  ✗ ${relFile} not found`, 'red');
203            continue;
204        }
205
206        // Extract extern function declarations from this source file
207        const sourceFile = path.join(PROJECT_DIR, `${name}.c`);
208        const externFuncs = extractExternFunctions(sourceFile);
209
210        if (externFuncs.length === 0) {
211            log(`  Relinking ${name} at ${codeLoc} (no external dependencies)...`, 'yellow');
212        } else {
213            log(`  Relinking ${name} at ${codeLoc} with ${externFuncs.length} external function(s):`, 'yellow');
214        }
215
216        // Find each extern function's address in the MAP file
217        let linkerFlags = '';
218        for (const funcName of externFuncs) {
219            const addr = findSymbolInMap(mapFile, funcName);
220            if (addr) {
221                linkerFlags += ` -Wl-g_${funcName}=${addr}`;
222                log(`    ${funcName} = ${addr}`, 'green');
223            } else {
224                log(`    ✗ ${funcName} NOT FOUND in MAP file!`, 'red');
225            }
226        }
227
228        const cmd = `"${SDCC_PATH}/sdcc" -mz80 --no-std-crt0 --code-loc ${codeLoc} ` +
229            `"${relFile}"${linkerFlags} ` +
230            `-L"${SDCC_PATH}/../lib/z80" -o "${OUT_DIR}/${name}.ihx"`;
231
232        exec(cmd, `  Relinking ${name} at ${codeLoc}`);
233    }
234
235    // Step 2c: Convert IHX to binary format
236    log('\nStep 2c: Converting IHX files to binary format...', 'yellow');
237
238    for (const func of PaginatedFunctions) {
239        const name = func.name;
240        const ihxFile = path.join(OUT_DIR, `${name}.ihx`);
241
242        if (fs.existsSync(ihxFile)) {
243            const cmd = `"${MSXHEX}" "${ihxFile}"`;
244            exec(cmd, `  Converting ${name}.ihx → ${name}.bin`);
245        }
246    }
247
248    // Step 2d: Copy files to emulator directory
249    log('\nStep 2d: Copying binaries to emulator directory...', 'yellow');
250
251    if (!fs.existsSync(EMUL_DIR)) {
252        fs.mkdirSync(EMUL_DIR, { recursive: true });
253    }
254
255    for (const func of PaginatedFunctions) {
256        const name = func.name;
257        const binFile = path.join(OUT_DIR, `${name}.bin`);
258
259        if (fs.existsSync(binFile)) {
260            fs.copyFileSync(binFile, path.join(EMUL_DIR, `${name}.bin`));
261            log(`  ✓ Copied ${name}.bin`, 'green');
262        }
263    }
264
265    log('\n✓ Post-build complete!\n', 'green');
266}
267
        

268// Determine which phase to run
269const args = process.argv.slice(2);
270const phase = args[0] || 'pre';
271
272try {
273    if (phase === 'pre') {
274        preBuild();
275    } else if (phase === 'post') {
276        postBuild();
277    } else {
278        log(`Unknown phase: ${phase}`, 'red');
279        process.exit(1);
280    }
281} catch (error) {
282    log(`\n✗ Build failed!\n`, 'red');
283    process.exit(1);
284}