Exemple #1
0
//-----------------------------------------------------------------------------
// (For text buffers only)
// Parse a token from the buffer:
// Grab all text that lies between a starting delimiter + ending delimiter
// (skipping whitespace that leads + trails both delimiters).
// Note the delimiter checks are case-insensitive.
// If successful, the get index is advanced and the function returns true,
// otherwise the index is not advanced and the function returns false.
//-----------------------------------------------------------------------------
bool CUtlBuffer::ParseToken( const char *pStartingDelim, const char *pEndingDelim, char* pString, int nMaxLen )
{
	int nCharsToCopy = 0;
	int nCurrentGet = 0;

	size_t nEndingDelimLen;

	// Starting delimiter is optional
	char emptyBuf = '\0';
	if ( !pStartingDelim )
	{
		pStartingDelim = &emptyBuf;
	}

	// Ending delimiter is not
	Assert( pEndingDelim && pEndingDelim[0] );
	nEndingDelimLen = Q_strlen( pEndingDelim );

	int nStartGet = TellGet();
	char nCurrChar;
	int nTokenStart = -1;
	EatWhiteSpace( );
	while ( *pStartingDelim )
	{
		nCurrChar = *pStartingDelim++;
		if ( !isspace((unsigned char)nCurrChar) )
		{
			if ( tolower( GetChar() ) != tolower( nCurrChar ) )
				goto parseFailed;
		}
		else
		{
			EatWhiteSpace();
		}
	}

	EatWhiteSpace();
	nTokenStart = TellGet();
	if ( !GetToken( pEndingDelim ) )
		goto parseFailed;

	nCurrentGet = TellGet();
	nCharsToCopy = (nCurrentGet - nEndingDelimLen) - nTokenStart;
	if ( nCharsToCopy >= nMaxLen )
	{
		nCharsToCopy = nMaxLen - 1;
	}

	if ( nCharsToCopy > 0 )
	{
		SeekGet( CUtlBuffer::SEEK_HEAD, nTokenStart );
		Get( pString, nCharsToCopy );
		if ( !IsValid() )
			goto parseFailed;

		// Eat trailing whitespace
		for ( ; nCharsToCopy > 0; --nCharsToCopy )
		{
			if ( !isspace( (unsigned char)pString[ nCharsToCopy-1 ] ) )
				break;
		}
	}
	pString[ nCharsToCopy ] = '\0';

	// Advance the Get index
	SeekGet( CUtlBuffer::SEEK_HEAD, nCurrentGet );
	return true;

parseFailed:
	// Revert the get index
	SeekGet( SEEK_HEAD, nStartGet );
	pString[0] = '\0';
	return false;
}
Exemple #2
0
void CommHandler(void) //UART4 Interrupt handler implementation
{
    int c = GetChar();

    if (c >= 0)
    {
        //ConfigMode = 1;
        LEDon();
        //print("got char %02X\r\n", c);

        switch (c)
        {
            case 'b':
                print("rebooting into boot loader ...\r\n");
                Delay_ms(1000);
                bootloader();
                break;

            case 'c':
                debugCnt ^= 1;
                print("counter messages %s\r\n", debugCnt ? "on" : "off");
                break;

            case 'd':
                debugPrint ^= 1;
                print("debug messages %s\r\n", debugPrint ? "on" : "off");
                break;

            case 'g':
                Delay_ms(100);
                PutChar('x');

                for (int i = 0; i < CONFIGDATASIZE; i++)
                {
                    uint8_t data = configData[i];
                    PutChar(data);
                }

                break;

            case 'G':
                printConfig();
                break;

#if 0

            case 'H':
                if (CharAvailable() >= CONFIGDATASIZE)
                {
                    for (int i = 0; i < CONFIGDATASIZE; i++)
                    {
                        uint8_t data = GetChar();

                        if (data <= LARGEST_CONFIGDATA)
                        {
                            configData[i] = data;
                        }
                    }

                    configSave();
                }
                else
                {
                    UnGetChar(c); // try again in next loop
                }

                break;
#endif

            case 'h':
                for (int i = 0; i < CONFIGDATASIZE; i++)
                {
                    int data;

                    while ((data = GetChar()) < 0)
                        ;

                    if (data <= LARGEST_CONFIGDATA)
                    {
                        configData[i] = data;
                    }
                }

                configSave();
                break;

            case 'i':
                ConfigMode = 1;
                break;

            case 'j':
                ConfigMode = 0;
                break;

            case 'o':
                debugOrient ^= 1;
                print("Orientation messages %s\r\n", debugOrient ? "on" : "off");
                break;

            case 'p':
                debugPerf ^= 1;
                print("performance messages %s\r\n", debugPerf ? "on" : "off");
                break;

            case 'r':
                debugRC ^= 1;
                print("RC messages %s\r\n", debugRC ? "on" : "off");
                break;

            case 'R':
                print("rebooting...\r\n");
                Delay_ms(1000);
                reboot();
                break;

            case 's':
                debugSense ^= 1;
                print("Sensor messages %s\r\n", debugSense ? "on" : "off");
                break;

            case 'u':
            {
                extern int bDeviceState;
                printUSART("\r\nYY bDeviceState %3d  VCPConnectMode %d\r\n", bDeviceState, GetVCPConnectMode());
                break;
            }

            case '+':
                testPhase += 0.1;
                print("test phase output %5.1f\r\n", testPhase);
                break;

            case '-':
                testPhase -= 0.1;
                print("test phase output %5.1f\r\n", testPhase);
                break;

            default:
                // TODO
                break;
        }
    }
}
//------------------------------------------------------------------------------
bool FBasicTokenParser::GetToken(FBasicToken& Token, bool bNoConsts/* = false*/)
{
	// if the parser is in a bad state, then don't continue parsing (who 
	// knows what will happen!?)
	if (!IsValid())
	{
		return false;
	}

	Token.TokenName	= NAME_None;
	TCHAR c = GetLeadingChar();
	TCHAR p = PeekChar();
	if( c == 0 )
	{
		UngetChar();
		return 0;
	}
	Token.StartPos		= PrevPos;
	Token.StartLine		= PrevLine;
	if( (c>='A' && c<='Z') || (c>='a' && c<='z') || (c=='_') )
	{
		// Alphanumeric token.
		int32 Length=0;
		do
		{
			Token.Identifier[Length++] = c;
			if( Length >= NAME_SIZE )
			{
				Length = ((int32)NAME_SIZE) - 1;
				Token.Identifier[Length]=0; // need this for the error description

				FText ErrorDesc = FText::Format(LOCTEXT("IdTooLong", "Identifer ({0}...) exceeds maximum length of {1}"), FText::FromString(Token.Identifier), FText::AsNumber((int32)NAME_SIZE));
				SetError(FErrorState::ParseError, ErrorDesc);

				break;
			}
			c = GetChar();
		} while( ((c>='A')&&(c<='Z')) || ((c>='a')&&(c<='z')) || ((c>='0')&&(c<='9')) || (c=='_') );
		UngetChar();
		Token.Identifier[Length]=0;

		// Assume this is an identifier unless we find otherwise.
		Token.TokenType = FBasicToken::TOKEN_Identifier;

		// Lookup the token's global name.
		Token.TokenName = FName( Token.Identifier, FNAME_Find, true );

		// If const values are allowed, determine whether the identifier represents a constant
		if ( !bNoConsts )
		{
			// See if the identifier is part of a vector, rotation or other struct constant.
			// boolean true/false
			if( Token.Matches(TEXT("true")) )
			{
				Token.SetConstBool(true);
				return true;
			}
			else if( Token.Matches(TEXT("false")) )
			{
				Token.SetConstBool(false);
				return true;
			}
		}

		return IsValid();
	}
	// if const values are allowed, determine whether the non-identifier token represents a const
	else if ( !bNoConsts && ((c>='0' && c<='9') || ((c=='+' || c=='-') && (p>='0' && p<='9'))) )
	{
		// Integer or floating point constant.
		bool  bIsFloat = 0;
		int32 Length   = 0;
		bool  bIsHex   = 0;
		do
		{
			if( c==TEXT('.') )
			{
				bIsFloat = true;
			}
			if( c==TEXT('X') || c == TEXT('x') )
			{
				bIsHex = true;
			}

			Token.Identifier[Length++] = c;
			if( Length >= NAME_SIZE )
			{
				Length = ((int32)NAME_SIZE) - 1;
				Token.Identifier[Length]=0; // need this for the error description

				FText ErrorDesc = FText::Format(LOCTEXT("IdTooLong", "Identifer ({0}...) exceeds maximum length of {1}"), FText::FromString(Token.Identifier), FText::AsNumber((int32)NAME_SIZE));
				SetError(FErrorState::ParseError, ErrorDesc);

				break;
			}
			c = FChar::ToUpper(GetChar());
		} while ((c >= TEXT('0') && c <= TEXT('9')) || (!bIsFloat && c == TEXT('.')) || (!bIsHex && c == TEXT('X')) || (bIsHex && c >= TEXT('A') && c <= TEXT('F')));

		Token.Identifier[Length]=0;
		if (!bIsFloat || c != 'F')
		{
			UngetChar();
		}

		if (bIsFloat)
		{
			Token.SetConstFloat( FCString::Atof(Token.Identifier) );
		}
		else if (bIsHex)
		{
			TCHAR* End = Token.Identifier + FCString::Strlen(Token.Identifier);
			Token.SetConstInt( FCString::Strtoi(Token.Identifier,&End,0) );
		}
		else
		{
			Token.SetConstInt( FCString::Atoi(Token.Identifier) );
		}
		return IsValid();
	}
	else if( c=='"' )
	{
		// String constant.
		TCHAR Temp[MAX_STRING_CONST_SIZE];
		int32 Length=0;
		c = GetChar(1);
		while( (c!='"') && !IsEOL(c) )
		{
			if( c=='\\' )
			{
				c = GetChar(1);
				if( IsEOL(c) )
				{
					break;
				}
				else if(c == 'n')
				{
					// Newline escape sequence.
					c = '\n';
				}
			}
			Temp[Length++] = c;
			if( Length >= MAX_STRING_CONST_SIZE )
			{
				Length = ((int32)MAX_STRING_CONST_SIZE) - 1;
				Temp[Length]=0; // need this for the error description

				FText ErrorDesc = FText::Format(LOCTEXT("StringConstTooLong", "String constant ({0}...) exceeds maximum of {1} characters"), FText::FromString(Temp), FText::AsNumber((int32)MAX_STRING_CONST_SIZE));
				SetError(FErrorState::ParseError, ErrorDesc);

				c = TEXT('\"');				
				break;
			}
			c = GetChar(1);
		}
		Temp[Length]=0;

		if( c != '"' )
		{
			FText ErrorDesc = FText::Format(LOCTEXT("NoClosingQuote", "Unterminated quoted string ({0})"), FText::FromString(Temp));
			SetError(FErrorState::ParseError, ErrorDesc);

			UngetChar();
		}

		Token.SetConstString(Temp);
		return IsValid();
	}
	else
	{
		// Symbol.
		int32 Length=0;
		Token.Identifier[Length++] = c;

		// Handle special 2-character symbols.
#define PAIR(cc,dd) ((c==cc)&&(d==dd)) /* Comparison macro for convenience */
		TCHAR d = GetChar();
		if
		(	PAIR('<','<')
		||	PAIR('>','>')
		||	PAIR('!','=')
		||	PAIR('<','=')
		||	PAIR('>','=')
		||	PAIR('+','+')
		||	PAIR('-','-')
		||	PAIR('+','=')
		||	PAIR('-','=')
		||	PAIR('*','=')
		||	PAIR('/','=')
		||	PAIR('&','&')
		||	PAIR('|','|')
		||	PAIR('^','^')
		||	PAIR('=','=')
		||	PAIR('*','*')
		||	PAIR('~','=')
		||	PAIR(':',':')
		)
		{
			Token.Identifier[Length++] = d;
			if( c=='>' && d=='>' )
			{
				if( GetChar()=='>' )
					Token.Identifier[Length++] = '>';
				else
					UngetChar();
			}
		}
		else UngetChar();
#undef PAIR

		Token.Identifier[Length] = 0;
		Token.TokenType = FBasicToken::TOKEN_Symbol;

		// Lookup the token's global name.
		Token.TokenName = FName( Token.Identifier, FNAME_Find, true );

		return true;
	}
}
	const Number FloatLiteralParser::Parse()
	{
		// Assert( NotAtEnd() && InClass(CharClass::NUMBER_HEAD) )

		char c = GetChar();

		NumberBuilder numberBuilder;

		if (c == '0')
		{
			Advance();
			if (AtEnd())
			{
				return Number::ZERO();
			}

			switch (GetChar())
			{
				case '.' : return ParseFractional(numberBuilder);
				case 'e' :
				case 'E' : return ParseExponent(numberBuilder);
				case 'b' : return config_.parse_binary ? ParseBinary() : Number::ZERO();
				case 'x' : return config_.parse_hexadecimal ? ParseHexadecimal() : Number::ZERO();
			}

			if (NotInClass(CharClass::DECIMAL))
			{
				return Number::ZERO();
			}

			if (config_.parse_octal)
			{
				return ParseOctal();
			}
		}
		else if (c == '-')
		{
			numberBuilder.SetNegative();
			Advance();
			if (AtEnd() || NotInClass(CharClass::DECIMAL))
			{
				ThrowError("Decimal digit expected");
			}
		}

		// Assert( NotAtEnd() && InClass(CharClass::DECIMAL) )
		do
		{
			numberBuilder.OnIntegerDigit(GetChar() - '0');

			Advance();
			if (AtEnd())
			{
				return numberBuilder.Release();
			}
		}
		while (InClass(CharClass::DECIMAL));

		if (GetChar() == '.')
		{
			return ParseFractional(numberBuilder);
		}
		else if (GetChar() == 'e' || GetChar() == 'E')
		{
			return ParseExponent(numberBuilder);
		}

		return numberBuilder.Release();
	}
