AM_PARAM Class Reference

Hold a parameter value for an "aperture macro" as defined within standard RS274X. More...

#include <am_param.h>

Public Member Functions
	AM_PARAM ()
void	PushOperator (parm_item_type aType, double aValue)
	Add an operator/operand to the current stack. More...
void	PushOperator (parm_item_type aType, int aValue=0)
double	GetValue (const D_CODE *aDcode) const
bool	IsImmediate () const
	Test if this AM_PARAM holds an immediate parameter or is a pointer into a parameter held by an owning D_CODE. More...
unsigned	GetIndex () const
void	SetIndex (int aIndex)
bool	ReadParam (char *&aText)
	Read one aperture macro parameter. More...

Private Attributes
int	m_index
	has meaning to define parameter local to an aperture macro More...
std::vector< AM_PARAM_ITEM >	m_paramStack
	List of operands/operators to evaluate the actual value if a par def is $3/2, there are 3 items in stack: 3 (type PUSHPARM) , / (type DIV), 2 (type PUSHVALUE). More...

Detailed Description

Hold a parameter value for an "aperture macro" as defined within standard RS274X.

The parameter can be a constant, i.e. "immediate" parameter, or depend on some deferred values, defined in a D_CODE, by the ADD command. Note the actual value could need an evaluation from an arithmetical expression items in the expression are stored in. A simple definition is just a value stored in one item in m_paramStack.

Definition at line 284 of file am_param.h.

Constructor & Destructor Documentation

AM_PARAM()

AM_PARAM::AM_PARAM

(

)

Definition at line 49 of file am_param.cpp.

{
    m_index = -1;
}

References m_index.

Member Function Documentation

GetIndex()

unsigned AM_PARAM::GetIndex ( ) const

inline

Definition at line 309 of file am_param.h.

    {
        return (unsigned) m_index;
    }

References m_index.

GetValue()

double AM_PARAM::GetValue

(

const D_CODE *

aDcode

)

const

Definition at line 74 of file am_param.cpp.

{
    // In macros, actual values are sometimes given by an expression like:
    // 0-$2/2-$4
    // Because arithmetic predence is used, the parameters (values (double) and operators)
    // are stored in a stack, with all numeric values converted to the actual values
    // when they are defered parameters
    // Each item is stored in a AM_PARAM_EVAL (a value or an operator)
    //
    // Then the stack with all values resolved is parsed and numeric values
    // calculated according to the precedence of operators
    double curr_value = 0.0;
    parm_item_type op_code;

    AM_PARAM_EVAL_STACK ops;

    for( unsigned ii = 0; ii < m_paramStack.size(); ii++ )
    {
        AM_PARAM_ITEM item = m_paramStack[ii];

        switch( item.GetType() )
        {
            case ADD:
            case SUB:
            case MUL:
            case DIV:       // just an operator for next parameter value
            case OPEN_PAR:
            case CLOSE_PAR: // Priority modifiers: store in stack
                op_code = item.GetType();
                ops.push_back( AM_PARAM_EVAL( op_code ) );
                break;

            case PUSHPARM:
                // a defered value: get the actual parameter from the aDcode
                if( aDcode )    // should be always true here
                {
                    if( item.GetIndex() <= aDcode->GetParamCount() )
                    {
                        curr_value = aDcode->GetParam( item.GetIndex() );
                    }
                    else    // Get parameter from local param definition
                    {
                        const APERTURE_MACRO * am_parent = aDcode->GetMacro();
                        curr_value = am_parent->GetLocalParam( aDcode, item.GetIndex() );
                    }
                }
                else
                {
                    wxFAIL_MSG( "AM_PARAM::GetValue(): NULL param aDcode" );
                }

                ops.push_back( AM_PARAM_EVAL( curr_value ) );
                break;

            case PUSHVALUE: // a value is on the stack:
                curr_value = item.GetValue();
                ops.push_back( AM_PARAM_EVAL( curr_value ) );
                break;

            default:
                wxFAIL_MSG( wxString::Format( "AM_PARAM::GetValue(): dcode %d prm %d/%d: "
                                              "unexpected type %d",
                                               aDcode ? aDcode->m_Num_Dcode : -1, ii,
                                               m_paramStack.size(), item.GetType() ) );
                break;
        }
    }

    double result = Evaluate( ops );

    return result;
}

References ADD, CLOSE_PAR, DIV, Evaluate(), Format(), AM_PARAM_ITEM::GetIndex(), APERTURE_MACRO::GetLocalParam(), D_CODE::GetMacro(), D_CODE::GetParam(), D_CODE::GetParamCount(), AM_PARAM_ITEM::GetType(), AM_PARAM_ITEM::GetValue(), D_CODE::m_Num_Dcode, m_paramStack, MUL, OPEN_PAR, PUSHPARM, PUSHVALUE, and SUB.

Referenced by APERTURE_MACRO::GetLocalParam().

IsImmediate()

bool AM_PARAM::IsImmediate

(

)

const

Test if this AM_PARAM holds an immediate parameter or is a pointer into a parameter held by an owning D_CODE.

Function IsImmediate tests if this AM_PARAM holds an immediate parameter or has parameter held by an owning D_CODE.

Returns

true if the value is immediate, i.e. no deferred value in operands used in its definition.

Definition at line 59 of file am_param.cpp.

{
    bool is_immediate = true;
    for( unsigned ii = 0; ii < m_paramStack.size(); ii++ )
    {
        if( m_paramStack[ii].IsDefered() )
        {   // a defered value is found in operand list,
            // so the parameter is not immediate
            is_immediate = false;
            break;
        }
    }
    return is_immediate;
}

