/**
* A namespace.
* @namespace VCDParser
*/
const async = require('async');
const { extend } = require('./utils');
/**
* Parse VCD text content and generate a valid JSON representation.
* The function returns a promise unless a callback is provided.
* @name VCDParser~parse
* @function
* @param {string} content - The text content of the VCD file
* @param {VCDParser~Options} [opts = {}] - Optional configuration to customize the parsing process
* @param {VCDParser~ParseCallback} [cb = null] - Optional callback if you don't prefer to use promises
* @return {Promise<VCDParser~ParsedData>} Promise object that resolves with the parsed data
* @example
* const VCDParser = require('vcd-parser');
* VCDParser.parse(`
$date
Tue Feb 12 14:01:15 2019
$end
$version
Icarus Verilog
$end
$timescale
1ns
$end
$scope module test_tb $end
$var reg 1 ! clk $end
$var wire 1 " rst $end
$upscope $end
$enddefinitions $end
#0
$dumpvars
0"
0!
$end
#15
1"
#20
1!
#40
0!
#60
1!
#80
0!
#100
1!
#115
`).then(parsedData => {
* console.log(parsedData);
// {
// "date": "Tue Feb 12 14:01:15 2019",
// "version": "Icarus Verilog",
// "timescale": "1ns",
// "endtime": "115",
// "scale": "1ns",
// "signal": [
// {
// "type": "reg",
// "size": 1,
// "refName": "!",
// "signalName": "clk",
// "module": "test_tb",
// "name": "test_tb.clk",
// "wave": [
// [
// "0",
// "0"
// ],
// [
// "20",
// "1"
// ],
// [
// "40",
// "0"
// ],
// [
// "60",
// "1"
// ],
// [
// "80",
// "0"
// ],
// [
// "100",
// "1"
// ]
// ]
// },
// {
// "type": "wire",
// "size": 1,
// "refName": "\"",
// "signalName": "rst",
// "module": "test_tb",
// "name": "test_tb.rst",
// "wave": [
// [
// "0",
// "0"
// ],
// [
// "15",
// "1"
// ]
// ]
// }
// ]
// }
* }).catch(err => {
* console.error(err);
* }).
*/
const parse = (content, opts = {}, cb) => {
if (typeof opts === 'function') {
cb = opts;
opts = {};
}
const wrappedCallback = () => {
if (typeof cb !== 'function') {
return null;
}
return function() {
return cb(null, ...arguments);
};
};
return new Promise((resolve, reject) => {
setTimeout(function() {
process.nextTick(function() {
const blocks = content
.split(/\s*\$end\s/gm)
.map(line => line.replace(/[\n\t]/gm, ' '));
const States = {
Init: 0,
Meta: 1,
Def: 2,
Dump: 3
};
let modules = [];
const meta = {};
const signals = [];
const signalMap = {};
let lastIndex;
for (let i = 0; i < blocks.length; i++) {
const block = blocks[i].trim();
if (block === '') {
continue;
}
const scopeMatches = /\$(\w+?)\b/gm.exec(block);
if (scopeMatches) {
const scopeName = scopeMatches[1];
if (scopeName === 'scope') {
state = States.Def;
const scopeDefMatches = /\$(\w+)\s+([\s\S]+)\s+([\s\S]+)/gm.exec(
block
);
if (!scopeDefMatches) {
return reject({
error: 'Invalid VCD data'
});
}
const modName = scopeDefMatches[3];
modules.push(modName);
} else if (scopeName === 'enddefinitions') {
state = States.Dump;
lastIndex = i + 1;
break;
} else if (scopeName === 'upscope') {
modules.pop();
} else if (scopeName === 'var') {
const varDefMatches = /\$(\w+)\s+([\s\S]+?)\s+(\d+)\s+([\s\S]+?)\s+([\s\S]+)\s*/gm.exec(
block
);
const signalName = varDefMatches[5].replace(
/\s+/,
''
);
const refName = varDefMatches[4];
if (!signalMap[refName]) {
const signal = {
type: varDefMatches[2],
size: parseInt(varDefMatches[3]),
refName,
signalName,
module: modules[modules.length - 1] || '',
name: modules.concat(signalName).join('.'),
wave: []
};
signals.push(signal);
signalMap[refName] = signal;
}
} else {
const contentMatches = /\$(\w+)\b\s*([\s\S]+)?\s*/gm.exec(
block
);
if (contentMatches) {
meta[contentMatches[1]] = contentMatches[2];
}
}
} else {
return reject({
error: 'Invalid VCD data'
});
}
}
if (!lastIndex) {
return reject({
error: 'Invalid VCD data'
});
}
let currentTime = 0;
const rem = content.split(/\s*\$enddefinitions\s*/gm)[1];
if (!rem) {
return reject({
error: 'Invalid VCD data'
});
}
const lines = rem.split(/\s*\n\s*/gm);
async.eachSeries(
lines,
function(line, callback) {
(function(line) {
setTimeout(function() {
const block = line.trim();
if (block === '') {
return callback();
}
const timingMatches = /^#(\d+)$/gm.exec(block);
if (timingMatches) {
const time = parseInt(timingMatches[1]);
currentTime = time;
} else if (block === '$dumpvars') {
return callback();
} else if (block === '$end') {
return callback();
} else {
if (block.startsWith('x')) {
const refName = block.substr(1).trim();
if (!signalMap[refName]) {
return callback({
error: 'Invalid VCD data'
});
}
const wave = signalMap[refName].wave;
if (
!opts.compress ||
!wave.length ||
wave[wave.length - 1][1] !== 'x'
) {
signalMap[refName].wave.push([
currentTime.toString(),
'x'
]);
}
} else if (block.startsWith('b')) {
const matches = /b([01xz]+)\s+([\s\S]+)/gm.exec(
block
);
if (!matches) {
return callback({
error: 'Invalid VCD data'
});
}
const refName = matches[2];
if (!signalMap[refName]) {
return callback({
error: 'Invalid VCD data'
});
}
let value = matches[1];
if (!opts.expandAmbigousBus) {
if (/z/gm.test(value)) {
value = 'z';
} else if (/x/gm.test(value)) {
value = 'x';
}
}
const wave = signalMap[refName].wave;
if (
!opts.compress ||
!wave.length ||
wave[wave.length - 1][1] !== value
) {
signalMap[refName].wave.push([
currentTime.toString(),
value
]);
}
} else if (block.startsWith('z')) {
const refName = block.substr(1).trim();
if (!signalMap[refName]) {
return callback({
error: 'Invalid VCD data'
});
}
const wave = signalMap[refName].wave;
if (
!opts.compress ||
!wave.length ||
wave[wave.length - 1][1] !== 'z'
) {
signalMap[refName].wave.push([
currentTime.toString(),
'z'
]);
}
} else if (/^[01]([\s\S]+)/gm.test(block)) {
const matches = /^([01])([\s\S]+)/gm.exec(
block
);
const refName = matches[2];
if (!signalMap[refName]) {
return callback({
error: 'Invalid VCD data'
});
}
const converted = parseInt(
matches[1],
10
).toString(2);
const wave = signalMap[refName].wave;
if (
!opts.compress ||
!wave.length ||
wave[wave.length - 1][1] !==
converted
) {
signalMap[refName].wave.push([
currentTime.toString(),
converted
]);
}
} else if (block.startsWith('r')) {
const matches = /r((\d+\.?\d*)|(nan)|(x+)|(z+))\s+([\s\S]+)/gm.exec(
block
);
if (!matches) {
return callback({
error: 'Invalid VCD data'
});
}
let value;
if (
matches[1] === 'nan' ||
matches[1].charAt(0) === 'x'
) {
value = 'x';
} else if (
matches[1].charAt(0) === 'z'
) {
value = 'z';
} else {
value = parseFloat(matches[1]);
}
const refName = matches[6];
if (!signalMap[refName]) {
return callback({
error: 'Invalid VCD data'
});
}
const wave = signalMap[refName].wave;
if (
!opts.compress ||
!wave.length ||
wave[wave.length - 1][1] !==
converted
) {
signalMap[refName].wave.push([
currentTime.toString(),
isNaN(value)
? 'x'
: value.toString()
]);
}
} else {
return callback({
error: 'Invalid VCD data'
});
}
}
return callback();
}, 0);
})(line);
},
function(err) {
if (err) {
return reject(err);
}
meta.endtime = currentTime.toString();
meta.scale = meta.timescale;
return resolve(
extend({}, meta, {
signal: signals
})
);
}
);
});
}, 0);
})
.then(wrappedCallback())
.catch(cb);
};
/**
* The optional configuration for the VCD parser
* @typedef {Object} VCDParser~Options
* @property {boolean} compress - Compress the output wave by ignoring the unchanged values
* @property {boolean} expandAmbigousBus - If the bus has some ambigous value (z | x), it gets expanded to represent the whole bus signal
*/
/**
* The value of a signal at a specific point of time, represnted as a tuple [time, value]
* @typedef {Array<number>} VCDParser~SignalValue
* @property {number} 0 - The time of the event
* @property {number} 1 - The value of the signal at that event
*/
/**
* The object representing one signal data
* @typedef {Object} VCDParser~Signal
* @property {string} name - The full name of the signal
* @property {string} type - The type of the signal, e.g. wire, reg,..etc
* @property {number} size - The size/width of the signal in bits
* @property {string} refName - The reference for this signal used inside the VCD file
* @property {string} module - The name of the top module for which this signal belongs
* @property {Array<VCDParser~SignalValue>} wave - The values of the signal at different points of time
*/
/**
* The parsed VCD object generated by the parser
* @typedef {Object} VCDParser~ParsedData
* @property {string} [<"meta">] - The values of different initial meta-data, e.g. date, timescale..etc
* @property {string} endtime - The endtime of the simulation
* @property {string} scale - The time-scale unit of the simulation
* @property {Array<VCDParser~Signal>} signal - The signal values of the simulation
*/
/**
* The callback for the parsing function.
* @callback VCDParser~ParseCallback
* @param {error} err - The error generated while parsing
* @param {ParsedData} parsedJSON - The JSON document generated by the parser
*/
module.exports = { parse };