Exemple #5
0
void kGUIText::DrawSectionRot(int sstart,int slen,float x,float y,float angle,kGUIColor color,float alpha)
{
	kGUIFace *face=kGUIFont::GetFace(GetFontID());
	int glyph_index;
	int font_height,font_above,font_below;
	FT_Face ftface;
	int size;
	FT_Glyph   glyph2;
	FT_Matrix  matrix;
	FT_BitmapGlyph  bit;
	float dx,dy,adv;
	float advsin,advcos;
	float fax,fay;	/* rotated font above */
	unsigned int ch;	/* current character */
	unsigned int nb;	/* number of bytes for current character */

	ftface=face->GetFace();
	size=GetFontSize();
	if(!size)
		return;
	assert(size>0,"Cannot print size 0\n");

	font_height=face->GetPixHeight(size);
	font_above = face->GetPixAscHeight(size);
	font_below = face->GetPixDescHeight(size);
	kGUI::SelectFont(face,size);

	matrix.xx = (FT_Fixed)( cos( angle ) * 0x10000L );
	matrix.xy = (FT_Fixed)(-sin( angle ) * 0x10000L );
	matrix.yx = (FT_Fixed)( sin( angle ) * 0x10000L );
	matrix.yy = (FT_Fixed)( cos( angle ) * 0x10000L );

	adv=0;
	advsin=sin(angle);
	advcos=cos(angle);
	fax=sin(angle-(2*PI)*0.025f)*font_above;
	fay=-(cos(angle-(2*PI)*0.025f)*font_above);

	/* todo, handle underline */

	while(slen>0)
	{
		ch=GetChar(sstart,&nb);
		if(!ch)
			return;
		sstart+=nb;
		slen-=nb;

		/* todo, handle tabs, handle encoding  */
		glyph_index = FT_Get_Char_Index( ftface, ch );
		if(glyph_index>0)
		{
			FT_Load_Glyph(ftface,glyph_index,FT_LOAD_DEFAULT);
			FT_Get_Glyph( ftface->glyph, &glyph2 );
			FT_Glyph_Transform( glyph2, &matrix, 0 );
			FT_Glyph_To_Bitmap( &glyph2, ft_render_mode_normal,0, 1);
			
			/* draw to screen using writepixel */
			bit = (FT_BitmapGlyph)glyph2;

			dx=x+((advcos*adv)+fax);
			dy=y-((advsin*adv)+fay);
			DrawChar( (char *)bit->bitmap.buffer,
						dx + bit->left,
						dy -bit->top,
						bit->bitmap.width, bit->bitmap.rows,
						color,alpha);

			adv+=ftface->glyph->advance.x/64.0f;
			adv+=m_letterspacing;
			FT_Done_Glyph(glyph2);
		}
	}
	if(m_underline)
		kGUI::DrawLine(x+fax,y-fay,x+((advcos*adv)+fax),y-((advsin*adv)+fay),color,alpha);
}
Exemple #6
0
CFSVar CJSONReader::ReadVal(const CFSAString &szKeyPath)
{
	OnValReadStart(szKeyPath);
	CFSVar Data;

	if (m_cCh=='[') {
		Data.Cast(CFSVar::VAR_ARRAY);
		GetChar(true);
		INTPTR ipPos=0;
		for (;;) {
			if (m_cCh==0) {
				throw CJSONException(FSTSTR("Unexpetcted EOF"));
			} else if (m_cCh==']') {
				GetChar(true);
				break;
			} else if (ipPos>0) {
				if (m_cCh==',') {
					GetChar(true);
				} else {
					throw CJSONException(FSTSTR("Missing ',' in array"));
				}
			}

			CFSAString szKey;
			szKey.Format("%zd", ipPos);
			CFSVar Data1=ReadVal(szKeyPath+"/"+szKey);
			if (m_iCollectData>0) {
				Data[ipPos]=Data1;
			}
			ipPos++;
		}
	} else if (m_cCh=='{') {
		Data.Cast(CFSVar::VAR_MAP);
		GetChar(true);
		INTPTR ipPos=0;
		for (;;) {
			if (m_cCh==0) {
				throw CJSONException(FSTSTR("Unexpetcted EOF"));
			} else if (m_cCh=='}') {
				GetChar(true);
				break;
			} else if (ipPos>0) {
				if (m_cCh==',') {
					GetChar(true);
				} else {
					throw CJSONException(FSTSTR("Missing ',' in map"));
				}
			}

			CFSAString szKey;
			if (m_cCh=='\"' || m_cCh=='\'') {
				szKey=ReadString();
			} else if (FSIsLetter(m_cCh)) {
				szKey=ReadText();
			} else {
				throw CJSONException(FSTSTR("Expected key"));
			}
			if (m_cCh==':') {
				GetChar(true);
			} else {
				throw CJSONException(FSTSTR("Expected ':'"));
			}
			CFSVar Data1=ReadVal(szKeyPath+"/"+szKey);
			if (m_iCollectData>0) {
				Data[szKey]=Data1;
			}
			ipPos++;
		}
	} else if (m_cCh=='\"' || m_cCh=='\'') {
		Data=ReadString();
	} else if ((m_cCh>='0' && m_cCh<='9') || FSStrChr("-+.", m_cCh)) {
		Data=ReadNumber();
	} else if (FSIsLetter(m_cCh)) {
		Data=ReadConst();
	} else if (!m_cCh) {
	} else {
		throw CJSONException(FSTSTR("Unknown value type"));
	}

	OnValReadEnd(szKeyPath, Data);
	return Data;
}
Exemple #7
0
inline CField::operator tchar() const
{
	return GetChar();
}
Exemple #8
0
 void TK_Device2PC(void)
 {
    int count=0,i=0;
	uint16_t len=0;
	uint8_t test;		
	TK_CNANNEL_CONFIG tk_channel_config;
	TK_CNANNEL_CONFIG *tkchconfig;
	len=sizeof(TK_CNANNEL_CONFIG);	
	
	
	//get magic id
	i=0;
	count=0;
 	while(1)
	{	
		if(kbhit())	
		{		
			test=GetChar();
			if(test!=MagicId[i++])
			{										
				return;
			}
			if(i==sizeof(MagicId)) break;
		}
		else
		{			
			count++;			
		}
		if(count > DELAY_TIME_OUT) return;
	} 	
	
	i=0;
	count=0;
	while(i<2)
	{
	 	if(kbhit())	
		{
			((uint8_t *)&reclen)[i]=GetChar();
			i++;
		}


	}

	i=0;
	count=0;
	while(i<reclen)
	{
		 if(kbhit())	
		{
			ReceiveBuf[i]=GetChar();
			i++;
		}

	}

	SendChars(MagicIdR,sizeof(MagicIdR));

	count=0;
	switch(ReceiveBuf[0])
	{
		case OP_AUTO_CHANNEL_CONFIG:
		/*Send : MagicidR | len(16) | "START" | progess (5 time) |len<NEXT> (16) */
			len=5+sizeof(len);
				
			memcpy(SendBuf+count,&len,sizeof(len));
			count+=sizeof(len);
			memcpy(SendBuf+count,(uint8_t *)"START",5);
			count+=5;
			len=sizeof(TK_CNANNEL_CONFIG)+5 /*Used by Progress */;
			memcpy(SendBuf+count,&len,2);
			count+=sizeof(len);
			SendChars((uint8_t *)SendBuf,count);
												
			AutoChannelConfig(ReceiveBuf[1],&final_result);
			
			tk_channel_config.channel=ReceiveBuf[1];					
			tk_channel_config.base=final_result.base;
			tk_channel_config.diff=final_result.diff;
			tk_channel_config.current=final_result.current;
			tk_channel_config.div=final_result.div;	
							
			SendChars((uint8_t *)&tk_channel_config,sizeof(TK_CNANNEL_CONFIG));

		break;
		case OP_GET_CONFIG:				
			len=TK_CH_NUM*sizeof(TK_CNANNEL_CONFIG);			
			memcpy( SendBuf+count,(uint8_t *)&len,sizeof(len));		
		   	count+=sizeof(len);
			
			for(i=0;i<TK_CH_NUM;i++)			
			{			
				tk_channel_config.channel=i;					
				tk_channel_config.base=cfg[i].base;
				tk_channel_config.diff=cfg[i].diff;
				tk_channel_config.current=cfg[i].current;
				tk_channel_config.div=cfg[i].div;		
	
				memcpy(SendBuf+count,(uint8_t *)(&tk_channel_config),sizeof(TK_CNANNEL_CONFIG));
				count+=sizeof(TK_CNANNEL_CONFIG);
			}		
			 SendChars(SendBuf,count);

		break;


		case OP_SET_CHANNEL_CONFIG:
		 			
			tkchconfig=(TK_CNANNEL_CONFIG *)(ReceiveBuf+1);
											
			cfg[tkchconfig->channel].base=tkchconfig->base;
			cfg[tkchconfig->channel].diff=tkchconfig->diff;
			cfg[tkchconfig->channel].current=tkchconfig->current;
			cfg[tkchconfig->channel].div=tkchconfig->div;
			len=3;	
			SendBuf[0]='A';
			SendBuf[1]='C';
			SendBuf[2]='K';	
			SendChars((uint8_t *)&len,sizeof(len));					
			SendChars(SendBuf,3);
						
		break;

		case OP_LISTEN_STATUS:
		/*Recive :   magic_id(64) |  len(16) | OP_LISTEN_STATUS(8) | Channel(16)                          */ 		
		/*Send   :   magic_id(32) |  len(16) | struct LISTEN_STATUS(32) | ... | struct LISTEN_STATUS(32)  */
		 		  RecordCount=0;
				  memcpy((uint8_t *)&RecordChannel,(uint8_t *)(&ReceiveBuf[1]),2);
				  Get_TK_Data(RecordChannel);
				  for(i=0;i<MAX_CHANNEL;i++)
				  {
				  	if(RecordChannel & 0x0001)					
						RecordCount++;				
					RecordChannel=RecordChannel>>1;
				  }
				  len=sizeof(LISTEN_STATUS)*RecordCount;
				  SendChars((uint8_t *)&len,sizeof(len));

				  memcpy((uint8_t *)&RecordChannel,(uint8_t *)(&ReceiveBuf[1]),2);
				  for(i=0;i<MAX_CHANNEL;i++)
				  {
				  	if(RecordChannel & 0x0001)
					{
						Record.channel=i;
						Record.data=data[i];
					    SendChars((uint8_t *)&Record,sizeof(Record));
					}
					RecordChannel=RecordChannel>>1;
				  }				
		break;
		
		default:
		break;
	}
	
	return ;

 }
