mfbbasic.c

spice中支持多层次元件模型仿真的可单独运行的插件源码

/**********
Copyright 1990 Regents of the University of California.  All rights reserved.
Author: -C- 1982 Giles C. Billingsley
**********/
/*
 * mfbbasic.c
 *
 * sccsid "@(#)mfbbasic.c   1.9  9/3/83"
 *
 *     MFB is a graphics package that was developed by the integrated
 * circuits group of the Electronics Research Laboratory and the
 * Department of Electrical Engineering and Computer Sciences at
 * the University of California, Berkeley, California.  The programs
 * in MFB are available free of charge to any interested party.
 * The sale, resale, or use of these program for profit without the
 * express written consent of the Department of Electrical Engineering
 * and Computer Sciences, University of California, Berkeley, California,
 * is forbidden.
 */


#include "spice.h"
#include "mfb.h"
#include <stdio.h>
#include "suffix.h"

#define RadToDeg    57.29577951
#define MFBFORMAT   MFBCurrent->strings

/* Here we take care of externs */
MFB *MFBCurrent;


/*****************************************************************************
 *
 *          BASIC MACROS AND SERVICE ROUTINES
 *
 *****************************************************************************/

int
MFBInfo(Info)
    int Info;
    {
    /*
     * Notes:
     *    MFBInfo is the only routine for acquiring device
     *    specific information.  The valid arguments are to
     *    MFBInfo are defined in mfb.h.  If an invalid argument
     *    is used, MFBInfo returns -1.
     */
    switch(Info){
    case  MAXX:
        return(MFBCurrent->maxX);
    case  MAXY:
        return(MFBCurrent->maxY);
    case  MAXCOLORS:
        return(MFBCurrent->maxColors);
    case  MAXINTENSITY:
        return(MFBCurrent->maxIntensity);
    case  MAXFILLPATTERNS:
        return(MFBCurrent->maxFillPatterns);
    case  MAXLINESTYLES:
        return(MFBCurrent->maxLineStyles);
    case  MAXBLINKERS:
        return(MFBCurrent->maxBlinkers);
    case  POINTINGDEVICE:
        return((int)MFBCurrent->PointingDeviceBool);
    case  POINTINGBUTTONS:
        return((int)MFBCurrent->buttonsBool);
    case  NUMBUTTONS:
        return(MFBCurrent->numberOfButtons);
    case  BUTTON1:
        return(MFBCurrent->buttonMask[0]);
    case  BUTTON2:
        return(MFBCurrent->buttonMask[1]);
    case  BUTTON3:
        return(MFBCurrent->buttonMask[2]);
    case  BUTTON4:
        return(MFBCurrent->buttonMask[3]);
    case  BUTTON5:
        return(MFBCurrent->buttonMask[4]);
    case  BUTTON6:
        return(MFBCurrent->buttonMask[5]);
    case  BUTTON7:
        return(MFBCurrent->buttonMask[6]);
    case  BUTTON8:
        return(MFBCurrent->buttonMask[7]);
    case  BUTTON9:
        return(MFBCurrent->buttonMask[8]);
    case  BUTTON10:
        return(MFBCurrent->buttonMask[9]);
    case  BUTTON11:
        return(MFBCurrent->buttonMask[10]);
    case  BUTTON12:
        return(MFBCurrent->buttonMask[11]);
    case  TEXTPOSITIONALBE:
        return((int)MFBCurrent->textPositionableBool);
    case  TEXTROTATABLE:
        return((int)MFBCurrent->textRotateBool);
    case  FONTHEIGHT:
        return(MFBCurrent->fontHeight);
    case  FONTWIDTH:
        return(MFBCurrent->fontWidth);
    case  FONTXOFFSET:
        return(MFBCurrent->fontXOffset);
    case  FONTYOFFSET:
        return(MFBCurrent->fontYOffset);
    case  DESTRUCTIVETEXT:
        return((int)MFBCurrent->replaceTextBool);
    case  OVERSTRIKETEXT:
        return((int)MFBCurrent->overstrikeTextBool);
    case  VLT:
        return((int)MFBCurrent->vltBool);
    case  BLINKERS:
        return((int)MFBCurrent->blinkersBool);
    case  FILLEDPOLYGONS:
        return((int)MFBCurrent->filledPlygnBool);
    case  DEFFILLPATTERNS:
        return((int)MFBCurrent->fillPtrnDefineBool);
    case  DEFREADMASK:
        return((int)MFBCurrent->readMaskBool);
    case  DEFCHANNELMASK:
        return((int)MFBCurrent->channelMaskBool);
    case  DEFLINEPATTERN:
        return((int)MFBCurrent->linePatternDefineBool);
    case  CURFGCOLOR:
        return(MFBCurrent->fgColorId);
    case  CURFILLPATTERN:
        return(MFBCurrent->fillPattern);
    case  CURLINESTYLE:
        return(MFBCurrent->lineStyle);
    case  CURCHANNELMASK:
        return(MFBCurrent->channelMask);
    case  CURREADMASK:
        return(MFBCurrent->readMask);
    case  NUMBITPLANES:
        return(MFBCurrent->lengthOfVLT);
    case  RASTERCOPY:
        return((int)MFBCurrent->rastCopyBool);
    case  OFFSCREENX:
        return(MFBCurrent->minOffScreenX);
    case  OFFSCREENY:
        return(MFBCurrent->minOffScreenY);
    case  OFFSCREENDX:
        return(MFBCurrent->offScreenDX);
    case  OFFSCREENDY:
        return(MFBCurrent->offScreenDY);
    default:
        return(-1);
    }
    }


