antlr to html

This JavaScript code appears to be part of a parser or tree-traversal function that handles tasks such as special character handling, filtering object properties, and converting a tree-like data structure to a string representation. The main function, treeToStr, recursively traverses the tree, extracting information from statement objects and using parser objects to resolve rule names and input strings.

Run example

antlr to html

What the code could have been:

const importer = require('../Core');
const { selectDom } = importer.import('select tree');

// Function to remove special characters from a string
const removeSpecialChars = (str) => {
    const specialCharsRegex = /&|<|>|"|'|/g;
    return str.replace(specialCharsRegex, (match) => {
        switch (match) {
            case '&':
                return '&amp;';
            case '<':
                return '&lt;';
            case '>':
                return '&gt;';
            case '"':
                return '&quot;';
            case "'":
                return '&apos;';
            default:
                return match;
        }
    });
};

// Function to filter out unwanted properties from an object
const filterObject = (obj) => {
    return Object.fromEntries(Object.entries(obj).filter(([key, value]) => key!== 'children' && key!== 'parentCtx'));
};

// Function to convert a tree statement to a string
const treeToStr = (statement, parent, parser) => {
    const { type, ruleIndex, start, stop, exception, strdata } = statement;

    if (typeof start === 'object') {
        statement['start'] = start.start;
        statement['line'] = start.line;
    }
    if (typeof stop === 'object') {
        statement['stop'] = stop.stop;
    }

    const parserNames = parser.ruleNames;
    if (!parser) {
        parser = statement.parentCtx?.parser?? statement.parser;
    }

    if (typeof type === 'number') {
        type = parserNames[type];
    } else if (typeof ruleIndex === 'number') {
        type = parserNames[ruleIndex];
        statement.type = type;
    }

    if (exception) {
        return '';
    }

    if (!strdata && statement.start && statement.stop && statement.type) {
        statement.strdata = parser.input.substring(statement.start, statement.stop + 1);
    }

    const result = [];
    const attrs = {};
    let isList = true;

    for (const [key, value] of Object.entries(statement)) {
        // Recursively convert child elements
        if (parseInt(key) + '' === key + '') {
            result.push(treeToStr(value, parent, parser));
            continue;
        }
        if (key === 'parentCtx' || key === 'parser' || key.startsWith('_') || key === 'exception' || key ==='source') {
            continue;
        }

        if (key ==='strdata') {
            statement[key] = statement[key].split('\n')[0];
        }

        if (key === 'type' && typeof statement[key] === 'number') {
            statement[key] = parserNames[statement[key]];
        }

        isList = false;
        const jsType = typeof value;

        if (jsType === 'object' && value) {
            jsType = Object.getPrototypeOf(value).constructor.name;
        }

        if (key ==='symbol' && jsType === 'Function') {
            continue;
        }

        // Convert objects and arrays to HTML
        if (statement[key] && typeof statement[key].type!== 'undefined' ||
            (Array.isArray(statement[key])) // TODO: uncomment this line
        ) {
            attrs[key] = { type: jsType };
            // Recursively convert child elements
            result.push(treeToStr(statement[key], key, parser));
            // Output as child element and <-attr> elements
            // TODO: uncomment this line
        } else {
            // Convert native types to HTML
            if (typeof value === 'object' && value!== null) {
                attrs[key] = { type: jsType };
                attrs[key].value = specialChars(JSON.stringify(filterObject(value)));
            } else if (typeof value!=='string') {
                attrs[key] = { type: jsType };
                attrs[key].value = specialChars(JSON.stringify(value));
            } else {
                attrs[key] = { type: jsType };
                attrs[key].value = specialChars(value);
            }
        }
    }

    // Output as child element or element with attributes
    if (isList) {
        return result.join('');
    }
    return `<${type}${Object.keys(attrs).map((key) => `${key}="${attrs[key].value}" ${key}-type="${attrs[key].type}""`).join('')}${parent? ` parent-attr="${parent}"`: ``}>${result.join('')}</${type}>`;
};

// Function to convert a tree to HTML
const treeToHtml = (tree) => {
    const body = treeToStr(tree);
    const fs = require('fs');
    fs.writeFileSync('text.html', body);
    return selectDom('//BODY', `<BODY>${body}</BODY>`);
};

module.exports = { treeToHtml };

This code appears to be a part of a parser or a tree-traversal function. It's written in JavaScript and uses Node.js's require function to import other modules. Here's a brief explanation of the code:

Importing Dependencies

This code imports a module from ../Core and extracts the selectDom function from it.

Special Character Handling

This function takes a string as input and replaces special characters with their HTML entity equivalents. This is likely used to escape special characters in text data.

Filtering Object Properties

This function takes an object as input and returns a new object with some properties filtered out. Specifically, it ignores properties named 'children' and 'parentCtx'.

Tree to String Conversion

This is the main function of interest. It takes a statement object, an optional parent object, and a parser object as input. It appears to recursively traverse a tree-like data structure, converting each statement to a string representation.

This function seems to be used to serialize a tree-like data structure into a human-readable string representation.