Exemple #9
0
			bool NotInClass(const CharClass & charClass) const { return !charClass.Contains(GetChar()); }
/*! \brief Extract the data packet from QTouch Studio and set channel config.
 * \note  Should only be called from the command handler.
 */
void Set_Channel_Config(void)
{
	touch_ret_t touch_ret = TOUCH_SUCCESS;

#if ((DEF_TOUCH_QDEBUG_ENABLE_QM == 1)      ||\
	(DEF_TOUCH_QDEBUG_ENABLE_QTA == 1) ||\
	(DEF_TOUCH_QDEBUG_ENABLE_QTB == 1))

	sensor_id_t sensor_id;
	uint8_t type_aks_pos_hyst;

#if (DEF_TOUCH_QDEBUG_ENABLE_QM == 1)
	touch_qm_param_t touch_sensor_param;
#endif

#if ((DEF_TOUCH_QDEBUG_ENABLE_QTA == 1) || (DEF_TOUCH_QDEBUG_ENABLE_QTB == 1))
	touch_qt_param_t touch_sensor_param;
#endif

	sensor_id = GetChar();

	/* Read back and initialize the touch_sensor_param structure.
	 * This is because not all the touch_sensor_param members are
	 * updated by this API. */
	touch_ret
		= QDEBUG_GET_SENSOR_CONFIG_FUNC(sensor_id,
			&touch_sensor_param);
	if (touch_ret != TOUCH_SUCCESS) {
		while (1) {
		}
	}

	/* Update the necessary members of the touch_sensor_param structure
	 * and write back. */
	touch_sensor_param.detect_threshold = GetChar();
	type_aks_pos_hyst = GetChar();
	touch_sensor_param.aks_group
		= (aks_group_t)((uint8_t)((type_aks_pos_hyst & 0x38u) >> 3u));
	touch_sensor_param.detect_hysteresis
		= (hysteresis_t)((uint8_t)(type_aks_pos_hyst & 0x03u));

	touch_ret
		= QDEBUG_UPDATE_SENSOR_CONFIG_FUNC(sensor_id,
			&touch_sensor_param);
	if (touch_ret != TOUCH_SUCCESS) {
		while (1) {
		}
	}

#endif