void
MFBConvertToHLS(r,g,b)
    int r,g,b;
    /*
     * Notes:
     *    The HLS values are returned in MFBCurrent->Y,
     *    MFBCurrent->Z, and MFBCurrent->T.
     */
    {
    double rrr,ggg,bbb,rr,gg,bb,sum,dif,mx,mn,lit,intensity;
    intensity = (double)MFBCurrent->maxIntensity;
    /* RGB is normalized to 1000 */
    rr = ((double) r)/1000.0;
    gg = ((double) g)/1000.0;
    bb = ((double) b)/1000.0;
    mx = rr;
    if(mx < gg) mx = gg;
    if(mx < bb) mx = bb;
    mn = rr;
    if(mn > gg) mn = gg;
    if(mn > bb) mn = bb;
    sum = mx + mn; dif = mx - mn;
    if(dif != 0.0){
        rrr = (mx - rr)/dif; ggg = (mx - gg)/dif; bbb = (mx - bb)/dif;
        }
    /* lightness calculation */
    lit = sum/2.0;
    /* saturation calculation */
    if(mx == mn) MFBCurrent->T = 0;
    else if(lit <= .5) MFBCurrent->T = (int)(intensity * dif/sum);
    else MFBCurrent->T = (int)((intensity * dif)/(2.0 - sum));
    /* hue calculation */
    if(MFBCurrent->T == 0) MFBCurrent->Y = 0;
    else if(rr == mx) MFBCurrent->Y = (int)(60.0 * (2.0 + bbb - ggg));
    else if(gg == mx) MFBCurrent->Y = (int)(60.0 * (4.0 + rrr - bbb));
    else MFBCurrent->Y = (int)(60.0 * (6.0 + ggg - rrr));
    MFBCurrent->Z = (int)(intensity * lit);
    }


void
SetCurrentMFB(mfb)
    MFB *mfb;
    /*
     * Notes:
     *    Set the current frame buffer.  Since each MFB struct contains
     *    all necessary I/O information, it is possible for a host
     *    program to manipulate several different graphics displays by
     *    simply maintaining a MFB struct for each device.
     */
    {
    MFBCurrent = mfb;
    }


void
MFBZeroCounters() {
#ifdef DEBUG
    if(MFBCurrent == NULL) return;
    MFBCurrent->nChars = MFBCurrent->nBoxes
    = MFBCurrent->nLines = MFBCurrent->nChars
    = MFBCurrent->sumBoxArea = MFBCurrent->sumLineLength = 0;
#endif
    }


void
MFBCounters(nChars,nBoxes,meanBoxArea,nLines,meanLineLength,nPixels)
    int *nChars,*nBoxes,*meanBoxArea,*nLines,*meanLineLength,*nPixels;
    {
#ifdef DEBUG
    /*
     * routine for measuring approximate pixel bandwidth
     */
    *nChars = MFBCurrent->nChars;
    *nBoxes = MFBCurrent->nBoxes;
    *nLines = MFBCurrent->nLines;
    *meanLineLength = 0;
    *meanBoxArea = 0;
    if(MFBCurrent->nBoxes != 0)
    *meanBoxArea = MFBCurrent->sumBoxArea/MFBCurrent->nBoxes;
    if(MFBCurrent->nLines != 0)
    *meanLineLength = MFBCurrent->sumLineLength/MFBCurrent->nLines;
    *nPixels = 
    MFBCurrent->nChars*MFBCurrent->fontHeight*MFBCurrent->fontWidth+
    MFBCurrent->sumBoxArea+
    MFBCurrent->sumLineLength;
#else
    *nChars = *nBoxes = *nLines = *meanLineLength = *meanBoxArea = 0;
#endif
    }





/*****************************************************************************
 *
 *      SET VIEWPORT ATTRIBUTES
 *
 *****************************************************************************/

MFBSetLineStyle(styleId)
    int styleId;
    /*
     * Notes:
     *    Sets current line style.
     *    Return immediately if line style is already current.
     *    Return MFBBADLST if styleId is out of range.
     */
    {
    /*
     * Check if styleId is already the current line style
     */
    if(styleId == MFBCurrent->lineStyle && !MFBCurrent->reissueLineStyleBool)
    return(MFBOK);
    if(styleId < 0 || styleId >= MFBCurrent->maxLineStyles)
    /* bad styleId */
    return(MFBBADLST);
    else {
    MFBCurrent->X = MFBCurrent->lineStyle = styleId;
    if(styleId == 0 && MFBFORMAT.setSolidLineStyle != NULL
        && *MFBFORMAT.setSolidLineStyle != 0)
        MFBGenCode(MFBFORMAT.setSolidLineStyle);
    else
        MFBGenCode(MFBFORMAT.setLineStyle);
    }
    return(MFBOK);
    }


