jlex 1.1.3 → 1.2.0

package/README.md

@@ -17,30 +17,30 @@ npx jlex <package name>
 `jlex` is  a tiny wrapper around `jison-lex` that allows you to use the script 
 `jlex` as standalone (`flex` like) processor.
 
-Assuming the following lexer in file `example.js`:
+Assuming the following lexer in file [examples/example.l](examples/example.l):
 
 ```
+comment [/][*](.|[\r\n])*?[*][/]
 %%
-\s+                   /* skip whitespace */
+\s+|{comment}         /* skip whitespace */
 [0-9]+                return 'NUMBER';
-"-"                   return '-';
+[-+*/]                return 'OPERATOR';
 <<EOF>>               return 'EOF';
-.                     return 'INVALID';% 
+.                     return 'INVALID';
 ```
 
 Compile it with:
 
 ```
-➜  jlex-test npx jlex example  
-Processing file: example
-Writing file: example.js
+npx jlex examples/example.l
 ``` 
 
-This produces a Common.JS module `example.js` you can use with a simple `require` like in the file `main.js` below:
+This produces a Common.JS module `examples/example.js` you can use with a simple `require` like in the file [main.js](examples/main.js) below:
 
 ```js
 const lex = require("./example");
-lex.setInput("2\n-\n3")
+const input = process.argv[2] || "2\n-/* a comment*/\n3";
+lex.setInput(input);
 
 const results = [];
 
@@ -49,38 +49,13 @@ results.push({ type: lex.lex(), lexeme: lex.yytext, loc: lex.yylloc });
 results.push({ type: lex.lex(), lexeme: lex.yytext, loc: lex.yylloc });
 results.push({ type: lex.lex(), lexeme: lex.yytext, loc: lex.yylloc });
 
-console.log(results);
-/*
-➜  examples git:(main) ✗ node main.js
-[
-  {
-    type: 'NUMBER',
-    lexeme: '2',
-    loc: { first_line: 1, last_line: 1, first_column: 0, last_column: 1 }
-  },
-  {
-    type: '-',
-    lexeme: '-',
-    loc: { first_line: 2, last_line: 2, first_column: 0, last_column: 1 }
-  },
-  {
-    type: 'NUMBER',
-    lexeme: '3',
-    loc: { first_line: 3, last_line: 3, first_column: 0, last_column: 1 }
-  },
-  {
-    type: 'EOF',
-    lexeme: '',
-    loc: { first_line: 3, last_line: 3, first_column: 1, last_column: 1 }
-  }
-]
-*/  
+console.log(results); 
 ```
 When you execute the former program, you get:
 
 
 ```js
-➜  jlex-test node main.js 
+➜  jlex git:(main) ✗ node examples/main.js 
 [
   {
     type: 'NUMBER',
@@ -88,7 +63,7 @@ When you execute the former program, you get:
     loc: { first_line: 1, last_line: 1, first_column: 0, last_column: 1 }
   },
   {
-    type: '-',
+    type: 'OPERATOR',
     lexeme: '-',
     loc: { first_line: 2, last_line: 2, first_column: 0, last_column: 1 }
   },
@@ -124,7 +99,7 @@ Compile the grammar with:
 
 And use the parser:
 
-```
+```js
 ➜  jlex git:(main) ✗ node
 Welcome to Node.js v25.6.0.
 Type ".help" for more information.
@@ -191,4 +166,68 @@ Here is a description of the attributes of the lexer object:
 ## Writing a Jison compatible lexer by hand 
 
 See file [examples/manual-lexer.js](examples/manual-lexer.js) to see an example that 
-illustrates how to write a Jison compatible lexer by hand.
+illustrates how to write a Jison compatible lexer by hand.
+
+To use with the [grammar](examples/grammar.jison#L33-L34) in the `examples` folder, set the `parser.lexer` to the hand-written one:
+
+```diff
+➜  jlex git:(main) ✗ git -P diff examples/grammar.jison 
+diff --git a/examples/grammar.jison b/examples/grammar.jison
+index 0b99d40..c9e974d 100644
+--- a/examples/grammar.jison
++++ b/examples/grammar.jison
+@@ -12,6 +12,7 @@ expr
+       {
+         $$ = {
+           type: "OPERATOR",
++          lexeme: $2,
+           left: $1,
+           right: $3,
+           loc: @2
+@@ -29,5 +30,7 @@ expr
+ 
+ %%
+ 
+-const lexer = require("./example.js");
++//const lexer = require("./example.js");
++const lexer = require("./manual-lexer.js");
++
+ parser.lexer = lexer;
+
+```
+
+Then compile the grammar:
+
+```
+➜  jlex git:(main) ✗ npx jison examples/grammar.jison -o examples/parser.js
+```
+and use it like this:
+
+```js
+➜  jlex git:(main) ✗ node                                                  
+Welcome to Node.js v25.6.0.
+Type ".help" for more information.
+> p = require("./examples/parser.js")
+{
+  parser: { yy: {} },
+  Parser: [Function: Parser],
+  parse: [Function (anonymous)],
+  main: [Function: commonjsMain]
+}
+> p.parse("2*3")
+{
+  type: 'OPERATOR',
+  lexeme: '*',
+  left: {
+    type: 'number',
+    value: 2,
+    loc: { first_line: 1, last_line: 1, first_column: 0, last_column: 1 }
+  },
+  right: {
+    type: 'number',
+    value: 3,
+    loc: { first_line: 1, last_line: 1, first_column: 2, last_column: 3 }
+  },
+  loc: { first_line: 1, last_line: 1, first_column: 1, last_column: 2 }
+}
+```

package/examples/grammar.jison

@@ -12,6 +12,7 @@ expr
       {
         $$ = {
           type: "OPERATOR",
+          lexeme: $2,
           left: $1,
           right: $3,
           loc: @2
@@ -30,4 +31,6 @@ expr
 %%
 
 const lexer = require("./example.js");
+//const lexer = require("./manual-lexer.js");
+
 parser.lexer = lexer;

package/examples/manual-lexer.js

@@ -16,7 +16,7 @@ const lexer = {
 
   lex() {
     if (this.index >= this.input.length) {
-      return this.EOF;
+      return 'EOF' /* this.EOF */;
     }
 
     // Saltar espacios
@@ -33,9 +33,9 @@ const lexer = {
 
     const char = this.input[this.index];
 
-    // PLUS
-    if (char === "+") {
-      this.yytext = "+";
+    // OPERATOR
+    if (/[-+*\/]/.test(char)) {
+      this.yytext = char;
       this.advance(char);
 
       this.yylloc = {
@@ -45,7 +45,7 @@ const lexer = {
         last_column: this.column
       };
 
-      return "PLUS";
+      return "OPERATOR";
     }
 
     // NUMBER (soporta múltiples dígitos)

package/jlex.js

@@ -1,35 +1,133 @@
 #!/usr/bin/env node
 // replace example by the name of the generated module
 const fs = require("fs");
-const { execSync } = require('child_process');
+const jisonLex = require('jison-lex');
+
 const { Command } = require('commander')
 const packageJson = require('./package.json')
 const path = require('path');
 const program = new Command();
 
 program
-  .version(packageJson.version)
-  .description('A tiny wrapper around jison-lex that allows you to use jison-lex as a standalone (flex like) processor.')
-  .addHelpText('after', `See https://github.com/ULL-ESIT-PL/jlex/blob/main/README.md for more help`)
-  .option("-o <fileName>", "Output file name")
-  .usage("[options] <filename>");
+    .version(packageJson.version)
+    .description('A tiny wrapper around jison-lex that allows you to use jison-lex as a standalone (flex like) processor.')
+    .addHelpText('after', `See https://github.com/ULL-ESIT-PL/jlex/blob/main/README.md for more help`)
+    .option("-o, --output <fileName>", "Output file name")
+    .option("-v, --verbose", "Enable verbose output")
+    .usage("[options] <filename>");
 
 program.parse(process.argv);
 const options = program.opts();
 
+// Logging helper
+function log(message, isVerbose = false) {
+    if (!isVerbose || options.verbose) {
+        console.log(message);
+    }
+}
+
+function logError(message) {
+    console.error(`❌ Error: ${message}`);
+}
+
+function logSuccess(message) {
+    console.log(`✅ ${message}`);
+}
+
+if (program.args.length === 0) {
+    logError("No input file specified");
+    program.help();
+    process.exit(1);
+}
 const fileName = program.args[0];
 
-const {dir,name } = path.parse(fileName); // { dir, base, ext, name }
-const outputFileName = options.o || path.join(dir, `${name}.js`);
-const outputParse = path.parse(outputFileName);
+// Validate input file extension
+if (!/[.](l|lex|flex)$/.test(fileName)) {
+    console.warn(`⚠️  Warning: Expected .l or .lex extension for lexer file, got: ${path.extname(fileName)}`);
+}
+
+const { dir, name } = path.parse(fileName);
+const outputFileName = options.output || path.join(dir, `${name}.js`);
 
-const shellCommand = `npx jison-lex ${fileName} -o ${outputFileName}`;
 try {
-    execSync(shellCommand, { encoding: 'utf-8' });
-    let lexerStr = fs.readFileSync(outputFileName, "utf8").toString();
-    let lexerModule = lexerStr.replace(new RegExp(`var ${outputParse.name} =`), `\nmodule.exports =`);
-    console.log("Writing file:", outputFileName);
+    if (!fs.existsSync(fileName)) {
+        logError(`File '${fileName}' does not exist`);
+        process.exit(1);
+    }
+    
+    const stats = fs.statSync(fileName);
+    if (!stats.isFile()) {
+        logError(`'${fileName}' is not a regular file`);
+        process.exit(1);
+    }
+    
+    log(`📖 Reading lexer grammar from: ${fileName}`, true);
+    let lexerStr = fs.readFileSync(fileName, "utf8");
+
+    let generatedCode = jisonLex.generate(lexerStr, { moduleType: 'commonjs' });
+    
+    if (!generatedCode || generatedCode.trim().length === 0) {
+        logError(`jison-lex failed to generate code from '${fileName}'`);
+        process.exit(1);
+    }
+    
+    log(`📝 Generated ${generatedCode.length} characters of lexer code`, true);
+    
+    // More robust transformation with multiple patterns
+    const patterns = [
+        /var\s+lexer\s*=/,
+        /let\s+lexer\s*=/,
+        /const\s+lexer\s*=/,
+        new RegExp(`var\\s+${name}\\s*=`)
+    ];
+    
+    let lexerModule = generatedCode;
+    let transformApplied = false;
+    
+    for (const pattern of patterns) {
+        if (pattern.test(generatedCode)) {
+            lexerModule = generatedCode.replace(pattern, `module.exports =`);
+            transformApplied = true;
+            log(`🔄 Applied transformation pattern: ${pattern}`, true);
+            break;
+        }
+    }
+    
+    //transformApplied = false;
+    if (!transformApplied) {
+        logError(
+`No standard pattern found in the generated code!.
+       Applied patterns: ${patterns.map(p => p.toString()).join(' or ')}.
+       Output may not be a valid CommonJS module.
+       Consider adding an issue: https://github.com/ULL-ESIT-PL/jlex/issues.
+`);
+    }
+    
+    // Ensure output directory exists
+    const outputDir = path.dirname(outputFileName);
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+        log(`📁 Created directory: ${outputDir}`, true);
+    }
+    
+    log(`📝 Writing file: ${outputFileName}`);
     fs.writeFileSync(outputFileName, lexerModule);
+    
+    logSuccess(`Successfully processed ${fileName} → ${outputFileName}`);
+    log(`📊 Output size: ${(fs.statSync(outputFileName).size / 1024).toFixed(1)}KB`, true);
+    
 } catch (error) {
-    console.error("Error:", error.message);
+    if (error.message.includes('Lexical error') || error.message.includes('Parse error')) {
+        logError(`Invalid lexer grammar in '${fileName}': ${error.message}`);
+    } else if (error.code === 'EACCES') {
+        logError(`Permission denied accessing '${error.path}'`);
+    } else if (error.code === 'ENOSPC') {
+        logError(`No space left on device when writing '${outputFileName}'`);
+    } else {
+        logError(error.message);
+        if (options.verbose) {
+            console.error('Stack trace:', error.stack);
+        }
+    }
+    process.exit(1);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jlex",
-  "version": "1.1.3",
+  "version": "1.2.0",
   "description": "A wrapper around jison-lex to make it work as a standalone program like Flex",
   "keywords": [
     "jison-lex",