References m_paramStack.

PushOperator() [1/2]

void AM_PARAM::PushOperator	(	parm_item_type	aType,
		double	aValue
	)

Add an operator/operand to the current stack.

add an operator/operand to the current stack aType = NOP, PUSHVALUE, PUSHPARM, ADD, SUB, MUL, DIV, EQUATE aValue required only for PUSHVALUE (double) or PUSHPARM (int) aType.

Parameters

aType	is the type of item (NOP, PUSHVALUE, PUSHPARM, ADD, SUB, MUL, DIV, EQUATE)
aValue	is the item value, double for PUSHVALUE or int for PUSHPARM type.

Definition at line 152 of file am_param.cpp.

{
    AM_PARAM_ITEM item( aType, aValue);
    m_paramStack.push_back( item );
}

References m_paramStack.

Referenced by ReadParam().

PushOperator() [2/2]

void AM_PARAM::PushOperator	(	parm_item_type	aType,
		int	aValue = 0
	)

Definition at line 158 of file am_param.cpp.

{
    AM_PARAM_ITEM item( aType, aValue);
    m_paramStack.push_back( item );
}

References m_paramStack.

ReadParam()

bool AM_PARAM::ReadParam

(

char *&

aText

)

Read one aperture macro parameter.

Function ReadParam Read one aperture macro parameter a parameter can be: a number a reference to an aperture definition parameter value: $1 ot $3 ...

a parameter can be: a number a reference to an aperture definition parameter value: $1 to $3 ... a parameter definition can be complex and have operators between numbers and/or other parameter like $1+3 or $2x2.. Parameters are separated by a comma ( of finish by *)

Parameters

aText

= pointer to the parameter to read. Will be modified to point to the next field

Returns

true if a param is read, or false

a parameter definition can be complex and have operators between numbers and/or other parameter like $1+3 or $2x2.. Note minus sign is not always an operator. It can be the sign of a value. Parameters are separated by a comma ( of finish by *)

Parameters

aText

= pointer to the parameter to read. Will be modified to point to the next field

Returns

true if a param is read, or false

Definition at line 177 of file am_param.cpp.

{
    bool found = false;
    int ivalue;
    double dvalue;
    bool end = false;

    while( !end )
    {
        switch( *aText )
        {
        case ',':
            aText++;

            if( !found )    // happens when a string starts by ',' before any param
                break;      // just skip this separator

            KI_FALLTHROUGH;

        case '\n':
        case '\r':
        case 0:     // EOL
        case '*':   // Terminator in a gerber command
            end = true;
            break;

        case ' ':
            aText++;
            break;

        case '$':
            // defered value defined later, in ADD command which define defered parameters
            ++aText;
            ivalue = ReadInt( aText, false );
            if( m_index < 1 )
                SetIndex( ivalue );
            PushOperator( PUSHPARM, ivalue );
            found = true;
            break;

        case '/':
            PushOperator( DIV );
            aText++;
            break;

        case '(':   // Open a block to evaluate an expression between '(' and ')'
            PushOperator( OPEN_PAR );
            aText++;
            break;

        case ')':   // close a block between '(' and ')'
            PushOperator( CLOSE_PAR );
            aText++;
            break;

        case 'x':
        case 'X':
            PushOperator( MUL );
            aText++;
            break;

        case '-':
        case '+':
            // Test if this is an operator between 2 params, or the sign of a value
            if( m_paramStack.size() > 0 && !m_paramStack.back().IsOperator() )
            {   // Seems an operator
                PushOperator( *aText == '+' ? ADD : SUB );
                aText++;
            }
            else
            {   // seems the sign of a value
                dvalue = ReadDouble( aText, false );
                PushOperator( PUSHVALUE, dvalue );
                found = true;
            }
            break;

        case '=':   // A local definition found like $4=$3/2
            // At this point, one defered parameter is expected to be read.
            // this parameter value (the index) is stored in m_index.
            // The list of items is cleared
            aText++;
            m_paramStack.clear();
            found = false;
            break;

        default:
            dvalue = ReadDouble( aText, false );
            PushOperator( PUSHVALUE, dvalue );
            found = true;
            break;
        }
    }

    return found;
}

References ADD, CLOSE_PAR, DIV, KI_FALLTHROUGH, m_index, m_paramStack, MUL, OPEN_PAR, PushOperator(), PUSHPARM, PUSHVALUE, ReadDouble(), ReadInt(), SetIndex(), and SUB.

Referenced by GERBER_FILE_IMAGE::ReadApertureMacro().

SetIndex()

void AM_PARAM::SetIndex ( int  aIndex )

inline

Definition at line 314 of file am_param.h.

    {
        m_index = aIndex;
    }

References m_index.

Referenced by ReadParam().

Member Data Documentation

m_index

int AM_PARAM::m_index

private

has meaning to define parameter local to an aperture macro

Definition at line 335 of file am_param.h.

Referenced by AM_PARAM(), GetIndex(), ReadParam(), and SetIndex().

m_paramStack

std::vector<AM_PARAM_ITEM> AM_PARAM::m_paramStack

private

List of operands/operators to evaluate the actual value if a par def is $3/2, there are 3 items in stack: 3 (type PUSHPARM) , / (type DIV), 2 (type PUSHVALUE).

Definition at line 336 of file am_param.h.

Referenced by GetValue(), IsImmediate(), PushOperator(), and ReadParam().

---

The documentation for this class was generated from the following files:

• am_param.h
• am_param.cpp