MFBSetFillPattern(styleId)
    int styleId;
    /*
     * Notes:
     *    Sets current fill pattern.
     *
     *    CURRENT COLOR MUST BE SET PRIOR TO SETTING FILL STYLE!!!!!!!!
     *    Some frame buffers allow multi-colored stipple patterns.
     *    MFB sets all pixels in the bit array to either the
     *    background color (ID = 0) or the current forground color.
     */
    {

    /*
     * Check if styleId is already the current fill style
     */
    if(styleId == MFBCurrent->fillPattern)
    return(MFBOK);
    if(styleId < 0 || styleId >= MFBCurrent->maxFillPatterns)
    /* bad styleId */
    return(MFBBADFST);
    else {
    MFBCurrent->X = MFBCurrent->fillPattern = styleId;
    if(styleId == 0 && MFBFORMAT.setSolidFillPattern != NULL
        && *MFBFORMAT.setSolidFillPattern != 0)
        MFBGenCode(MFBFORMAT.setSolidFillPattern);
    else
        MFBGenCode(MFBFORMAT.setFillPattern);
    }
    return(MFBOK);
    }


int
MFBSetChannelMask(channelMask)
    int channelMask;
    /*
     * Notes:
     *    Sets write enable mask.  This is relevant only to terminals
     *    which have write enable masks.
     */
    {

    /* Is channel mask already set? */
    if(channelMask == MFBCurrent->channelMask)
    return(MFBOK);
    /* Are there channel or write-enable masks? */
    if(!MFBCurrent->channelMaskBool)
    return(MFBNOMASK);
    else{
    MFBCurrent->X = MFBCurrent->channelMask = channelMask;
    MFBGenCode(MFBFORMAT.channelMaskSet);
    }
    return(MFBOK);
    }


int
MFBSetReadMask(readMask)
    int readMask;
    /*
     * Notes:
     *    Sets write enable mask.  This is relevant only to terminals
     *    which have write enable masks.
     */
    {

    /* Is channel mask already set? */
    if(readMask == MFBCurrent->readMask)
    return(MFBOK);
    /* Are there channel or write-enable masks? */
    if(!MFBCurrent->readMaskBool)
    return(MFBNOMASK);
    else{
    MFBCurrent->X = MFBCurrent->readMask = readMask;
    MFBGenCode(MFBFORMAT.readMaskSet);
    }
    return(MFBOK);
    }


int
MFBSetColor(colorId)
    int colorId;
    /*
     * Notes:
     *    Sets the current (foreground) color to `colorId'.
     */
    {

    /*
     * Check if styleId is already the foreground color
     */
    if(colorId == MFBCurrent->fgColorId) return(MFBOK);

    if(colorId < 0 || colorId >= MFBCurrent->maxColors)
    /* bad colorId */
/*    return(MFBBADCST); commented out for test, p.w.h. */
    return(MFBOK); /* quickhack, p.w.h. */
    else {
    MFBCurrent->X = MFBCurrent->fgColorId = colorId;
    MFBGenCode(MFBFORMAT.setForegroundColor);
    }
    return(MFBOK);
    }


int
MFBSetTextMode(destructiveBool)
    Bool destructiveBool;
    /*
     * Notes:
     *    Changes mode of displaying text if possible.
     *    If destructiveBool is true,the the destructive
     *    text mode is set.  Also,the text index is changed
     *    to colorId.
     */
    {
    if(MFBCurrent->textMode != (int)destructiveBool) {
    if(destructiveBool){
        if(!MFBCurrent->replaceTextBool)
        return(MFBBADTM1);
        MFBGenCode(MFBFORMAT.replaceON);
        }
    else{
        if(!MFBCurrent->overstrikeTextBool)
        return(MFBBADTM2);
        MFBGenCode(MFBFORMAT.overstrikeON);
        }
    MFBCurrent->textMode = (int)destructiveBool;
    }
    return(MFBOK);
    }


int
MFBSetALUMode(mode)
    int mode;
    /*
     * Notes:
     *    This routine changes the mode by which pixels on the screen
     *    are changed when written over.  The four possible operations
     *    are:
     *      mode = MFBALUJAM    JAM (replace mode)
     *      mode = MFBALUOR     OR
     *      mode = MFBALUNOR    NOR
     *      mode = MFBALUEOR    EOR
     *    If MFB cannot set the ALU mode, MFBBADALU is returned.  Otherwise,
     *    MFBOK is returned.
     */
    {
    char *cp;
    switch(mode){
        case MFBALUJAM:
        cp = MFBFORMAT.setALUJAM;
        break;
        case MFBALUOR: