@alu0101163970/constant-folding v1.1.0

constant-folding

Constant folding is the process of recognizing and evaluating constant expressions at compile time rather than computing them at runtime. Terms in constant expressions are typically simple literals, such as the integer literal 2, but they may also be variables whose values are known at compile time. Consider the statement:

i = 320 200 32;

Most compilers would not actually generate two multiply instructions and a store for this statement. Instead, they identify constructs such as these and substitute the computed values at compile time (in this case, 2,048,000).

In this module we have a program which makes the constant folding of a js code.

Installation

To install execute:

npm install @alu0101163970/constant-folding --save

Usage as executable:

• Version

user (master) $ cf -V
1.0.0

• Usage

user (master) $ cf -h
Usage: constant-folding-js cf <input> <output>

Constant Folding javascript code

Arguments:
  input          file with the original code
  output         file which its write the output code

Options:
  -V, --version  output the version number
  -h, --help     display help for command

• Excute program

user (master) $ cat examples/examples.js 
var f = 3+null;
var e = 4 | 3;
var d = 3+"c";
var b = 9 +1;
var a = 2+3*5+b;

user (master) $ cf examples/examples.js output.js
File read succesfully
Output written succesfully in output.js

user (master) $ cat output.js 
var f = 3;
var e = 7;
var d = '3c';
var b = 10;
var a = 17 + b;

Usage from code:

//Export function
const constantFolding = require('constant-folding');

//Create a string with js code
const input = 
              `var f = 3+null;
               var e = 4 | 3;
               var d = 3+"c";
               var b = 9 +1;
               var a = 2+3*5+b;`;

//call function
const output = constantFolding(input); 

console.log(output);
/* OUTPUT
var f = 3;
var e = 7;
var d = '3c';
var b = 10;
var a = 17 + b;
*/

The documentation of the function.

Author

alu0101163970 - Francisco Jesús Mendes Gómez

Tests

To execute tests use:

npm test

You will see:

user (master) $ npm test

> @alu0101163970/constant-folding@1.0.1 test
> mocha



  constantFolding tests
    ✔ works correctly with normal functions -> a=2*3;
    ✔ works correctly with normal functions -> a=3+null
    ✔ works correctly with normal functions -> a=4 | 3
    ✔ works correctly with normal functions -> a=3+"c"
    ✔ works correctly with normal functions -> a=9 +1
    ✔ works correctly with normal functions -> a=2+3*5+b
{
  "type": "Program",
  "start": 0,
  "end": 9,
  "body": [
    {
      "type": "ExpressionStatement",
      "start": 0,
      "end": 9,
      "expression": {
        "type": "AssignmentExpression",
        "start": 0,
        "end": 9,
        "operator": "=",
        "left": {
          "type": "Identifier",
          "start": 0,
          "end": 1,
          "name": "a"
        },
        "right": {
          "type": "BinaryExpression",
          "start": 2,
          "end": 9,
          "left": {
            "type": "Literal",
            "start": 2,
            "end": 7,
            "operator": "+",
            "value": 17,
            "raw": "17"
          },
          "operator": "+",
          "right": {
            "type": "Identifier",
            "start": 8,
            "end": 9,
            "name": "b"
          }
        }
      }
    }
  ],
  "sourceType": "script"
}
    ✔ Debug Test -> a=2+3*5+b Befere we looked the AST
    ✔ works correctly with Extension functions -> ["a", "b", "c"].concat(["d", "e"], "f", "g", ["h"])
    ✔ works correctly with Extension functions -> length = [1, 2, 3].length;
    ✔ works correctly with Extension functions -> var chuchi = [a, b, c].pop()
    ✔ works correctly with Extension functions -> var chuchi = ['a', 'b', 'c'].pop()


  11 passing (47ms)

Versions

• 1.0.0 Initial release.
• 1.0.1 Documentation fix
• 1.1.0 new features added
  • "a", "b", "c".concat("d", "e", "f", "g", "h"); ---> "a", "b", "c", "d", "e", "f", "g", "h";
  • 1, 2, 3.length; ---> 3;
  • a, b, c.pop(); ---> c;