jlex 1.1.2 → 1.1.4

package/README.md

@@ -1,3 +1,6 @@
+
+# jlex [![NPM Version](https://img.shields.io/npm/v/jlex)](https://www.npmjs.com/package/jlex)
+
 ## Install
 
 `npm i jlex`
@@ -14,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 = [];
 
@@ -46,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',
@@ -85,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 }
   },
@@ -104,7 +82,7 @@ When you execute the former program, you get:
 
 ## Using the lexer from a Jison grammar
 
-In file  [examples/grammar.jison](examples/grammar.jison) you'll find an example
+In file  [examples/grammar.jison](examples/grammar.jison#L32-L33) you'll find an example
 of setting the generated lexer to be used from a Jison grammar. The key is 
 to set the `lex` attribute of the `parser` object to the generated lexer:
 
@@ -121,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.
@@ -183,4 +161,73 @@ Here is a description of the attributes of the lexer object:
   rules: [ /^(?:\s+)/, /^(?:[0-9]+)/, /^(?:-)/, /^(?:$)/, /^(?:.)/ ],
   conditions: { INITIAL: { rules: [Array], inclusive: true } }
 }
+```
+
+## 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.
+
+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

@@ -0,0 +1,87 @@
+const lexer = {
+  input: "",
+  index: 0,
+
+  yytext: "",
+  yylineno: 0,  // base 0 internamente
+  yylloc: {},
+
+  setInput(input) {
+    this.input = input;
+    this.index = 0;
+    this.yylineno = 0;
+    this.column = 0;
+    return this;
+  },
+
+  lex() {
+    if (this.index >= this.input.length) {
+      return 'EOF' /* this.EOF */;
+    }
+
+    // Saltar espacios
+    while (/\s+/.test(this.input[this.index])) {
+      this.advance(this.input[this.index]);
+    }
+
+    if (this.index >= this.input.length) {
+      return this.EOF;
+    }
+
+    const startLine = this.yylineno + 1;   // Jison usa base 1
+    const startColumn = this.column;
+
+    const char = this.input[this.index];
+
+    // OPERATOR
+    if (/[-+*\/]/.test(char)) {
+      this.yytext = char;
+      this.advance(char);
+
+      this.yylloc = {
+        first_line: startLine,
+        last_line: this.yylineno + 1,
+        first_column: startColumn,
+        last_column: this.column
+      };
+
+      return "OPERATOR";
+    }
+
+    // NUMBER (soporta múltiples dígitos)
+    if (/\d/.test(char)) {
+      let num = "";
+
+      while (/\d/.test(this.input[this.index])) {
+        num += this.input[this.index];
+        this.advance(this.input[this.index]);
+      }
+
+      this.yytext = num;
+
+      this.yylloc = {
+        first_line: startLine,
+        last_line: this.yylineno + 1,
+        first_column: startColumn,
+        last_column: this.column
+      };
+
+      return "NUMBER";
+    }
+
+    throw new Error("Carácter inesperado: " + char);
+  },
+
+  advance(char) {
+    this.index++;
+
+    if (char === "\n") {
+      this.yylineno++;
+      this.column = 0;
+    } else {
+      this.column++;
+    }
+  }
+};
+
+module.exports = lexer;

package/package.json

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