#if DEF_TOUCH_QDEBUG_ENABLE_AT == 1
	sensor_id_t sensor_id;
	touch_at_param_t touch_sensor_param;

	sensor_id = GetChar();  /* Dummy. To skip sensor_id. */
	UNUSED(sensor_id);  /* Dummy. To avoid warning. */

	/* Read back and initialize the touch_sensor_param structure.
	 * This is because not all the touch_sensor_param members are
	 * updated by this API. */
	touch_ret = QDEBUG_GET_SENSOR_CONFIG_FUNC(&touch_sensor_param);
	if (touch_ret != TOUCH_SUCCESS) {
		while (1) {
		}
	}

	/* Update the necessary members of the touch_sensor_param structure
	 * and write back. */
	touch_sensor_param.sense = GetChar();   /* Sense level (Detect
	                                         *Threshold). */

	touch_ret = QDEBUG_UPDATE_SENSOR_CONFIG_FUNC(&touch_sensor_param);
	if (touch_ret != TOUCH_SUCCESS) {
		while (1) {
		}
	}

#endif
}
Exemple #11
0
void AutoChannelConfig(uint8_t ch,best_cfg* final_result)
{
	uint16_t div, i;
	uint16_t current = 1;
	S_TK_CH_CFG ch_cfg = {1, 0, 0xFFFF, 0x0000};
	uint8_t sen_level, sen_state,tmp_div;
	uint16_t sen_data;	
	int8_t tmp_score;
	uint8_t tmp_cur;
	uint8_t progress=0;

	final_result->current = 1;
	final_result->div = 0;
	final_result->base = 0;
	final_result->diff = 0;

	base_rank[0].val = 0xFFFF;							
	base_rank[0].div = 0;
	base_rank[0].current = 1;
	diff_rank[0].val = 0;
	diff_rank[0].div = 0;
	diff_rank[0].current = 1;
	
			progress=20;
			SendChars((uint8_t *)&progress,sizeof(progress));

			for(div = 1; div < 12; div++) {			
				for(current = 1; current <= 15; current++) {
					ch_cfg.u8Level = current;
					ch_cfg.u8Div = div;
					TK_ConfigChannel(ch, &ch_cfg);		
					result[div][current - 1].level_off = 0;	
					result[div][current - 1].data_off = 0;					
		
					for(i = 0; i < 2; i++) {
						complete = 0;
						TK_Start(1 << ch);
						while(complete != 1);
						TK_ReadStatus(&sen_level, &sen_state, NULL);
						sen_data = TK_ReadData(ch);
						if(sen_state != 0 || sen_data == 0 || sen_data == 0xFFFF) {
							result[div][current - 1].level_off = 0;	
							result[div][current - 1].data_off = 0;
							break;
						} else {
							result[div][current - 1].level_off += sen_level;
							result[div][current - 1].data_off += (sen_data >> 1);						
						}									
					}
					result[div][current - 1].level_off >>= 1;
				}
			}
			
			
			progress=40;
			SendChars((uint8_t *)&progress,sizeof(progress));
	
		 	while(1)
			{	
				if(kbhit())												
					if(GetChar()==progress)															
						break;				
			} 	

			for(div = 1; div < 12; div++) {				
				for(current = 1; current <= 15; current++) {
					ch_cfg.u8Level = current;
					ch_cfg.u8Div = div;
					TK_ConfigChannel(ch, &ch_cfg);
		
					result[div][current - 1].level_on = 0;	
					result[div][current - 1].data_on = 0;					
					if(result[div][current - 1].level_off == 0)
						continue;
					for(i = 0; i < 2; i++) {
						complete = 0;
						TK_Start(1 << ch);
						while(complete != 1);
						TK_ReadStatus(&sen_level, &sen_state, NULL);
						sen_data = TK_ReadData(ch);
						if(sen_state != 0 || sen_data == 0 || sen_data == 0xFFFF) {
							result[div][current - 1].level_on = 0;	
							result[div][current - 1].data_on = 0;
							break;
						} else {
							result[div][current - 1].level_on += sen_level;
							result[div][current - 1].data_on += (sen_data >> 1);
						
						}									
					}
					result[div][current - 1].level_on >>= 1;
				}
			}


			// calculate sense level, timer divider, and change current score
			for(div = 1; div < 12; div++) {
				for(current = 1; current <= 15; current++) {

					result[div][current - 1].score = 0;

					if((result[div][current - 1].level_off != 0) &&
					   (result[div][current - 1].level_on != 0) &&	
					   (result[div][current - 1].data_on > result[div][current - 1].data_off)) {
						
						result[div][current - 1].score += (div_score[div] + cur_score[current] + lvl_score[result[div][current - 1].level_off]);
		
					}
				}
			}	
			
			// find out entry with highest diff
			for(div = 1; div < 12; div++) {
				for(current = 1; current <= 15; current++) {
					if(result[div][current - 1].score != 0) {
						if(((result[div][current - 1].data_on - result[div][current - 1].data_off) > diff_rank[0].val) &&
						   (result[div][current - 1].data_on > result[div][current - 1].data_off) &&
						   ((result[div][current - 1].data_on - result[div][current - 1].data_off) > 0x100)) {
							diff_rank[0].val = (result[div][current - 1].data_on - result[div][current - 1].data_off);
							diff_rank[0].current = current;
							diff_rank[0].div = div;
							break;
						}	
					}
				}
			}				

		   progress=60;
			SendChars((uint8_t *)&progress,sizeof(progress));

			// give score base on the differences
			for(div = 1; div < 12; div++) {
				for(current = 1; current <= 15; current++) {
					if(result[div][current - 1].score > 0) {											
						if(result[div][current - 1].data_on < result[div][current - 1].data_off)
							result[div][current - 1].score -=	100;
						else if((result[div][current - 1].data_on - result[div][current - 1].data_off) < 0x50)
							result[div][current - 1].score -=	100;	
						else
							result[div][current - 1].score += (8 - (diff_rank[0].val - (result[div][current - 1].data_on - result[div][current - 1].data_off)) / 0x800);
					}
				}
			}

			
			// find out lowest base
			for(div = 1; div < 12; div++) {
				for(current = 1; current <= 15; current++) {
					if(result[div][current - 1].score > 0) {
						if((result[div][current - 1].data_off < base_rank[0].val) && (result[div][current - 1].data_off < 0xF000)) {
							base_rank[0].val = result[div][current - 1].data_off;
							base_rank[0].current = current;
							base_rank[0].div = div;
							break;
						}
	
					}
				}
			}

			progress=80;
			SendChars((uint8_t *)&progress,sizeof(progress));

			// give score base on the differences
			for(div = 1; div < 12; div++) {
				for(current = 1; current <= 15; current++) {
					if(result[div][current - 1].score > 0) {											
							result[div][current - 1].score += (4 - (diff_rank[0].val - result[div][current - 1].data_off) / 0x1000);
					}
				}
			}

			// find the entry with highest score
			tmp_score = 0;
			tmp_cur = 1;  // eliminate compilation warning
			tmp_div = 0;						 // eliminate compilation warning
			for(div = 1; div < 12; div++) {
				for(current = 1; current <= 15; current++) {
					if(result[div][current - 1].score > tmp_score) {
						tmp_score = result[div][current - 1].score;
						tmp_div = div;
						tmp_cur = current;
							
					}
				}
			}

		   	progress=100;
			SendChars((uint8_t *)&progress,sizeof(progress));

			if(tmp_score == 0) {
				final_result->base=0;
				final_result->diff=0;
				final_result->current=0;
				final_result->div=0;
			} else {
				final_result->base = result[tmp_div][tmp_cur - 1].data_off;
				final_result->diff = result[tmp_div][tmp_cur - 1].data_on - result[tmp_div][tmp_cur - 1].data_off;
				final_result->current = tmp_cur;
				final_result->div = tmp_div;
			}
}
/*! \brief Extract the data packet from QTouch Studio and set global config.
 * \note  Should only be called from the command handler.
 */
void Set_Global_Config(void)
{
	touch_ret_t touch_ret = TOUCH_SUCCESS;

#if ((DEF_TOUCH_QDEBUG_ENABLE_QM == 1)      ||\
	(DEF_TOUCH_QDEBUG_ENABLE_QTA == 1) ||\
	(DEF_TOUCH_QDEBUG_ENABLE_QTB == 1))

	touch_global_param_t global_params;

	global_params.recal_threshold = (recal_threshold_t)GetChar();
	global_params.di = GetChar();
	global_params.drift_hold_time = GetChar();
	global_params.max_on_duration = GetChar();
	global_params.neg_drift_rate = GetChar();
	global_params.pos_drift_rate = GetChar();
	global_params.pos_recal_delay = GetChar();

	/* update the global parameter value inside the uc3l library */
	touch_ret = QDEBUG_UPDATE_GLOBAL_PARAM_FUNC(&global_params);
	if (touch_ret != TOUCH_SUCCESS) {
		while (1) {
		}
	}

#endif

#if DEF_TOUCH_QDEBUG_ENABLE_AT == 1
	touch_at_param_t touch_sensor_param;
	uint8_t dummy_var;

	/* Fill touch_sensor_param structure with default values.
	 * This is because QTouch Studio does not provide sense and outsense
	 * values.  So these values should not be overwritten by the update API.
	 * */
	touch_ret = QDEBUG_GET_GLOBAL_PARAM_FUNC(&touch_sensor_param);
	if (touch_ret != TOUCH_SUCCESS) {
		while (1) {
		}
	}

	/* Update data from QTouch Studio. */
	touch_sensor_param.pthr = (recal_threshold_t)GetChar();
	touch_sensor_param.filter = GetChar();
	dummy_var = GetChar();  /* Skip drift_hold_time. */
	dummy_var = GetChar();  /* Skip max_on_duration. */
	touch_sensor_param.ndrift = GetChar();
	touch_sensor_param.pdrift = GetChar();

	UNUSED(dummy_var);  /* Dummy. Avoid compiler warning. */

	/* update the global parameter value inside the uc3l library */
	touch_ret = QDEBUG_UPDATE_GLOBAL_PARAM_FUNC(&touch_sensor_param);
	if (touch_ret != TOUCH_SUCCESS) {
		while (1) {
		}
	}

