/*
    analyzing all arguments of the function call
*/
void analyze_args(Exprs args, char* procName, char* callee, int paramNum)
{
    Expr first = args->first;
    Exprs rest = args->rest;
    if(first && getParamType(callee, paramNum)!=-1)
    {
        analyze_expr(first, procName);
        analyze_arg(first, callee, paramNum, procName);
    }
    else if(first && getParamType(callee, paramNum)==-1)
    {
        printf("function call %s has more number of parameter.\n",
                                                    callee);
        errorNum++;
        return;
    }
    if(rest == 0 && getParamType(callee, paramNum+1)!=-1)
    {
        printf("function call %s has less number of parameter.\n",
                                                    callee);
        errorNum++;
    }
    if(rest)
        analyze_args(rest, procName, callee, paramNum+1);

}
예제 #2
0
void TColorStyle::assignBlend(const TColorStyle &a, const TColorStyle &b,
                              double t) {
  // Blend colors
  {
    int col, colCount = getColorParamCount();
    assert(a.getColorParamCount() == colCount &&
           b.getColorParamCount() == colCount);

    for (col = 0; col != colCount; ++col)
      setColorParamValue(
          col, blend(a.getColorParamValue(col), b.getColorParamValue(col), t));
  }

  // Blend parameters
  {
    int par, parCount = getParamCount();
    assert(a.getParamCount() == parCount && b.getParamCount() == parCount);

    for (par = 0; par != parCount; ++par) {
      switch (getParamType(par)) {
      case DOUBLE:
        setParamValue(par, (1 - t) * a.getParamValue(double_tag(), par) +
                               t * b.getParamValue(double_tag(), par));
        break;
      default:
        break;
      }
    }
  }

  invalidateIcon();
}
예제 #3
0
std::string OfxhParamAccessor::getParamTypeName() const
{
    static const std::string ofxPrefix = "OfxParamType";
    const std::string& type = getParamType();
    BOOST_ASSERT(type.size() > ofxPrefix.size());
    return type.substr(ofxPrefix.size());
}
/* generate code from function call arguments*/
int print_arg(Expr expr, int reg, char* proc_id,
    int paramNum,char* callee) {

    int curr_reg = reg;
    int next_reg;
    int ID_type;
    int ID_type2;
    switch (expr->kind) {
        Type ID_type;
        int stackNo;
        case EXPR_ID:
            ID_type = getType(proc_id,expr->id);
            stackNo = getStackSlotNum(proc_id, expr->id);
            if(isParamRef(callee,paramNum)==0){
                
                printf("load r%d, %d\n", curr_reg,stackNo);
            }
            if(isParamRef(callee,paramNum)==1){
                if(isRef(proc_id, expr->id)==1)
                    printf("load r%d, %d\n", curr_reg,stackNo);
                else
                    printf("load_address r%d, %d\n", curr_reg,stackNo);
            }
            break;
        case EXPR_CONST:
            print_constant(expr->constant, curr_reg);
            
            break;
        case EXPR_BINOP:
            ID_type = getExprType(expr->e1, proc_id);
            ID_type2 = getExprType(expr->e2, proc_id);
            curr_reg = print_expr(expr->e1, curr_reg, proc_id);
            next_reg = print_expr(expr->e2, curr_reg + 1, proc_id);
            print_binop_string(expr->binop, curr_reg, 
                next_reg, ID_type, ID_type2);
            break;
        case EXPR_RELOP:
            ID_type = getExprType(expr->e1, proc_id);
            ID_type2 = getExprType(expr->e2, proc_id);
            
            curr_reg = print_expr(expr->e1, curr_reg, proc_id);
            next_reg = print_expr(expr->e2, curr_reg + 1, proc_id);
            print_relop_string(expr->relop, curr_reg, 
                next_reg, ID_type, ID_type2);
            break;
        case EXPR_UNOP: 
            ID_type = getExprType(expr->e1, proc_id);
            print_unop_string(expr->unop, curr_reg, ID_type);
            break;
            
            }
        if(getExprType(expr,proc_id) != getParamType(callee,paramNum)){
            //printf("%d,%d    ",getExprType(expr), getParamType(callee,paramNum));
            printf("int_to_real r%d, r%d\n", curr_reg,curr_reg);
        }
    return curr_reg;        
}
예제 #5
0
// Возвращает текущее значение параметра.
int16_t LocalParams::getValue() const {
	int16_t v = val;

	if (getParamType() == Param::PARAM_BITES) {
		uint8_t cur = getNumOfCurrSameParam() - 1;
		uint8_t bite = cur % 8;

		v = ((val & (1 << bite)) != 0) ? 1 : 0;
	}

	return v;
}
/*
    analyzing each argument of the function call
    check the arguments number and type with the
    defination of the callee
*/
void analyze_arg(Expr arg, char* callee, int paramNum, char* procName)
{
    if(isParamRef(callee, paramNum)==1)
    {
        // ref parameters
        if (arg->kind != EXPR_ID&& arg->kind!=EXPR_ARRAY)
        {
            printf("ref parameter is not a scaler.\n");
            errorNum++;
        }
        if((getParamType(callee, paramNum) != getExprType(arg, procName)) &&
            (getArrayType(getParamType(callee, paramNum)) != 
                              getExprType(arg, procName)))
        {
            printf("No.%d parameter of function call %s has wrong type.\n",
                paramNum+1, callee);
            errorNum++;
        }
    }
    else if(isParamRef(callee, paramNum)==0)
    {
        // val parameters
        if((getParamType(callee, paramNum) != getExprType(arg, procName)) &&
            (getArrayType(getParamType(callee, paramNum)) != 
                              getExprType(arg, procName)))
        {
            if(getParamType(callee, paramNum) == FLOAT_TYPE && 
                (getExprType(arg, procName) == INT_TYPE ||
                  getExprType(arg, procName) == INT_ARRAY_TYPE))
            {}
            else
            {
                printf("No.%d parameter of function call %s has wrong type.\n",
                    paramNum+1, callee);
                errorNum++;
            }
        }
    }
}
예제 #7
0
static tZGBool getParam(tZGU8 index)
{
    tZGU8 paramType;

    paramType = getParamType(ARGV[index]);
    switch (paramType)
    {
        case kZGUnknownParam:
            sprintf( (char *) g_ConsoleContext.txBuf,
                      "Param %d invalid", index);

            ZG_PUTSUART( (char *) g_ConsoleContext.txBuf );

            return kZGBoolFalse;

        case kZGNetmaskParam:
            gLineParseState = kZGWaitingForNetmaskValue;
            return kZGBoolTrue;

#ifdef ZG_CONFIG_DHCP
        case kZGDHCPParam:
            gLineParseState = kZGWaitingForDHCP;
            return kZGBoolTrue;
#endif

        case kZGGatewayParam:
            gLineParseState = kZGWaitingForGateway;
            return kZGBoolTrue;

        case kZGArpParam:
        case kZGMinusArpParam:
        case kZGDownParam:
        case kZGUpParam:
            sprintf( (char *) g_ConsoleContext.txBuf,
                     "Param %d not supported", index);

            ZG_PUTSUART( (char *) g_ConsoleContext.txBuf );

            return kZGBoolFalse;

        default:
            sprintf( (char *) g_ConsoleContext.txBuf,
                     "Param %d not handled", index);

            ZG_PUTSUART( (char *) g_ConsoleContext.txBuf );

            return kZGBoolFalse;
    }

    return kZGBoolTrue;
}
/*****************************************************************************
* FUNCTION: getParam

*
* RETURNS: None
*
* PARAMS:    tokenIndex -- index of token in the command line
*
* NOTES:
*****************************************************************************/
static tZGBool getParam(tZGU8 tokenIndex)
{
    tZGU8 paramType;

    // Parse the token and return it's corresponding paramType id
    paramType = getParamType(ARGV[tokenIndex]);

    // set the state of the line parsing state machine based on the parameter type.
    // Either need to wait for a value or go on to the next parameter
    switch (paramType)
    {
    case kZGUnknownParam:
        sprintf( (char *) g_ConsoleContext.txBuf,
            "Param %d invalid", tokenIndex);
        ZG_PUTSUART( (char *) g_ConsoleContext.txBuf );
        return kZGBoolFalse;

    case kZGWpaPskParam:
        gLineParseState = kZGWaitingForWpaPsk;
        break;

    case kZGWpaStrParam:
        gLineParseState = kZGWaitingForWpaStr;
        break;

    case kZGEncTypeParam:
        gLineParseState = kZGWaitingForEnc;
        break;

    case kZGWepAuthParam:
        gLineParseState = kZGWaitingForWepAuth;
        break;

    case kZGWepKeyParam:
        gLineParseState = kZGWaitingForWepKey;
        break;

    case kZGBeaconParam:
        gLineParseState = kZGWaitingForBeacon;
        break;

    default:
        sprintf( (char *) g_ConsoleContext.txBuf,
            "Param %d not handled", tokenIndex);

        return kZGBoolFalse;
    }

    return kZGBoolTrue;
}
예제 #9
0
bool TColorStyle::operator==(const TColorStyle &cs) const {
  if (getTagId() != cs.getTagId()) return false;

  if (getMainColor() != cs.getMainColor()) return false;

  int paramCount = getParamCount();
  if (paramCount != cs.getParamCount()) return false;

  int colorParamCount = getColorParamCount();
  if (colorParamCount != cs.getColorParamCount()) return false;

  if (m_name != cs.getName()) return false;
  if (m_originalName != cs.getOriginalName()) return false;
  if (m_globalName != cs.getGlobalName()) return false;
  if (m_isEditedFromOriginal != cs.getIsEditedFlag()) return false;
  if (m_pickedPosition != cs.getPickedPosition()) return false;
  if (m_flags != cs.getFlags()) return false;

  for (int p = 0; p < colorParamCount; ++p)
    if (getColorParamValue(p) != cs.getColorParamValue(p)) return false;

  for (int p = 0; p < paramCount; ++p) {
    switch (getParamType(p)) {
    case BOOL:
      if (getParamValue(bool_tag(), p) != cs.getParamValue(bool_tag(), p))
        return false;
      break;
    case INT:
    case ENUM:
      if (getParamValue(int_tag(), p) != cs.getParamValue(int_tag(), p))
        return false;
      break;
    case DOUBLE:
      if (getParamValue(double_tag(), p) != cs.getParamValue(double_tag(), p))
        return false;
      break;
    case FILEPATH:
      if (getParamValue(TFilePath_tag(), p) !=
          cs.getParamValue(TFilePath_tag(), p))
        return false;
      break;
    default:
      assert(false);
    }
  }

  return true;
}
예제 #10
0
//	Возвращает максимальное значение параметра.
int16_t LocalParams::getMax() const {
	uint16_t max = 0;

	switch(getDependMax()) {
		case Param::DEPEND_MAX_NO:
			max = pgm_read_word(&getPtrParam()->max);
			break;
		case Param::DEPEND_MAX_ON_NUM_DEVS:
			max = numDevices;
			break;
		case Param::DEPEND_MAX_ON_COM_PRD:
			max = numComPrd;
	}

	// для строковых параметров  в максимуме записано макс.количество элементов
	// списка, поэтому скорректируем максимальное значение

	Param::PARAM_TYPE type = getParamType();
	if ((type == Param::PARAM_LIST) || (type == Param::PARAM_BITES)) {
		max = getMin() + max - 1;
	}

	return max;
}
/*****************************************************************************
* FUNCTION: do_iwpriv_cmd
*
* RETURNS: None
*
* PARAMS:    None
*
* NOTES:   Responds to the user invoking ifconfig
*****************************************************************************/
tZGVoidReturn do_iwpriv_cmd(tZGVoidInput)
{
    tZGU8  i;
    tZGU8  temp;
    tZGBool cont_parse;
    tZGS8* ptrString;

    gLineParseState = kZGWaitingForParamKeyword;

    // if user only typed in iwpriv with no other parameters
    if (ARGC == 1u)
    {
        IwprivDisplayStatus();
    }
    // else loop through each parameter
    else
    {
        // parse each param and set state variables
        for (i = 1; i < ARGC; ++i)
        {
            switch (gLineParseState)
            {
            case kZGWaitingForParamKeyword:

                if ( !getParam(i) )
                {
                    return;
                }

                break;

            case kZGWaitingForWpaPsk:

                /* Can only set security in idle state */
                if ( ZG_IS_CONNECTED() == kZGBoolTrue )
                {
                    ZG_PUTRSUART("Security context may only be set in idle state\n\r");
                    return;
                }

                /* The ARGV buffer is modified in place  */
                if ( !ExtractandValidateWpaPSK( ARGV[i] ) )
                {
                    ZG_PUTRSUART("WPA PSK must be exactly 64 bytes\n\r");
                    return;
                }

                ZG_SET_WPAPSK( (tZGU8Ptr) ARGV[i] );
                gLineParseState = kZGWaitingForParamKeyword;

                break;

            case kZGWaitingForWpaStr:

                /* Can only set security in idle state */
                if ( ZG_IS_CONNECTED() == kZGBoolTrue )
                {
                    ZG_PUTRSUART("Security context may only be set in idle state\n\r");
                    return;
                }

                ptrString = ARGV[i++];

                /* if the start char is found, gobble that char */
                if ( (cont_parse = ExtractWpaStrStart(ptrString)) == kZGBoolTrue)
                {
                    ptrString++;
                }

                /* this code concats tokens together with whitespace */
                /* until no more tokens or the EOS " char is found */
                while ( cont_parse && (i++ < ARGC))
                {
                    cont_parse = ExtractWpaStrEnd( ptrString );
                }

                /* if the EOS char is not found then cont parse is true */
                if (cont_parse)
                {
                    ZG_PUTRSUART("Passphrase missing EOS '\"' \n\r");
                    return;
                }

                /* temp contains the string length after call */
                if ( !ValidateWpaStr(&ptrString, &temp) )
                {
                    ZG_PUTRSUART("Passphrase must be between 8 and 63 chars\n\r");
                    return;
                }

                ZG_SET_WPA_PASSPHRASE( ptrString, temp );

                gLineParseState = kZGWaitingForParamKeyword;

                break;

            case kZGWaitingForEnc:
                /* Can only set security in idle state */
                if ( ZG_IS_CONNECTED() == kZGBoolTrue )
                {
                    ZG_PUTRSUART("Security context may only be set in idle state\n\r");
                    return;
                }

                /* temp contains the encryption type enum */
                if ( !ExtractandValidateEncType(ARGV[i], &temp) )
                {
                    ZG_PUTRSUART("Invalid encyption type\n\r");
                    return;
                }

                ZG_SET_ENC_TYPE( temp );
                gLineParseState = kZGWaitingForParamKeyword;

                break;


            case kZGWaitingForWepAuth:

                /* Can only set security in idle state */
                if ( ZG_IS_CONNECTED() == kZGBoolTrue )
                {
                    ZG_PUTRSUART("Security context may only be set in idle state\n\r");
                    return;
                }

                /* temp contains the Wep Auth type enum */
                if ( !ExtractandValidateAuthType(ARGV[i], &temp) )
                {
                    ZG_PUTRSUART("Invalid WEP Auth type\n\r");
                    return;
                }

                ZG_SET_AUTH_TYPE( temp );
                gLineParseState = kZGWaitingForParamKeyword;

                break;

            case kZGWaitingForWepKey:

                /* Can only set security in idle state */
                if ( ZG_IS_CONNECTED() == kZGBoolTrue )
                {
                    ZG_PUTRSUART("Security context may only be set in idle state\n\r");
                    return;
                }

                /* temp contains the active WEP key index 1 of 4 */
                if ( !ExtractandValidateWepIndex(ARGV[i], &temp) )
                {
                    ZG_PUTRSUART("Invalid WEP key index\n\r");
                    return;
                }

                /* check for a 3rd optional parameter */
                if ( (i+1 < ARGC) &&
                    (getParamType(ARGV[i+1]) == kZGUnknownParam) )
                {

                    i++;  /* advance to the optional param */

                    /* The ARGV buffer is modified in place  */
                    if ( ExtractandValidateWepLong( ARGV[i] ) )
                    {
                        ZG_SET_WEP_KEY_LONG( (tZGU8Ptr) ARGV[i], temp );
                    }
                    else if ( ExtractandValidateWepShort( ARGV[i] ) )
                    {
                        ZG_SET_WEP_KEY_SHORT( (tZGU8Ptr) ARGV[i], temp );
                    }
                    else
                    {
                        ZG_PUTRSUART("\n\rWarning, 64/128bit WEP key format not valid \n\r\t");
                        return;
                    }
                }

                ZG_SET_WEP_ACTIVE_INDEX(temp);

                gLineParseState = kZGWaitingForParamKeyword;
                break;

            default:

                ZGSYS_MODULE_ASSERT(2, (ROM FAR char*)"iwpriv param");
                break;

            } // end switch

        } // end for
    }

    switch (gLineParseState)
    {
    case kZGWaitingForBeacon:

        // Send an untampered frame that looks like a Beacon.
        iwpriv_beacon();

        gLineParseState = kZGWaitingForParamKeyword;
        break;

    default:
        //do nothing
        break;
    }

    if (gLineParseState != (tZGU8)kZGWaitingForParamKeyword)
    {
        ZG_PUTRSUART("Missing value after last parameter\n\r");
    }

}