epicreaderprocess.java

The ElectricTM VLSI Design System is an open-source Electronic Design Automation (EDA) system that c

                bufP++;
        } else {
            return false;
        }
        if (twoNumbers)
            putValue(num1, num2);
        else
            putTime(num1);
        lineNum++;
        return true;
    }
    
    /**
     * Sets new current time.
     * This current time will be used in PutBValue method.
     * @param time time as int value.
     */
    private void putTime(int time) {
        timesC++;
        curTime = Math.max(curTime, time);
    }
    
    /**
     * Puts event into packed waveforms.
     * @param sigNum Epic signal index of signal.
     * @param value new value of signal.
     */
    private void putValue(int sigNum, int value) {
        EpicReaderSignal s = signalsByEpicIndex.get(sigNum);
        if (s == null) {
            message("Signal " + sigNum + " not defined");
            return;
        }
        s.putEvent(curTime, value);
        eventsC++;
    }
    
    /**
     * Gets new line from buffer.
     * @return String line read.
     */
    private String getLine() throws IOException {
        builder.setLength(0);
        for (;;) {
            while (bufP < bufL) {
                int ch = buf[bufP++] & 0xff;
                if (ch == '\n') {
                    return builder.toString();
                }
                if (ch == '\r') {
                    if (bufP == bufL) readBuf();
                    if (bufP < bufL && buf[bufP] == '\n')
                        bufP++;
                    return builder.toString();
                }
                builder.append((char)ch);
            }
            if (readBuf()) {
                if (builder.length() == 0) return null;
                lineNum++;
                return builder.toString();
            }
        }
    }
    
    /**
     * ASCII to double.
     * @param s ASCII string. 
     * @return double value of string.
     */
    private double atof(String s) {
        double value = 0;
        try {
            value = Double.parseDouble(s);
        } catch (NumberFormatException e) {
            message("Bad float format: " + s);
        }
        return value;
    }
    
    /**
     * ASCII to int.
     * @param s ASCII string. 
     * @return int value of string.
     */
    private int atoi(String s) {
        int value = 0;
        try {
            value = Integer.parseInt(s);
        } catch (NumberFormatException e) {
            message("Bad integer format: " + s);
        }
        return value;
    }
    
    /**
     * Reads buffer from Epic file.
     */
    private boolean readBuf() throws IOException {
        assert bufP == bufL;
        bufP = bufL = 0;
        bufL = inputStream.read(buf, 0, buf.length);
        if (bufL <= 0) {
            bufL = 0;
            return true;
        }
        byteCount += bufL;
        showProgress(fileLength != 0 ? byteCount/(double)fileLength : 0);
        return false;
    }
    
    /**
     * Writes resolutions, signalInfo and fileName to stdOut.
     */
    private void writeOut() throws IOException {
        File tempFile = null;
        BufferedOutputStream waveStream = null;
        boolean ok = false;
        try {
            long startTime = System.currentTimeMillis();
            tempFile = File.createTempFile("elec", ".epic");
            waveStream = new BufferedOutputStream(new FileOutputStream(tempFile));
            
            showProgressNote("Writing " + tempFile);
            stdOut.writeByte('F');
            
            stdOut.writeDouble(timeResolution);
            stdOut.writeDouble(voltageResolution);
            stdOut.writeDouble(currentResolution);
            stdOut.writeDouble(curTime*timeResolution);
            int size = 0;
            for (EpicReaderSignal s: signals)
                size += s.len;
            int start = 0;
            for (EpicReaderSignal s: signals) {
                waveStream.write(s.waveform, 0, s.len);
                
                stdOut.writeInt(s.minV);
                stdOut.writeInt(s.maxV);
                stdOut.writeInt(s.len);
                start += s.len;
                showProgress(size != 0 ? start/(double)size : 0);
            }
            
            waveStream.close();
            
            stdOut.writeUTF(tempFile.toString());
            stdOut.close();
            ok = true;
            long stopTime = System.currentTimeMillis();
            System.err.println((stopTime - startTime)/1000.0 + " sec to write " + tempFile.length() + " bytes to " + tempFile);
        } finally {
            if (ok)
                return;
            if (waveStream != null)
                waveStream.close();
            if (tempFile != null)
                tempFile.delete();
        }
    }
    
    /**
     * Puts progress mark into stdErr.
     */
    private void showProgress(double ratio) {
        byte progress = (byte)(ratio*100);
        if (progress == lastProgress) return;
        System.err.println("**PROGRESS " + progress);
        lastProgress = progress;
    }
    
    /**
     * Puts progress not mark into stdErr.
     */
    private void showProgressNote(String note) {
        System.err.println("**PROGRESS !" + note);
        lastProgress = 0;
    }

    /**
     * Puts message int stdErr.
     */
    private void message(String s) {
        System.err.println(s + " in line " + (lineNum + 1));
    }
}