#endif
}
Exemple #13
0
char CUtlBuffer::GetDelimitedChar( CUtlCharConversion *pConv )
{
	if ( !IsText() || !pConv )
		return GetChar( );
	return GetDelimitedCharInternal( pConv );
}
Exemple #14
0
//-----------------------------------------------------------------------------
// Parses the next token, given a set of character breaks to stop at
//-----------------------------------------------------------------------------
int CUtlBuffer::ParseToken( characterset_t *pBreaks, char *pTokenBuf, int nMaxLen, bool bParseComments )
{
	Assert( nMaxLen > 0 );
	pTokenBuf[0] = 0;

	// skip whitespace + comments
	while ( true )
	{
		if ( !IsValid() )
			return -1;
		EatWhiteSpace();
		if ( bParseComments )
		{
			if ( !EatCPPComment() )	
				break;
		}
		else
		{
			break;
		}
	}
	
	char c = GetChar();
	
	// End of buffer
	if ( c == 0 )
		return -1;

	// handle quoted strings specially
	if ( c == '\"' )
	{
		int nLen = 0;
		while( IsValid() )
		{
			c = GetChar();
			if ( c == '\"' || !c )
			{
				pTokenBuf[nLen] = 0;
				return nLen;
			}
			pTokenBuf[nLen] = c;
			if ( ++nLen == nMaxLen )
			{
				pTokenBuf[nLen-1] = 0;
				return nMaxLen;
			}
		}

		// In this case, we hit the end of the buffer before hitting the end qoute
		pTokenBuf[nLen] = 0;
		return nLen;
	}

	// parse single characters
	if ( IN_CHARACTERSET( *pBreaks, c ) )
	{
		pTokenBuf[0] = c;
		pTokenBuf[1] = 0;
		return 1;
	}

	// parse a regular word
	int nLen = 0;
	while ( true )
	{
		pTokenBuf[nLen] = c;
		if ( ++nLen == nMaxLen )
		{
			pTokenBuf[nLen-1] = 0;
			return nMaxLen;
		}
		c = GetChar();
		if ( !IsValid() )
			break;

		if ( IN_CHARACTERSET( *pBreaks, c ) || c == '\"' || c <= ' ' )
		{
			SeekGet( SEEK_CURRENT, -1 );
			break;
		}
	}
	
	pTokenBuf[nLen] = 0;
	return nLen;
}
Exemple #15
0
/*---------------------------------------------------------------------------------------------------------*/
void AutoFlow_FunctionRxTest()
{
    uint32_t u32i;

    printf("\n");
    printf("+-----------------------------------------------------------+\n");
    printf("|     Pin Configure                                         |\n");
    printf("+-----------------------------------------------------------+\n");
    printf("|  ______                                            _____  |\n");
    printf("| |      |                                          |     | |\n");
    printf("| |Master|--UART1_TXD(PB.5)  <==>  UART1_RXD(PB.4)--|Slave| |\n");
    printf("| |      |--UART1_nCTS(PB.7) <==> UART1_nRTS(PB.6)--|     | |\n");
    printf("| |______|                                          |_____| |\n");
    printf("|                                                           |\n");
    printf("+-----------------------------------------------------------+\n");

    printf("\n");
    printf("+-----------------------------------------------------------+\n");
    printf("|       AutoFlow Function Test (Slave)                      |\n");
    printf("+-----------------------------------------------------------+\n");
    printf("|  Description :                                            |\n");
    printf("|    The sample code needs two boards. One is Master and    |\n");
    printf("|    the other is slave. Master will send 1k bytes data     |\n");
    printf("|    to slave.Slave will check if received data is correct  |\n");
    printf("|    after getting 1k bytes data.                           |\n");
    printf("|    Press any key to start...                              |\n");
    printf("+-----------------------------------------------------------+\n");
    GetChar();

    /* Enable RTS and CTS autoflow control */
    UART_EnableFlowCtrl(UART1);

    /* Set RTS Trigger Level as 8 bytes */
    UART1->FCR &= ~UART_FCR_RTS_TRI_LEV_Msk;
    UART1->FCR |= UART_FCR_RTS_TRI_LEV_8BYTES;

    /* Set RX Trigger Level as 8 bytes */
    UART1->FCR &= ~UART_FCR_RFITL_Msk;
    UART1->FCR |= UART_FCR_RFITL_8BYTES;

    /* Set Timeout time 0x3E bit-time and time-out counter enable */
    UART_SetTimeoutCnt(UART1, 0x3E);

    /* Enable RDA\RLS\RTO Interrupt  */
    UART_EnableInt(UART1, (UART_IER_RDA_IEN_Msk | UART_IER_RLS_IEN_Msk | UART_IER_TOUT_IEN_Msk));

    printf("\n Starting to receive data...\n");

    /* Wait for receive 1k bytes data */
    while(g_i32pointer < RXBUFSIZE);

    /* Compare Data */
    for(u32i = 0; u32i < RXBUFSIZE; u32i++) {
        if(g_u8RecData[u32i] != (u32i & 0xFF)) {
            printf("Compare Data Failed\n");
            while(1);
        }
    }
    printf("\n Receive OK & Check OK\n");

    /* Disable RDA\RLS\RTO Interrupt */
    UART_DisableInt(UART1, (UART_IER_RDA_IEN_Msk | UART_IER_RLS_IEN_Msk | UART_IER_TOUT_IEN_Msk));

}
Exemple #16
0
bool wxSimpleHtmlParser::EatWhitespace()
{
    while (!Eof() && IsWhitespace(GetChar(m_pos)))
        m_pos ++;
    return TRUE;
}
Exemple #17
0
int skapmot(void) {
    struct ShortUser *shortUser;
    int mad, setPermission, changed, ch, i, fidoDomainId, highestId;
    struct FidoDomain *fidoDomain;
    BPTR lock;
    struct User user;
    struct Mote tmpConf,*searchConf,*newConf;

    memset(&tmpConf, 0, sizeof(struct Mote));
    if(argument[0] == '\0') {
        SendString("\r\n\nNamn på mötet: ");
        if(GetString(40,NULL)) {
            return 1;
        }
        strcpy(tmpConf.namn, inmat);
    } else {
        strcpy(tmpConf.namn, argument);
    }
    if(parsemot(tmpConf.namn) != -1) {
        SendString("\r\n\nFinns redan ett sådant möte!\r\n");
        return 0;
    }
    tmpConf.skapat_tid = time(NULL);;
    tmpConf.skapat_av = inloggad;
    for(;;) {
        SendString("\r\nMötesAdministratör (MAD) : ");
        if(GetString(5,NULL)) {
            return 1;
        }
        if(inmat[0]) {
            if((mad = parsenamn(inmat)) == -1) {
                SendString("\r\nFinns ingen sådan användare!");
            } else {
                tmpConf.mad = mad;
                break;
            }
        }
    }
    SendString("\n\rSorteringsvärde: ");
    tmpConf.sortpri = GetNumber(0, LONG_MAX, NULL);

    if(EditBitFlagShort("\r\nSka mötet vara slutet?", 'j', 'n', "Slutet", "Öppet",
                        &tmpConf.status, SLUTET)) {
        return 1;
    }
    if(tmpConf.status & SLUTET) {
        SendString("\r\nVilka grupper ska ha tillgång till mötet? (? för lista)\r\n");
        if(editgrupp((char *)&tmpConf.grupper)) {
            return 1;
        }
    }
    if(EditBitFlagShort("\r\nSka mötet vara skrivskyddat?", 'j', 'n',
                        "Skyddat", "Oskyddat", &tmpConf.status, SKRIVSKYDD)) {
        return 1;
    }
    if(EditBitFlagShort("\r\nSka mötet vara kommentarsskyddat?", 'j', 'n',
                        "Skyddat", "Oskyddat", &tmpConf.status, KOMSKYDD)) {
        return 1;
    }
    if(EditBitFlagShort("\r\nSka mötet vara hemligt?", 'j', 'n',
                        "Hemligt", "Ej hemligt", &tmpConf.status, HEMLIGT)) {
        return 1;
    }
    if(!(tmpConf.status & SLUTET)) {
        if(EditBitFlagShort("\r\nSka alla användare bli medlemmar automagiskt?", 'j', 'n',
                            "Ja", "Nej", &tmpConf.status, AUTOMEDLEM)) {
            return 1;
        }
        if(EditBitFlagShort("\r\nSka rättigheterna styra skrivmöjlighet?", 'j', 'n',
                            "Ja", "Nej", &tmpConf.status, SKRIVSTYRT)) {
            return 1;
        }
        if(tmpConf.status & SKRIVSTYRT) {
            SendString("\r\nVilka grupper ska ha tillgång till mötet? (? för lista)\r\n");
            if(editgrupp((char *)&tmpConf.grupper)) {
                return 1;
            }
        }
    }
    if(EditBitFlagShort("\r\nSka mötet enbart kommas åt från ARexx?", 'j', 'n',
                        "Ja", "Nej", &tmpConf.status, SUPERHEMLIGT)) {
        return 1;
    }

    SendString("\n\n\rVilken typ av möte ska det vara?\n\r");
    SendString("1: Lokalt möte\n\r");
    SendString("2: Fido-möte\n\n\r");
    SendString("Val: ");
    for(;;) {
        ch = GetChar();
        if(ch == GETCHAR_LOGOUT) {
            return 1;
        }
        if(ch == '1' || ch == '2') {
            break;
        }
    }
    if(ch == '1') {
        SendString("Lokalt möte\n\n\r");
        tmpConf.type = MOTE_ORGINAL;
    } else {
        SendString("Fido-möte\n\n\r");
        tmpConf.type = MOTE_FIDO;
        if(EditString("Katalog for .msg-filerna", tmpConf.dir, 79, TRUE)) {
            return 1;
        }
        if(!(lock = Lock(tmpConf.dir, SHARED_LOCK))) {
            if(!(lock = CreateDir(tmpConf.dir)))
                SendString("\n\rKunde inte skapa katalogen\n\r");
        }
        if(lock) {
            UnLock(lock);
        }
        if(EditString("FidoNet tag-namn", tmpConf.tagnamn, 49, TRUE)) {
            return 1;
        }
        strcpy(tmpConf.origin, Servermem->fidodata.defaultorigin);
        if(MaybeEditString("Origin-rad", tmpConf.origin, 69)) {
            return 1;
        }

        SendString("\n\n\rVilken teckenuppsättning ska användas för utgående texter?\n\r");
        SendString("1: ISO Latin 1 (ISO 8859-1)\n\r");
        SendString("2: SIS-7 (SF7, 'Måsvingar')\n\r");
        SendString("3: IBM CodePage\n\r");
        SendString("4: Mac\n\n\r");
        SendString("Val: ");
        for(;;) {
            ch = GetChar();
            if(ch == GETCHAR_LOGOUT) {
                return 1;
            }
            if(ch == '1' || ch == '2' || ch == '3' || ch == '4') {
                break;
            }
        }
        switch(ch) {
        case '1':
            SendString("ISO Latin 1\n\n\r");
            tmpConf.charset = CHRS_LATIN1;
            break;
        case '2':
            SendString("SIS-7\n\n\r");
            tmpConf.charset = CHRS_SIS7;
            break;
        case '3':
            SendString("IBM CodePage\n\n\r");
            tmpConf.charset = CHRS_CP437;
            break;
        case '4':
            SendString("Mac\n\n\r");
            tmpConf.charset = CHRS_MAC;
            break;
        }
        SendString("Vilken domän är mötet i?\n\r");
        highestId = 0;
        for(i = 0; i < 10; i++) {
            if(!Servermem->fidodata.fd[i].domain[0]) {
                break;
            }
            highestId = max(highestId, Servermem->fidodata.fd[i].nummer);
            SendString("%3d: %s (%d:%d/%d.%d)\n\r",
                       Servermem->fidodata.fd[i].nummer,
                       Servermem->fidodata.fd[i].domain,
                       Servermem->fidodata.fd[i].zone,
                       Servermem->fidodata.fd[i].net,
                       Servermem->fidodata.fd[i].node,
                       Servermem->fidodata.fd[i].point);
        }
        if(i == 0) {
            SendString("\n\rDu måste definiera en domän i NiKomFido.cfg först!\n\r");
            return 0;
        }
        for(;;) {
            SendString("\r\nDomän: ");
            if(GetString(5, NULL)) {
                return 1;
            }
            fidoDomainId = atoi(inmat);
            if(fidoDomain = getfidodomain(fidoDomainId, 0)) {
                break;
            } else {
                SendString("\n\rFinns ingen sådan domän.\n\r");
            }
        }
        tmpConf.domain = fidoDomain->nummer;
        SendString("%s\n\n\r", fidoDomain->domain);
    }
    for(i = 0; i < MAXMOTE; i++) {
        if(getmotpek(i) == NULL) {
            break;
        }
    }
    if(i >= MAXMOTE) {
        SendString("\n\n\rDet finns inte plats för fler möten.\n\r");
        return 0;
    }
    tmpConf.nummer = i;
    if(!(newConf = (struct Mote *)AllocMem(sizeof(struct Mote),
                                           MEMF_CLEAR | MEMF_PUBLIC))) {
        LogEvent(SYSTEM_LOG, ERROR, "Could not allocate %d bytes.", sizeof(struct Mote));
        DisplayInternalError();
        return 0;
    }
    memcpy(newConf, &tmpConf, sizeof(struct Mote));
    ITER_EL(searchConf, Servermem->mot_list, mot_node, struct Mote *) {
        if(searchConf->sortpri > newConf->sortpri) {
            break;
        }
    }

    searchConf = (struct Mote *)searchConf->mot_node.mln_Pred;
    Insert((struct List *)&Servermem->mot_list, (struct Node *)newConf,
           (struct Node *)searchConf);
    writemeet(newConf);

    if((newConf->status & AUTOMEDLEM) && !(newConf->status & SKRIVSTYRT)) {
        return 0;
    }
    if(newConf->status & SUPERHEMLIGT) {
        return 0;
    }

    setPermission = (newConf->status & (SLUTET | SKRIVSTYRT)) ? FALSE : TRUE;
    for(i = 0; i < MAXNOD; i++) {
        BAMCLEAR(Servermem->inne[i].motmed, newConf->nummer);
        if(setPermission) {
            BAMSET(Servermem->inne[i].motratt, newConf->nummer);
        } else {
            BAMCLEAR(Servermem->inne[i].motratt, newConf->nummer);
        }
    }

    SendString("\r\nÄndrar i användardata..\r\n");
    ITER_EL(shortUser, Servermem->user_list, user_node, struct ShortUser *) {
        if(!(shortUser->nummer % 10)) {
            SendString("\r%d", shortUser->nummer);
        }
        if(readuser(shortUser->nummer, &user)) {
            LogEvent(SYSTEM_LOG, ERROR, "Could not read user %d to set "
                     "membership/permissions for new conference.", shortUser->nummer);
            DisplayInternalError();
            return 0;
        }
        changed = FALSE;
        if(setPermission != BAMTEST(user.motratt, newConf->nummer)) {
            if(setPermission) {
                BAMSET(user.motratt, newConf->nummer);
            } else {
                BAMCLEAR(user.motratt, newConf->nummer);
            }
            changed = TRUE;
        }
        if(!(newConf->status & AUTOMEDLEM) && BAMTEST(user.motmed, newConf->nummer)) {
            BAMCLEAR(user.motmed, newConf->nummer);
            changed = TRUE;
        }
        if(changed && writeuser(shortUser->nummer, &user)) {
            LogEvent(SYSTEM_LOG, ERROR, "Could not write user %d to set "
                     "membership/permissions for new conference.", shortUser->nummer);
            DisplayInternalError();
            return 0;
        }

    }
    for(i = 0; i < MAXNOD; i++) {
        BAMCLEAR(Servermem->inne[i].motmed, newConf->nummer);
        if(setPermission) {
            BAMSET(Servermem->inne[i].motratt, newConf->nummer);
        } else {
            BAMCLEAR(Servermem->inne[i].motratt, newConf->nummer);
        }
    }
    BAMSET(Servermem->inne[nodnr].motratt, newConf->nummer);
    BAMSET(Servermem->inne[nodnr].motmed, newConf->nummer);
    if(newConf->type == MOTE_FIDO) {
        ReScanFidoConf(newConf, 0);
    }
    return 0;
}
Exemple #18
0
bool wxSimpleHtmlParser::EatWhitespace(int& pos)
{
    while (!Eof(pos) && IsWhitespace(GetChar(pos)))
        pos ++;
    return TRUE;
}
Exemple #19
0
void MSA::ToAlnFile(TextFile &File) const
	{
	if (getMuscleContext()->params.g_bClwStrict)
		File.PutString("CLUSTAL W (1.81) multiple sequence alignment\n");
	else
		{
		File.PutString("MUSCLE ("
		  MUSCLE_MAJOR_VERSION "." MUSCLE_MINOR_VERSION ")"
		  " multiple sequence alignment\n");
		File.PutString("\n");
		}

	int iLongestNameLength = 0;
	for (unsigned uSeqIndex = 0; uSeqIndex < GetSeqCount(); ++uSeqIndex)
		{
		const char *ptrName = GetSeqName(uSeqIndex);
		const char *ptrBlank = strchr(ptrName, ' ');
		int iLength;
		if (0 != ptrBlank)
			iLength = (int) (ptrBlank - ptrName);
		else
			iLength = (int) strlen(ptrName);
		if (iLength > iLongestNameLength)
			iLongestNameLength = iLength;
		}
	if (iLongestNameLength > MAX_NAME)
		iLongestNameLength = MAX_NAME;
	if (iLongestNameLength < MIN_NAME)
		iLongestNameLength = MIN_NAME;

	unsigned uLineCount = (GetColCount() - 1)/uCharsPerLine + 1;
	for (unsigned uLineIndex = 0; uLineIndex < uLineCount; ++uLineIndex)
		{
		File.PutString("\n");
		unsigned uStartColIndex = uLineIndex*uCharsPerLine;
		unsigned uEndColIndex = uStartColIndex + uCharsPerLine - 1;
		if (uEndColIndex >= GetColCount())
			uEndColIndex = GetColCount() - 1;
		char Name[MAX_NAME+1];
		for (unsigned uSeqIndex = 0; uSeqIndex < GetSeqCount(); ++uSeqIndex)
			{
			const char *ptrName = GetSeqName(uSeqIndex);
			const char *ptrBlank = strchr(ptrName, ' ');
			int iLength;
			if (0 != ptrBlank)
				iLength = (int) (ptrBlank - ptrName);
			else
				iLength = (int) strlen(ptrName);
			if (iLength > MAX_NAME)
				iLength = MAX_NAME;
			memset(Name, ' ', MAX_NAME);
			memcpy(Name, ptrName, iLength);
			Name[iLongestNameLength] = 0;

			File.PutFormat("%s      ", Name);
			for (unsigned uColIndex = uStartColIndex; uColIndex <= uEndColIndex;
			  ++uColIndex)
				{
				const char c = GetChar(uSeqIndex, uColIndex);
				File.PutFormat("%c", toupper(c));
				}
			File.PutString("\n");
			}

		memset(Name, ' ', MAX_NAME);
		Name[iLongestNameLength] = 0;
		File.PutFormat("%s      ", Name);
		for (unsigned uColIndex = uStartColIndex; uColIndex <= uEndColIndex;
		  ++uColIndex)
			{
			const char c = GetAlnConsensusChar(*this, uColIndex);
			File.PutChar(c);
			}
		File.PutString("\n");
		}
	}
