Share your code. npm Orgs help your team discover, share, and reuse code. Create a free org »

    mips-parserpublic

    mips-parser

    Build Status npm version npm downloads

    MIPS Assembly parser in JavaScript

    MIPS is a reduced instruction set computer (RISC) instruction set architecture developed by MIPS Technologies (formerly MIPS Computer Systems, Inc.).

    MIPS is a load-store architecture (also sometimes called "register-register"), meaning it only performs arithmetic and logic operations between CPU registers, requiring load/store instructions to access memory (as opposed to a "register-memory" architecture, like x86).

    The parser recognizes MIPS Assembly language, and produces segment-based AST, which can be used directly for interpretation, implementing a MIPS virtual machine, or emitting an actual bytecode corresponding to the instructions.

    You can check the notes on the parser implementation, and also try it online.

    Installation

    The parser can be installed as an NPM module:

    npm install -g mips-parser
    
    mips-parser --help
    

    Or for developement, from the git repository. To regenerate the parser file after editing grammar file, run the build command:

    git clone https://github.com/DmitrySoshnikov/mips-parser.git
    cd mips-parser
    npm install
    npm run build
    
    ./bin/mips-parser --help
    

    Usage as a CLI

    MIPS parser can be used as a CLI tool, to parser a file:

    mips-parser -f ~/example.s
    

    Or direct expressions for quick syntax checks:

    mips-parser -e 'li $v0, 4'
    

    Usage from Node

    The parser can also be used as a Node module:

    const MIPSParser = require('mips-parser');
     
    const source = `
      li $v0, 4
      la $a0, message
      syscall
    `;
     
    console.log(MIPSParser.parse(source)); // MIPS AST

    Examples

    A basic MIPS program:

    # Hello, world!
    # MIPS Assembly
     
          .data               # Data segment
     
    # String to be printed:
    out_string: .asciiz "Hello, world!"
     
          .text               # Code segment (instructions go here)
     
    main:                     # Main entry point
     
          li $v0, 4           # System call code for printing string = 4
          la $a0, out_string  # Load address of string into $a0
          syscall             # Call operating system to perform operation
                              # specified in $v0
                              # syscall takes its arguments from $a0, $a1, etc.
     
          li $v0, 10          # Terminate the program
          syscall

    We get the following AST, which can be interpreted by a virtual machine:

    {
      "type": "Program",
      "segments": {
        ".text": {
          "instructions": [
            {
              "type": "Instruction",
              "opcode": "li",
              "operands": [
                {
                  "type": "Register",
                  "value": "$v0",
                  "kind": "Name"
                },
                {
                  "type": "Number",
                  "kind": "decimal",
                  "value": 4
                }
              ]
            },
            {
              "type": "Instruction",
              "opcode": "la",
              "operands": [
                {
                  "type": "Register",
                  "value": "$a0",
                  "kind": "Name"
                },
                {
                  "type": "Identifier",
                  "value": "out_string"
                }
              ]
            },
            {
              "type": "Instruction",
              "opcode": "syscall"
            },
            {
              "type": "Instruction",
              "opcode": "li",
              "operands": [
                {
                  "type": "Register",
                  "value": "$v0",
                  "kind": "Name"
                },
                {
                  "type": "Number",
                  "kind": "decimal",
                  "value": 10
                }
              ]
            },
            {
              "type": "Instruction",
              "opcode": "syscall"
            }
          ]
        },
        ".data": {
          "instructions": [
            {
              "type": "Data",
              "mode": ".asciiz",
              "value": {
                "type": "String",
                "value": "Hello, world!"
              }
            }
          ]
        }
      },
      "labels": {
        "out_string": {
          "address": 0,
          "segment": ".data"
        },
        "main": {
          "address": 0,
          "segment": ".text"
        }
      },
      "directives": [
        {
          "type": "Segment",
          "value": ".data",
        },
        {
          "type": "Segment",
          "value": ".text",
        }
      ]
    }

    Implementation

    The mips-parser is implemented using Syntax tool, which generates a LALR(1) parser based on the MIPS grammar.

    install

    npm i mips-parser

    Downloadsweekly downloads

    1

    version

    0.0.16

    license

    MIT Style License

    repository

    githubgithub

    last publish

    collaborators

    • avatar