/**
 * This class is a buffer to pack waveform of Epic signal.
 */
class EpicReaderSignal {
    /** Time of last event.*/               int lastT;
    /** Value of last event. */             int lastV;
    /** Minimal value among events. */      int minV = Integer.MAX_VALUE;
    /** Maximal value among events. */      int maxV = Integer.MIN_VALUE;

    /** Packed waveform. */                 byte[] waveform = new byte[512];
    /** Count of bytes used in waveform. */ int len;

    /**
     * Puts event into waveform. 
     * @param t time of event.
     * @param v value of event.
     */
    void putEvent(int t, int v) {
        putUnsigned(t - lastT);
        putSigned(v - lastV);
        lastT = t;
        lastV = v;
        minV = Math.min(minV, v);
        maxV = Math.max(maxV, v);
    }

    /**
     * Packes unsigned int.
     * @param value value to pack.
     */
    void putUnsigned(int value) {
        if (value < 0xC0) {
            ensureCapacity(1);
            putByte(value);
        } else if (value < 0x3F00) {
            ensureCapacity(2);
            putByte((value + 0xC000) >> 8);
            putByte(value);
        } else {
            ensureCapacity(5);
            putByte(0xFF);
            putByte(value >> 24);
            putByte(value >> 16);
            putByte(value >> 8);
            putByte(value);
        }
    }
    
    /**
     * Packes signed int.
     * @param value value to pack.
     */
    void putSigned(int value) {
        if (-0x60 <= value && value < 0x60) {
            ensureCapacity(1);
            putByte(value + 0x60);
        } else if (-0x1F00 <= value && value < 0x2000) {
            ensureCapacity(2);
            putByte((value + 0xDF00) >> 8);
            putByte(value);
        } else {
            ensureCapacity(5);
            putByte(0xFF);
            putByte(value >> 24);
            putByte(value >> 16);
            putByte(value >> 8);
            putByte(value);
        }
    }
    
    /**
     * Unpackes waveform.
     * @return array with time/value pairs.
     */    
    int[] getWaveform() {
        int count = 0;
        for (int i = 0; i < len; count++) {
            int l;
            int b = waveform[i++] & 0xff;
            if (b < 0xC0)
                l = 0;
            else if (b < 0xFF)
                l = 1;
            else
                l = 4;
            i += l;
            b = waveform[i++] & 0xff;
            if (b < 0xC0)
                l = 0;
            else if (b < 0xFF)
                l = 1;
            else
                l = 4;
            i += l;
        }
        int[] w = new int[count*2];
        count = 0;
        int t = 0;
        int v = 0;
        for (int i = 0; i < len; count++) {
            int l;
            int b = waveform[i++] & 0xff;
            if (b < 0xC0) {
                l = 0;
            } else if (b < 0xFF) {
                l = 1;
                b -= 0xC0;
            } else {
                l = 4;
            }
            while (l > 0) {
                b = (b << 8) | waveform[i++] & 0xff; 
                l--;
            }
            w[count*2] = t = t + b;
            
            b = waveform[i++] & 0xff;
            if (b < 0xC0) {
                l = 0;
                b -= 0x60;
            } else if (b < 0xFF) {
                l = 1;
                b -= 0xDF;
            } else {
                l = 4;
            }
            while (l > 0) {
                b = (b << 8) | waveform[i++] & 0xff; 
                l--;
            }
            w[count*2 + 1] = v = v + b;
        }
        assert count*2 == w.length;
        return w;
    }
    
    /**
     * Puts byte int packed array.
     * @param value byte to but.
     */
    void putByte(int value) { waveform[len++] = (byte)value; }
    
    /**
     * Ensures that it is possible to add specified number of bytes to packed waveform.
     * @param l number of bytes.
     */
    void ensureCapacity(int l) {
        if (len + l <= waveform.length) return;
        byte[] newWaveform = new byte[waveform.length*3/2];
        System.arraycopy(waveform, 0, newWaveform, 0, waveform.length);
        waveform = newWaveform;
        assert len + l <= waveform.length;
    }
}