Exemple #20
0
bool wxSimpleHtmlParser::IsString()
{
    return (GetChar(m_pos) == (int) '"') ;
}
Exemple #21
0
inline bool CField::operator!=(tchar cValue) const
{
	return (cValue != GetChar());
}
Exemple #22
0
bool wxSimpleHtmlParser::IsWord()
{
    return (IsAlpha(GetChar(m_pos)));
}
Exemple #23
0
void GetLine( char * buffer, const unsigned int size, int EchoFlag )
{
	char		ch = 0 ;
	int		c;
	char*		p = buffer ;
	unsigned int	n = 0L ;
	int		i ;

	while( n < size )
	{
		c = GetChar() ;
		if( c == -1 )
		{
		    continue;
		}
		ch = c;
		//dprintf("%x ",ch);
		if( ch == KEYCODE_LF )
		{
		    #ifdef USE_LF
		    *--p = 0 ;
		    n-- ;
		    #endif // USE_LF
		    break ;
		}
		else if( ch == KEYCODE_CR )
		{
		    *p = 0 ;
#ifndef CONFIG_HISTORY_KEYIN
		    n-- ;
#else //#ifdef CONFIG_HISTORY_KEYIN
		if(n!=0)
		{
			strcpy(history_cmd[hist_save_idx], buffer);
			(hist_save_idx >= HISTORY_CMD_ELN-1) ? hist_save_idx=0 : hist_save_idx++;
			hist_see_idx=hist_save_idx;
		}

#endif
		    break ;
		}
		else if( ch == KEYCODE_BS_7F )
		{
		    if( p != buffer )
		    {
			    p-- ;
			    n-- ;
							if(EchoFlag)
							{
								PutChar(KEYCODE_BS);
								PutChar(' ');
								PutChar(KEYCODE_BS);
							}
		    }
		}
		else if( ch == KEYCODE_TAB )
		{
		    for( i=0 ; i < TAB ; i++ )
		    {
			    *p++ = ' ' ;
			    n++ ;
							if(EchoFlag) PutChar(' ');
		    }
		}
#ifdef CONFIG_HISTORY_KEYIN
		else if( ch == KEYCODE_ESC )
		{				
			if( GetChar()!= KEYCODE_BRACKET)		continue;
			
			c=GetChar();
			
			unsigned int  vk= ( KEYCODE_ESC <<24) | (KEYCODE_BRACKET<<16) | (c<<8) | 0 ;
			
			if( vk==KEYCODE_VKUP)
			{				
				(hist_see_idx==0) ? hist_see_idx= HISTORY_CMD_ELN-1 : hist_see_idx--;
			}
			else if(vk== KEYCODE_VKDOWN) 
			{
				(hist_see_idx==HISTORY_CMD_ELN-1) ? hist_see_idx= 0 : hist_see_idx++;
					
			}
			else 
				continue;

			//clear
			for(i=0;i<n;i++)
			{
				PutChar(KEYCODE_BS);
				PutChar(' ');
				PutChar(KEYCODE_BS);
			}
			strcpy(buffer, history_cmd[hist_see_idx]);
			n= strlen(buffer);
			p=buffer+n;
			dprintf("%s", buffer);
			
		}
#endif
		else
		{
		    *p++ = ch ;
		    n++ ;
					if(EchoFlag) PutChar(ch);
		}
	}
}
Exemple #24
0
public void DecodeISO2022( state_t *state, byte codingSystem )
{
  int region;
  byte charset, ch, rch;
  byte c[ ICHAR_WIDTH ];

  for( ; ; ){
    GetChar( ch );
    if( ch < SP ){
      if( ESC == ch ){
	if( FALSE == DecodeEscape( state ) )
	  break;
      } else if( HT == ch )
	DecodeAddTab( state->attr );
      else if( SO == ch )	/* LS1 for 8bit */
	state->gset[ GL ] = G1;
      else if( SI == ch )	/* LS0 for 8bit */
	state->gset[ GL ] = G0;
      else if( BS == ch )
	DecodeAddBs();
      else if( EM == ch )
	state->sset = G2;
      else
	DecodeAddControl( ch );
    } else {
      if( '~' == ch && TRUE == hz_detection ){
	switch( STR[ SIDX ] ){
	case '~':
	  if( ASCII == state->cset[ G0 ] )
	    IncStringIndex();
	  break;	/* break for '~' itself.*/
	case '{':
	  if( ASCII == state->cset[ G0 ] ){
	    IncStringIndex();
	    state->cset[ G0 ] = GB2312;
	    continue;
	  }
	  break;
	case '}':
	  if( GB2312 == state->cset[ G0 ] ){
	    IncStringIndex();
	    state->cset[ G0 ] = ASCII;
	    continue;
	  }
	  break;
	}
      }
      rch = ch;
      if( 0 != state->sset ){
	/*
	 * single shifted character
	 */
	if( EUC_TAIWAN == codingSystem && G2 == state->sset ){
	  charset = CNS_1 + ( ch - 0xa1 );
	  if( charset < CNS_1 || charset > CNS_7 ){
	    state->sset = 0;
	    continue;
	  }
	  GetChar( ch );
	} else {
	  charset = SSET;
	}
	state->sset = 0;
	ch &= 0x7f;	/* for EUC */
	if( !IsGraphicChar( charset, ch ) ){
	  if( SP == ch ){
	    DecodeAddSpace( state->attr );
	  } else {
	    DecodeAddControl( rch );
	  }
	  continue;
	}
	c[ 0 ] = ch;
	if( TRUE == iTable[ (int)charset ].multi ){
	  GetChar( ch );
	  if( !IsGraphicChar( charset, ch & 0x7f ) ){
	    DecodeAddControl( rch );
	    DecodeAddControl( ch );
	    continue;
	  }
	  c[ 1 ] = ch & 0x7f;	/* for EUC */
	}
      } else {
	if( 0x80 & ch ){
	  if( SS2 == ch ){
	    state->sset = G2;
	    continue;
	  } else if( SS3 == ch ){
	    state->sset = G3;
	    continue;
	  }
	  region = GR;
	  ch &= 0x7f;
	} else {
	  region = GL;
	}
	charset = CSET( region );
	if( !IsGraphicChar( charset, ch ) ){
	  if( SP == ch ){
	    DecodeAddSpace( state->attr );
	  } else {
	    DecodeAddControl( rch );
	  }
	  continue;
	}
	c[ 0 ] = ch;
	if( TRUE == iTable[ (int)charset ].multi ){
	  GetChar( ch );
	  ch &= 0x7f;
	  if( !IsGraphicChar( charset, ch ) )
	    continue;
	  c[ 1 ] = ch;
	}
      }
      DecodeAddChar( charset, c, state->attr );
    }
  }
}
Exemple #25
0
void CObjectIStreamAsn::ReadAnyContent(string& value)
{
    char buf[128];
    size_t pos=0;
    const size_t maxpos=128;

    char to = GetChar(true);
    buf[pos++] = to;
    if (to == '{') {
        to = '}';
    } else if (to == '\"') {
    } else {
        to = '\0';
    }

    bool space = false;
    for (char c = m_Input.PeekChar(); ; c = m_Input.PeekChar()) {
        if (to != '\"') {
            if (to != '}' && c == '\n') {
                value.append(buf,pos);
                return;
            }
            if (isspace((unsigned char) c)) {
                if (space) {
                    m_Input.SkipChar();
                    continue;
                }
                c = ' ';
                space = true;
            } else {
                space = false;;
            }
            if (to != '}' && (c == ',' || c == '}')) {
                value.append(buf,pos);
                return;
            } else if (c == '\"' || c == '{') {
                value.append(buf,pos);
                ReadAnyContent(value);
                pos = 0;
                continue;
            }
        }
        if (c == to) {
            if (pos >= maxpos) {
                value.append(buf,pos);
                pos = 0;
            }
            buf[pos++] = c;
            value.append(buf,pos);
            m_Input.SkipChar();
            return;
        }
        if (c == '\"' || c == '{') {
            value.append(buf,pos);
            ReadAnyContent(value);
            pos = 0;
            continue;
        }
        if (pos >= maxpos) {
            value.append(buf,pos);
            pos = 0;
        }
        buf[pos++] = c;
        m_Input.SkipChar();
    }
}
char TOpt::GetCharOr0() const {
    if (Chars_.empty())
        return 0;
    return GetChar();
}
Exemple #27
0
const char* TiXmlBase::ReadText(	const char* p, 
									TIXML_STRING * text, 
									bool trimWhiteSpace, 
									const char* endTag, 
									bool caseInsensitive,
									TiXmlEncoding encoding )
{
    *text = "";
	if (    !trimWhiteSpace			// certain tags always keep whitespace
		 || !condenseWhiteSpace )	// if true, whitespace is always kept
	{
		// Keep all the white space.
		while (	   p && *p
				&& !StringEqual( p, endTag, caseInsensitive, encoding )
			  )
		{
			int len;
			char cArr[4] = { 0, 0, 0, 0 };
			p = GetChar( p, cArr, &len, encoding );
			text->append( cArr, len );
		}
	}
	else
	{
		bool whitespace = false;

		// Remove leading white space:
		p = SkipWhiteSpace( p, encoding );
		while (	   p && *p
				&& !StringEqual( p, endTag, caseInsensitive, encoding ) )
		{
			if ( *p == '\r' || *p == '\n' )
			{
				whitespace = true;
				++p;
			}
			else if ( IsWhiteSpace( *p ) )
			{
				whitespace = true;
				++p;
			}
			else
			{
				// If we've found whitespace, add it before the
				// new character. Any whitespace just becomes a space.
				if ( whitespace )
				{
					(*text) += ' ';
					whitespace = false;
				}
				int len;
				char cArr[4] = { 0, 0, 0, 0 };
				p = GetChar( p, cArr, &len, encoding );
				if ( len == 1 )
					(*text) += cArr[0];	// more efficient
				else
					text->append( cArr, len );
			}
		}
	}
	if ( p ) 
		p += strlen( endTag );
	return p;
}
Exemple #28
0
WandExport MagickBooleanType GetScriptToken(ScriptTokenInfo *token_info)
{
  int
    quote,
    c;

  int
    state;

  ssize_t
    offset;

  /* EOF - no more tokens! */
  if (token_info->status != TokenStatusOK)
    {
      token_info->token[0]='\0';
      return(MagickFalse);
    }

  state=IN_WHITE;
  quote='\0';
  offset=0;
  while(1)
  {
    /* get character */
    GetChar(c);

    /* hash comment handling */
    if ( state == IN_COMMENT ) {
      if ( c == '\n' )
        state=IN_WHITE;
      continue;
    }
    /* comment lines start with '#' anywhere, or ':' or '@' at start of line */
    if ( state == IN_WHITE )
      if ( ( c == '#' ) ||
           ( token_info->curr_column==1 && (c == ':' || c == '@' ) ) )
        state=IN_COMMENT;
    /* whitespace token seperator character */
    if (strchr(" \n\r\t",c) != (char *)NULL) {
      switch (state) {
        case IN_TOKEN:
          token_info->token[offset]='\0';
          return(MagickTrue);
        case IN_QUOTE:
          SaveChar(c);
          break;
      }
      continue;
    }
    /* quote character */
    if ( c=='\'' || c =='"' ) {
      switch (state) {
        case IN_WHITE:
          token_info->token_line=token_info->curr_line;
          token_info->token_column=token_info->curr_column;
        case IN_TOKEN:
          state=IN_QUOTE;
          quote=c;
          break;
        case IN_QUOTE:
          if (c == quote)
            {
              state=IN_TOKEN;
              quote='\0';
            }
          else
            SaveChar(c);
          break;
      }
      continue;
    }
    /* escape char (preserve in quotes - unless escaping the same quote) */
    if (c == '\\')
      {
        if ( state==IN_QUOTE && quote == '\'' ) {
            SaveChar('\\');
            continue;
          }
        GetChar(c);
        if (c == '\n')
          switch (state) {
            case IN_COMMENT:
              state=IN_WHITE;  /* end comment */
            case IN_QUOTE:
              if (quote != '"')
                break;         /* in double quotes only */
            case IN_WHITE:
            case IN_TOKEN:
              continue;        /* line continuation - remove line feed */
          }
        switch (state) {
          case IN_WHITE:
            token_info->token_line=token_info->curr_line;
            token_info->token_column=token_info->curr_column;
            state=IN_TOKEN;
            break;
          case IN_QUOTE:
            if (c != quote && c != '\\')
              SaveChar('\\');
            break;
        }
        SaveChar(c);
        continue;
      }
    /* ordinary character */
    switch (state) {
      case IN_WHITE:
        token_info->token_line=token_info->curr_line;
        token_info->token_column=token_info->curr_column;
        state=IN_TOKEN;
      case IN_TOKEN:
      case IN_QUOTE:
        SaveChar(c);
        break;
      case IN_COMMENT:
        break;
    }
  }
  /* input stream has EOF or produced a fatal error */
  token_info->token[offset]='\0';
  if ( token_info->status != TokenStatusOK )
    return(MagickFalse);  /* fatal condition - no valid token */
  token_info->status = TokenStatusEOF;
  if ( state == IN_QUOTE)
    token_info->status = TokenStatusBadQuotes;
  if ( state == IN_TOKEN)
    return(MagickTrue);   /* token with EOF at end - no problem */
  return(MagickFalse);    /* in white space or in quotes - invalid token */
}
//------------------------------------------------------------------------------
TCHAR FBasicTokenParser::GetLeadingChar()
{
	// if the parser is in a bad state, then don't continue parsing (who 
	// knows what will happen!?)... return a char signaling the end-of-stream
	if (!IsValid())
	{
		return 0;
	}

	TCHAR TrailingCommentNewline = 0;
	for (;;)
	{
		bool MultipleNewlines = false;

		TCHAR c;

		// Skip blanks.
		do
		{
			c = GetChar();

			// Check if we've encountered another newline since the last one
			if (c == TrailingCommentNewline)
			{
				MultipleNewlines = true;
			}
		} while (IsWhitespace(c));

		if (c != TEXT('/') || PeekChar() != TEXT('/'))
		{
			return c;
		}

		// Clear the comment if we've encountered newlines since the last comment
		if (MultipleNewlines)
		{
			ClearCachedComment();
		}

		// Record the first slash.  The first iteration of the loop will get the second slash.
		PrevComment += c;

		do
		{
			c = GetChar(true);
			if (c == 0)
				return c;
			PrevComment += c;
		} while (!IsEOL(c));

		TrailingCommentNewline = c;

		for (;;)
		{
			c = GetChar();
			if (c == 0)
				return c;
			if (c == TrailingCommentNewline || !IsEOL(c))
			{
				UngetChar();
				break;
			}

			PrevComment += c;
		}
	}
}
Exemple #30
0
void TextFile::GetCharX(char &c)
	{
	bool bEof = GetChar(c);
	if (bEof)
		Quit("End-of-file in GetCharX");
	}