AM_PARAM Class Reference

AM_PARAM holds 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)
	function PushOperator 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
	Function IsImmediate tests 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)
	Function ReadParam Read one aperture macro parameter a parameter can be: a number a reference to an aperture definition parameter value: $1 ot $3 ... More...

Private Attributes
int	m_index
std::vector< AM_PARAM_ITEM >	m_paramStack

Detailed Description

AM_PARAM holds 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 defered 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 286 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 316 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

Function IsImmediate tests 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 defered 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
	)

function PushOperator 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	= the type of item (NOP, PUSHVALUE, PUSHPARM, ADD, SUB, MUL, DIV, EQUATE)
aValue	= 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

)

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 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 321 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

Definition at line 289 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

Definition at line 290 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