예제 #1
0
파일: minscanf.c 프로젝트: taras-ko/c
int minscanf(char *fmt, ...)
{
	int c, cnt = 0;
	va_list ap;
	char *p;
	int *intp;
	char inputstr[MAXWORD];
	char d[MAXWORD];
	char *dp, *argsp;
	char *sp = inputstr;

	while ((c = getchar()) != EOF && c != '\n')
		*sp++ = c;
	*sp = '\0';
	sp = inputstr;

	va_start(ap, fmt);
	for (p = fmt; *p; p++) {
		if (*p != '%') {
			continue;
		}
		switch (*++p) {
			case 'd':
				intp = va_arg(ap, int *);
				dp = d;
				while (_isspace(*sp))
					sp++;
				while (_isdigit(*sp))
					*dp++ = *sp++;
				*dp = '\0';
				*intp = _atoi(d);
				cnt++;
				break;
			case 's':
				argsp = va_arg(ap, char *);
				while (_isspace(*sp))
					sp++;
				while (!_isspace(*sp))
					*argsp++ = *sp++;
				*argsp = '\0';
				cnt++;
				break;
			default:
				break;
		}
	}
	va_end(ap);

	return cnt;
}
예제 #2
0
파일: Path.cpp 프로젝트: aapo/numptyphysics
bool
SVGPathTokenizer::next(std::string &output)
{
    if (m_ipos < m_path.length()) {
        // Scan forward to first non-space character
        while (m_ipos < m_path.length() && _isspace(m_path.at(m_ipos))) {
            m_ipos++;
        }

        int start = m_ipos;
        char c = m_path.at(start);
        if (_isctrl(c)) {
            output = m_path.substr(start, 1);
            m_ipos++;
            return true;
        }

        if (_isnumber(c)) {
            while (m_ipos < m_path.length() && _isnumber(m_path.at(m_ipos))) {
                m_ipos++;
            };

            int end = m_ipos;
            output = m_path.substr(start, end-start);
            m_ipos++;
            return true;
        }
    }

    return false;
}
예제 #3
0
파일: utils.c 프로젝트: hckrtst/cs-refresh
int my_htoi(const char * const s) {
    //int neg = 0;
    if (s == NULL) return 0;

    char* cur = (char*)s;
    while(*cur != '\0' && _isspace(*cur)) {
      cur++;
    }

    if (*cur++ == '0' && (*cur == 'x' || *cur == 'X')) {
      cur++;
    } else {
      // backtrack
      cur--;
    }

    int acc = 0;
    while(*cur != '\0' && (_isdigit(*cur) || _isvalidchar(*cur))) {
      acc = acc * 16 + convert(*cur);
      //printf("acc = %x \n", acc);
      ++cur;
    }

    if (*cur != '\0') acc = 0;

    return acc;
}
예제 #4
0
double _atof(
	const char * src
	)
{
	double _integer = 0.0;
	double _minority = 0.0;
	double _set = 1;
	double mark = 1;

	while (_isspace(*src))
		src++;
	
	if (*src == '-')
		mark = -1, src++;
	else if(*src == '+')
		src++;
	
	while (*src && _isnumeric(*src))
		_integer = (_integer * 10) + (*src++ & 0xf);

	if (*src == '.')
		src++;

	while (*src && _isnumeric(*src))
		_minority = (_minority * 10) + (*src++ & 0xf),
		_set *= 0.1;
	
	return mark * (_integer + _minority * _set);
}
예제 #5
0
Boolean XmlParser::_getOpenElementName(
    char*& p,
    const char*& localName,
    Boolean& openCloseElement)
{
    openCloseElement = false;

    if (!_getQName(p, localName))
        throw XmlException(XmlException::BAD_START_TAG, _line);

    // The next character must be a space:

    if (_isspace(*p))
    {
        *p++ = '\0';
        _skipWhitespace(_line, p);
    }

    if (*p == '>')
    {
        *p++ = '\0';
        return true;
    }

    if (p[0] == '/' && p[1] == '>')
    {
        openCloseElement = true;
        *p = '\0';
        p += 2;
        return true;
    }

    return false;
}
예제 #6
0
파일: wrappers.c 프로젝트: emlyn/chdk
int isspace(int c) {
#if !CAM_DRYOS
    return _isspace(c);
#else
    return _ctype(c,_S);
#endif

}
예제 #7
0
unsigned long _strtoul_t(
	const char *nptr, 
	char **endptr, 
	register int base
	)
{
	register const char *s = nptr;
	register unsigned long acc;
	register int c;
	register unsigned long cutoff;
	register int neg = 0, any, cutlim;

	do {
		c = *s++;
	} while (_isspace(c));
	if (c == '-') {
		neg = 1;
		c = *s++;
	} else if (c == '+')
		c = *s++;
	if ((base == 0 || base == 16) &&
	    c == '0' && (*s == 'x' || *s == 'X')) {
		c = s[1];
		s += 2;
		base = 16;
	}
	if (base == 0)
		base = c == '0' ? 8 : 10;

	cutoff = neg ? (~((unsigned long)_LONG_MIN)+1) : _LONG_MAX;
	cutlim = cutoff % (unsigned long)base;
	cutoff /= (unsigned long)base;
	for (acc = 0, any = 0;; c = *s++) {
		if (_isdigit(c))
			c -= '0';
		else if (_isalpha(c))
			c -= _to_upper(c) & 0xf + 10;
		else
			break;
		if (c >= base)
			break;
		if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim))
			any = -1;
		else {
			any = 1;
			acc *= base;
			acc += c;
		}
	}
	if (any < 0) {
		acc = neg ? _LONG_MIN : _LONG_MAX;
	} else if (neg)
		acc = ~acc+1;
	if (endptr != 0)
		*endptr = (char *) (any ? s - 1 : nptr);
	return (acc);
}
예제 #8
0
파일: tag.cpp 프로젝트: jaju/hypar2
    inline int
Tag::getQuotedValue (_char *&pStr, _char **pValue, bool bSetNull)
{
    while ((pStr < m_pStrEnd) && _isspace (*pStr))
    {
        pStr++;
    }
    if (pStr >= m_pStrEnd)
    {
        return -1;
    }
    if ('"' == *pStr || '\'' == *pStr)
    {
        _char wideQuote = *pStr;
        pStr++;
        if (pStr >= m_pStrEnd)
            return -1;
        *pValue = pStr;
        while ((pStr < m_pStrEnd) && *pStr != wideQuote)
        {
            pStr++;
        }
        if (bSetNull)
        {
            *pStr = '\0';
        }
        pStr++;
        return 0;
    }
    else
    {
        *pValue = pStr;
        while ((pStr < m_pStrEnd) && !_isspace (*pStr))
        {
            pStr++;
        }
        if (bSetNull)
        {
            *pStr = '\0';
        }
        pStr++;
        return 0;
    }
}
예제 #9
0
inline void _skipWhitespace(Uint32& line, char*& p)
{
    while (*p && _isspace(*p))
    {
        if (*p == '\n')
            line++;

        p++;
    }
}
예제 #10
0
//*****************************************************************************
// Lex::IsSpaceNextChar - checks is the next character space and skip it if
//                        true; correctly deals with the lines' counter.
// Returns : 1 if space character, 0 otherwise.
//*****************************************************************************
int Lex::IsSpaceNextChar( void )
{
    QChar ch = NextChar();
    if( _isspace( ch ) )
        return 1;
    else
    {
        PutBack();
        return 0;
    }
}
예제 #11
0
static void _findEnds(
    const char* str,
    const char*& first,
    const char*& last)
{
    first = str;

    while (_isspace(*first))
        first++;

    if (!*first)
    {
        last = first;
        return;
    }

    last = first + strlen(first);

    while (last != first && _isspace(last[-1]))
        last--;
}
예제 #12
0
int _ltrim( char *str )
{
	int str_len = strlen( str );
	int cur_len = 0;

	while ( cur_len < str_len )
	{
		if ( _isspace( str[cur_len] ) )
		{
			cur_len++;
			continue;
		}
			
		strcpy( str, &str[cur_len] );
		break;
	}

	return cur_len;
}
예제 #13
0
Boolean XmlParser::_getElementName(char*& p, const char*& localName)
{
    if (!_getQName(p, localName))
        throw XmlException(XmlException::BAD_START_TAG, _line);

    // The next character must be a space:

    if (_isspace(*p))
    {
        *p++ = '\0';
        _skipWhitespace(_line, p);
    }

    if (*p == '>')
    {
        *p++ = '\0';
        return true;
    }

    return false;
}
예제 #14
0
_CODE_ACCESS int atoi(const char *st)
{
    int  result = 0;
    char cp;
    int  sign;

    while (_isspace(*st)) ++st;  /* SKIP WHITE SPACE */

    if (sign = ((cp = *st) == '-')) cp = *++st;
    else if (cp == '+')             cp = *++st;

    while (_isdigit(cp))
    {
        result *= 10;
        result += cp - '0';
        cp = *++st;
    }

    if (sign) result *= -1;
    return result;
}
예제 #15
0
int _rtrim( char *str )
{
	int str_len = 0;
	int cur_len = 0;

	while ( true )
	{
		str_len = strlen( str );

		if ( str_len && _isspace( str[str_len - 1] ) )
		{
			str[str_len - 1] = '\0';
			cur_len++;
		}
		else
		{
			break;
		}
	}

	return cur_len;
}
예제 #16
0
long _atol(
	const char * src
	)
{
#ifndef USING_DEVICE_FLAG_STRINGH
	long int_str = 0;
	long mark = 1;

	while (_isspace(*src))
		src++;

	if (*src == '-')
		mark = -1, src++;
	else if(*src == '+')
		src++;

	while (*src && _isnumeric(*src))
		int_str = (int_str * 10) + (*src++ & 0xf);

	return mark * int_str;
#else
	 return (long) _strtol_t (src, (char **) NULL, 10);
#endif
}
예제 #17
0
static unsigned long _strtoxl_asc(
	const char *nptr,
	char **endptr,
	register int base,
	int flags
	)
{
	register const char *n_ptr = nptr;
	register char c;
	register unsigned long number = 0;
	register unsigned digval;
	register unsigned long maxval;
	
	c = *n_ptr++;

	while (_isspace(*n_ptr))
		c = *n_ptr++;
	
	if (c == '-') {
		flags |= FL_NEG;
		c = *n_ptr++;
	}
	else if(c == '+')
		c = *n_ptr++;

	if(base < 0 || base > 36 || base == 1) {
		if (endptr) 
			*endptr = nptr;
		return 0L;
	} else if(base == 0) {
		if (c != '0')
			base = 10;
		else if (*n_ptr == 'x' || *n_ptr == 'X')
			base = 16;
		else
			base = 8;
	} else if (base == 16) {
		if (c == '0' && (*n_ptr == 'x' || *n_ptr == 'X')) {
			++n_ptr;
			c = *n_ptr++;
		}
	}
	
	maxval = _ULONG_MAX / base;

	for (;;) {
		if (_isdigit((int)(unsigned char)c))
			digval = c - '0';
		else if (_isalpha((int)(unsigned char)c))
			digval = _to_upper(c) & 0xf + 10;
		else
			break;
		if (digval >= (unsigned)base) break;
		flags |= FL_READDIGIT;
		if (number < maxval || (number == maxval 
			&& (unsigned long)digval <= _ULONG_MAX %base)) {

			number = number * base + digval;
		} else {
			flags |= FL_OVERFLOW;
			if (endptr == _NULL)
				break;
		}
		c = *n_ptr++;
	}

	--n_ptr;

	if (!(flags & FL_READDIGIT))
	{
		if (endptr) 
			n_ptr = nptr;
		number = 0L;
	}
	else if ((flags & FL_OVERFLOW) || 
		(!(flags & FL_UNSIGNED) && 
		(((flags & FL_NEG) && (number > -_LONG_MIN)) || 
		(!(flags & FL_NEG) && (number > _LONG_MAX)))))
	{
		if (flags & FL_UNSIGNED)
			number = _ULONG_MAX;
		else if (flags & FL_NEG)
			number = (unsigned long)(-_LONG_MIN);
		else
			number = _LONG_MAX;
	}

	if (endptr != _NULL) 
		*endptr = n_ptr;

	if (flags & FL_NEG) 
		number = (unsigned long)(-(long)number);

	return number;
}
예제 #18
0
void XmlParser::_getElement(char*& p, XmlEntry& entry)
{
    //--------------------------------------------------------------------------
    // Get the element name (expect one of these: '?', '!', [A-Za-z_])
    //--------------------------------------------------------------------------

    if (*p == '?')
    {
        entry.type = XmlEntry::XML_DECLARATION;
        entry.text = ++p;

        if (_getElementName(p, entry.localName))
            return;
    }
    else if (*p == '!')
    {
        p++;

        // Expect a comment or CDATA:

        if (p[0] == '-' && p[1] == '-')
        {
            p += 2;
            entry.type = XmlEntry::COMMENT;
            entry.text = p;
            _getComment(p);
            return;
        }
        else if (memcmp(p, "[CDATA[", 7) == 0)
        {
            p += 7;
            entry.type = XmlEntry::CDATA;
            entry.text = p;
            _getCData(p);
            entry.textLen = strlen(entry.text);
            return;
        }
        else if (memcmp(p, "DOCTYPE", 7) == 0)
        {
            entry.type = XmlEntry::DOCTYPE;
            entry.text = "";
            _getDocType(p);
            return;
        }
        throw(XmlException(XmlException::EXPECTED_COMMENT_OR_CDATA, _line));
    }
    else if (*p == '/')
    {
        entry.type = XmlEntry::END_TAG;
        entry.text = ++p;

        if (!_getElementName(p, entry.localName))
            throw(XmlException(XmlException::BAD_END_TAG, _line));

        return;
    }
    else if (CharSet::isAlphaUnder(Uint8(*p)))
    {
        entry.type = XmlEntry::START_TAG;
        entry.text = p;

        Boolean openCloseElement = false;

        if (_getOpenElementName(p, entry.localName, openCloseElement))
        {
            if (openCloseElement)
                entry.type = XmlEntry::EMPTY_TAG;
            return;
        }
    }
    else
        throw XmlException(XmlException::BAD_START_TAG, _line);

    //--------------------------------------------------------------------------
    // Grab all the attributes:
    //--------------------------------------------------------------------------

    for (;;)
    {
        if (entry.type == XmlEntry::XML_DECLARATION)
        {
            if (p[0] == '?' && p[1] == '>')
            {
                p += 2;
                return;
            }
        }
        else if (entry.type == XmlEntry::START_TAG && p[0] == '/' && p[1] =='>')
        {
            entry.type = XmlEntry::EMPTY_TAG;
            p += 2;
            return;
        }
        else if (*p == '>')
        {
            p++;
            return;
        }

        XmlAttribute attr;
        attr.nsType = -1;
        attr.name = p;
        _getAttributeNameAndEqual(p, attr.localName);

        // Get the attribute value (e.g., "some value")
        {
            if ((*p != '"') && (*p != '\''))
            {
                throw XmlException(XmlException::BAD_ATTRIBUTE_VALUE, _line);
            }

            char quote = *p++;

            char* start;
            _normalizeAttributeValue(_line, p, quote, start);
            attr.value = start;

            if (*p != quote)
            {
                throw XmlException(XmlException::BAD_ATTRIBUTE_VALUE, _line);
            }

            // Overwrite the closing quote with a null-terminator:

            *p++ = '\0';
        }

        if (entry.type == XmlEntry::XML_DECLARATION)
        {
            // The next thing must a space or a "?>":

            if (!(p[0] == '?' && p[1] == '>') && !_isspace(*p))
            {
                throw XmlException(
                    XmlException::BAD_ATTRIBUTE_VALUE, _line);
            }
        }
        else if (!(*p == '>' || (p[0] == '/' && p[1] == '>') || _isspace(*p)))
        {
            // The next thing must be a space or a '>':

            throw XmlException(XmlException::BAD_ATTRIBUTE_VALUE, _line);
        }

        _skipWhitespace(_line, p);

        entry.attributes.append(attr);
    }
}
예제 #19
0
int _isnspace(
	int ch
	)
{
	return !_isspace(ch);
}
CFormulaNode* CLineNode::InsertMMLFormulaNode_MFENCED( AST_TXML_Tag *node )
{
	AST_TXML_Attribute *_attr;
	QString attr_open, attr_close, b_attr_separator, attr_separator = _T("");
	long i;

	//=== 'open', 'close' and 'separator' attributes (or their defaults)
	_attr = node->getAttribute( FBL_ATTR_open );
	attr_open = ::formatBlankAsXML( _attr  ? _attr->getStringValue() : FBL_VAL_DEFAULT_mfenced_open  );
	_attr = node->getAttribute( FBL_ATTR_close );
	attr_close = ::formatBlankAsXML( _attr ? _attr->getStringValue() : FBL_VAL_DEFAULT_mfenced_close );
	_attr = node->getAttribute( FBL_ATTR_separators );

	if( node->getTags() && 
		node->getTags()->getChildNumber() == 1 &&
		node->getTags()->getChild( 0 ) &&
		node->getTags()->getChild( 0 )->getNodeType() == ASTT_TXML_Tag )
	{
		QString fid = _T("");
		if( ::isXMLSymbol__BracketL( attr_open ) && 
			::isXMLSymbol__BracketR( attr_close ) )
			fid = HF_BTNID_DEFAULT_BRACKET_LR;
		else if( ::isXMLSymbol__BracketLB( attr_open ) && 
				 ::isXMLSymbol__BracketRB( attr_close ) )
			fid = HF_BTNID_DEFAULT_BRACKET_LRB;
		else if( ::isXMLSymbol__BracketLF( attr_open ) && 
				 ::isXMLSymbol__BracketRF( attr_close ) )
			fid = HF_BTNID_DEFAULT_BRACKET_LRF;
		else if( ::isXMLSymbol__BracketLA( attr_open ) && 
				 ::isXMLSymbol__BracketRA( attr_close ) )
			fid = HF_BTNID_DEFAULT_BRACKET_LRA;
		else if( ::isXMLSymbol__BracketVerBar( attr_open ) && 
				 ::isXMLSymbol__BracketVerBar( attr_close ) )
			fid = HF_BTNID_DEFAULT_BRACKET_ABS;
		else if( ::isXMLSymbol__BracketDblVerBar( attr_open ) && 
				 ::isXMLSymbol__BracketDblVerBar( attr_close ) )
			fid = HF_BTNID_DEFAULT_BRACKET_NORM;
		else if( ::isXMLSymbol__BracketLFloor( attr_open ) && 
				 ::isXMLSymbol__BracketRFloor( attr_close ) )
			fid = HF_BTNID_DEFAULT_BRACKET_FLOOR;
		else if( ::isXMLSymbol__BracketLCeil( attr_open ) && 
				 ::isXMLSymbol__BracketRCeil( attr_close ) )
			fid = HF_BTNID_DEFAULT_BRACKET_CEIL;
		else if( attr_close.length() == 0 )
		{
			if( ::isXMLSymbol__BracketL( attr_open ) )
				fid = HF_BTNID_DEFAULT_BRACKET_L;
			else if( ::isXMLSymbol__BracketLB( attr_open ) )
				fid = HF_BTNID_DEFAULT_BRACKET_LB;
			else if( ::isXMLSymbol__BracketLF( attr_open ) )
				fid = HF_BTNID_DEFAULT_BRACKET_LF;
			else if( ::isXMLSymbol__BracketLA( attr_open ) )
				fid = HF_BTNID_DEFAULT_BRACKET_LA;
			else if( ::isXMLSymbol__BracketVerBar( attr_open ) )
				fid = HF_BTNID_DEFAULT_BRACKET_ABS_L;
			else if( ::isXMLSymbol__BracketDblVerBar( attr_open ) )
				fid = HF_BTNID_DEFAULT_BRACKET_NORM_L;
		}
		else  if( attr_open.length() == 0 )
		{
			if( ::isXMLSymbol__BracketR( attr_close ) )
				fid = HF_BTNID_DEFAULT_BRACKET_R;
			else if( ::isXMLSymbol__BracketRB( attr_close ) )
				fid = HF_BTNID_DEFAULT_BRACKET_RB;
			else if( ::isXMLSymbol__BracketRF( attr_close ) )
				fid = HF_BTNID_DEFAULT_BRACKET_RF;
			else if( ::isXMLSymbol__BracketRA( attr_close ) )
				fid = HF_BTNID_DEFAULT_BRACKET_RA;
			else if( ::isXMLSymbol__BracketVerBar( attr_close ) )
				fid = HF_BTNID_DEFAULT_BRACKET_ABS_R;
			else if( ::isXMLSymbol__BracketDblVerBar( attr_close ) )
				fid = HF_BTNID_DEFAULT_BRACKET_NORM_R;
		}

		CFormulaNode *r;
		if( fid.length() &&
			(r = InsertMMLFormulaNode_OTHERS_byID( fid, node )) != 0 )
			return r;
	}

	b_attr_separator = _attr ? _attr->getStringValue() : FBL_VAL_DEFAULT_mfenced_separator;
	for( i = 0; i < (long) b_attr_separator.length(); i++ )
		if( !_isspace( b_attr_separator.at(i) ) )
			attr_separator += b_attr_separator.at(i);

	AST_TXML_Compound *_tags = new AST_TXML_Compound();

	AST_TXML_Compound *_a;
	AST_TXML_Value *_v;
	AST_TXML_Compound *_innner_tags = new AST_TXML_Compound();
	AST_TXML_Tag *node_inner_mrow;

	_a = new AST_TXML_Compound();
	_a->Add( new AST_TXML_Attribute( &fenceV, &trueV ) );
	QString sV( attr_open ), s2V( attr_close );
	_v = new AST_TXML_Value( &sV );
	_tags->Add( new AST_TXML_Tag( &moV, _a, _v ) );
	_tags->Add( node_inner_mrow = new AST_TXML_Tag( &mrowV, 0, _innner_tags ) );
	_a = new AST_TXML_Compound();
	_a->Add( new AST_TXML_Attribute( &fenceV, &trueV ) );
	_v = new AST_TXML_Value( &s2V );
	_tags->Add( new AST_TXML_Tag( &moV, _a, _v ) );
	
	std::vector<long> loan;
	if( node->getTags() && node->getTags()->getChildNumber() )
	{
		if( attr_separator.length() && 
			((long) attr_separator.length()) < node->getTags()->getChildNumber() - 1 )
			attr_separator.append( QString( node->getTags()->getChildNumber() - 1 - attr_separator.length(), attr_separator.at(attr_separator.length() - 1) ) );
		for( i = 0; i < node->getTags()->getChildNumber() - 1; i++ )
		{
			loan.push_back( _innner_tags->Add( node->getTags()->getChild( i ) ) );
			if( i < (long) attr_separator.length() )
			{
				_a = new AST_TXML_Compound();
				_a->Add( new AST_TXML_Attribute( &separatorV, &trueV ) );
				QString s3V(1, attr_separator.at(i));
				_v = new AST_TXML_Value( &s3V );
				_innner_tags->Add( new AST_TXML_Tag( &moV, _a, _v ) );
			}
		}
		loan.push_back( _innner_tags->Add( node->getTags()->getChild( i ) ) );
	}

	AST_TXML_Tag *node_mrow = new AST_TXML_Tag( &mrowV, 0, _tags );
	node_mrow->mode.setFlag(OLIMP_MATHML_FLAG__MROW_KEEP1CHILD);
	CFormulaNode *_node = InsertMMLFormulaNode( node_mrow );

	for( i = 0; i < (long) loan.size(); i++ )
		_innner_tags->ReplaceChild( loan[ i ], 0 );
	delete node_mrow;

	return _node;
}
예제 #21
0
_CODE_ACCESS long double strtold(const char *st, char **endptr)
{
    long double      result = 0.0L;
    char        cp;
    const char *fst    = st;
    int         exp    = 0;               /* EXPONENT              */
    int         count;                    /* EXPONENT CALCULATION  */
    int         value  = 0;               /* SUCCESSFUL PARSE      */
    int         sign;
    int         plus_or_minus = 0;        /* READ IN EXPONENT SIGN (+/-) */

    while (_isspace(*fst)) ++fst;  /* SKIP WHITE SPACE */
    if ((sign = ((cp = *fst) == '-')) || (cp == '+')) { ++fst; value = 1; }

    /*----------------------------------------------------------------------*/
    /* READ IN FRACTIONAL PART OF NUMBER, UNTIL AN 'E' IS REACHED.          */
    /* COUNT DIGITS AFTER DECIMAL POINT.                                    */
    /*----------------------------------------------------------------------*/
    for (; _isdigit(cp = *fst); ++fst) 
    {
       result = result * 10 + digits[cp - '0']; 
       value  = 1;
    }

    if (cp == '.') {
       while (_isdigit(cp = *++fst)) 
       {
          result = result * 10 + digits[cp - '0']; 
          value  = 1;
	  --exp;
       }
    }

    if (sign) result = -result;  /* IF NEGATIVE NUMBER, REVERSE SIGN */

    /*----------------------------------------------------------------------*/
    /* READ IN EXPLICIT EXPONENT AND CALCULATE REAL EXPONENT.               */
    /* IF EXPONENT IS BOGUS (i.e. "1.234empty" or "1.234e+mpty") RESTORE    */
    /* BOGUS EXPONENT BACK ONTO RETURNED STRING (endptr).                   */
    /*----------------------------------------------------------------------*/
    if (value && _toupper(*fst) == 'E')
    {
       if ((sign = ((cp = *++fst) == '-')) || (cp == '+'))
       {
          cp = *++fst;
          plus_or_minus = 1;
       }
 
       if (!_isdigit(cp))
       {
          if (plus_or_minus) *--fst;
          *--fst;
          goto skip_loop;
       }

       for (count = 0; _isdigit(cp); cp = *++fst)
       {
	  if ((INT_MAX - abs(exp) - (cp - '0')) / 10 > count)
          {
             count *= 10; 
	     count += cp - '0';
	  } else
	  {
	    count = INT_MAX - exp;
	    break;
	  }
       }

skip_loop:

       if (sign) exp -= count;
       else      exp += count;
    }

    /*----------------------------------------------------------------------*/
    /* ADJUST NUMBER BY POWERS OF TEN SPECIFIED BY FORMAT AND EXPONENT.     */
    /*----------------------------------------------------------------------*/
    if (result != 0.0)
    {
       if (exp > LDBL_MAX_10_EXP) 
	  { errno = ERANGE; result = (result < 0) ? -HUGE_VALL : HUGE_VALL; }
       else if (exp < LDBL_MIN_10_EXP) 
	  { errno = ERANGE; result = 0.0; }
       else if (exp < 0) {
	    for (count = 0, exp = -exp; exp; count++, exp >>= 1)
	        { if (exp & 1) result /= powerof10[count]; }
       }
       else {
	    for (count = 0; exp; count++, exp >>= 1)
	        { if (exp & 1) result *= powerof10[count]; }
       }
    }
예제 #22
0
파일: shell_lib.c 프로젝트: KHATEEBNSIT/AP
/*call by main*/
int
next_cmd(char *out_cmd)
{
    unsigned char c = 0;
    int key_no = 0;
    int seq_char = 0;
    int str_valid = 0;

    /*set terminal new attrib */
    term_config();

    /*termial initial */
    term_init(out_cmd);

    /*main loop */
    while ((c = getc(stdin)) != '\n') {
        key_no = 0;
        seq_char = 0;

        if (!_isspace(c)) {
            str_valid = 1;
        }

        if (c == 27) {          /*escape sequence */
            if ((c = getc(stdin)) == '[' || c == 'O') {
                c = getc(stdin);
                seq_char = 1;
            }
        }

        /*search for bind key handle function */
        while (key_no < sizeof (key_bind) / sizeof (key_bind[0])) {
            if ((seq_char == key_bind[key_no].is_eseq)
                && (c == key_bind[key_no].key_last)) {
                key_bind[key_no].func();
                break;
            }
            key_no++;
        }

        if (key_no == sizeof (key_bind) / sizeof (key_bind[0]))
            handle_normal(out_cmd, c);

    }

    /*handle enter when at the end of a line */
    if (term_cursor)
        putchar('\n');

    /* record command history without '\n' */
    history_record(out_cmd);
#if 0
    /* add '\n' to  out_cmd */
    if (str_valid) {
        out_cmd[cmd_strlen++] = '\n';
    } else {
        cmd_strlen = 0;
        out_cmd[cmd_strlen++] = '\n';
    }

    if (cmd_strlen > 1 && out_cmd[cmd_strlen - 1] == '\n')
        out_cmd[cmd_strlen - 1] = 0;
#else
    if (!str_valid)
        cmd_strlen = 0;
#endif
    /*retore terminal to orginal status */
    term_restore();

    fflush(stdout);

    return cmd_strlen;
}
예제 #23
0
_CODE_ACCESS unsigned long strtoul(const char *st, char **endptr, int base)
{
    register unsigned long result = 0;
    register char          cp;
    register const char   *fst = st;
    int                    digits = 0;
    int                    minus = 0;

    while (_isspace(*fst)) ++fst;  /* SKIP WHITE SPACE */
    if (base > 36) base = 0;  

    if ((cp = *fst) == '+') cp = *++fst;
    else if ((cp = *fst) == '-') { cp = *++fst; minus = 1; }

    /*-------------------------------------------------------------------*/
    /* DETERMINE BASE IF ZERO BASE ASKED FOR.                            */
    /*-------------------------------------------------------------------*/
    switch (base)
    {
	case  0 : if      (cp != '0')           base = 10;
		  else if ((cp = *++fst) == 'x' || cp == 'X')
		     if   (_isxdigit(fst[1])) { base = 16; cp = *++fst; }
		     else                     { base = 10; cp = *--fst; }
		  else 
		  {
		     base = 8; 
		     if (cp < '0' || cp > '7')  cp = *--fst;
		  }
	          break;

        case 16 : if (cp == '0' && ((fst[1] == 'x') || (fst[1] == 'X')) &&
		      _isxdigit(fst[2]))
	             cp = *(fst += 2);
    }

    /*-------------------------------------------------------------------*/
    /* CONVERT THE NUMBER USING THE SPECIFIED BASE.                      */
    /*-------------------------------------------------------------------*/
    for (;; cp = *++fst)
    {
	register unsigned long addval;

	if (!((_isdigit(cp) && (addval = cp - '0')      < base) ||
	      (_isupper(cp) && (addval = cp - 'A' + 10) < base) ||
	      (_islower(cp) && (addval = cp - 'a' + 10) < base)))  break;

        if (result == (addval = (result * base + addval))/base) result = addval;
	else 
	{   
	    errno = ERANGE;
	    if (endptr) *endptr = (char *)st;        
	    return ULONG_MAX; 
	}

	digits++;
    }

    /*-------------------------------------------------------------------*/
    /* MARK THE END OF THE CONVERTED INPUT.                              */
    /*-------------------------------------------------------------------*/
    if (endptr) *endptr = (char *)(digits ? fst : st);

    return minus ? -result : result;
}
예제 #24
0
파일: system.c 프로젝트: Agochka/klibc
int isspace(int c) {
	return _isspace(c);
}
예제 #25
0
파일: tag.cpp 프로젝트: jaju/hypar2
    int
Tag::parseTag (_char *pTagString, bool bParseAttributes)
{
    _char *pTmpStr = pTagString;

    while ((pTmpStr < m_pStrEnd) && _isspace (*pTmpStr))
    {
        pTmpStr++;
    }

    if (*pTmpStr == SLASH)
    {
        m_bEndTag = true;
        pTmpStr++;
    }

    while ((pTmpStr < m_pStrEnd) && _isspace (*pTmpStr))
    {
        pTmpStr++;
    }

    m_pName = pTmpStr;

    while ((pTmpStr < m_pStrEnd) && !_isspace(*pTmpStr))
    {
        if (*pTmpStr == SLASH)
        {
            m_bSelfClosing = true;
            *pTmpStr = NULLCHAR;
        }
        else
        {
            *pTmpStr = _tolower (*pTmpStr);
        }
        pTmpStr++;
    }

    if (pTmpStr < m_pStrEnd)
    {
        *pTmpStr = NULLCHAR;
        pTmpStr++;
    }

    while ((pTmpStr < m_pStrEnd) && _isspace (*pTmpStr))
    {
        pTmpStr++;
    }
    if ((pTmpStr < m_pStrEnd))
    {
        _char *pSelfClosing = pTmpStr;
        while ((pSelfClosing + 1) < m_pStrEnd)
        {
            pSelfClosing++;
        }
        while (_isspace (*pSelfClosing))
        {
            pSelfClosing--;
        }
        if (SLASH == *pSelfClosing)
        {
            m_bSelfClosing = true;
            *pSelfClosing = NULLCHAR;
        }
        m_pTagAttrString = pTmpStr;
        if (bParseAttributes)
        {
            parseAttributes (pTmpStr);
        }
    }
    return 0;
}
예제 #26
0
static inline void _normalizeElementValue(
    Uint32& line,
    char*& p,
    Uint32 &textLen)
{
    // Process one character at a time:

    char* q = p;
    char *start = p;

    while (*p && (*p != '<'))
    {
        if (_isspace(*p))
        {
            // Trim whitespace from the end of the value, but do not compress
            // whitespace within the value.

            const char* start = p;

            if (*p++ == '\n')
            {
                line++;
            }

            _skipWhitespace(line, p);

            if (*p && (*p != '<'))
            {
                // Transfer internal whitespace to q without compressing it.
                const char* i = start;
                while (i < p)
                {
                    *q++ = *i++;
                }
            }
            else
            {
                // Do not transfer trailing whitespace to q.
                break;
            }
        }
        else if (*p == '&')
        {
            // Process an entity reference or a character reference.

            *q++ = _getRef(line, ++p);
        }
        else
        {
            *q++ = *p++;
        }
    }

    // If q got behind p, it is safe and necessary to null-terminate q

    if (q != p)
    {
        *q = '\0';
    }
    textLen = (Uint32)(q - start);
}
예제 #27
0
static inline void _normalizeAttributeValue(
    Uint32& line,
    char*& p,
    char end_char,
    char*& start)
{
    // Skip over leading whitespace:

    _skipWhitespace(line, p);
    start = p;

    // Process one character at a time:

    char* q = p;

    while (*p && (*p != end_char))
    {
        if (_isspace(*p))
        {
            // Compress sequences of whitespace characters to a single space
            // character. Update line number when newlines encountered.

            if (*p++ == '\n')
            {
                line++;
            }

            *q++ = ' ';

            _skipWhitespace(line, p);
        }
        else if (*p == '&')
        {
            // Process an entity reference or a character reference.

            *q++ = _getRef(line, ++p);
        }
        else
        {
            *q++ = *p++;
        }
    }

    // Remove single trailing whitespace (consecutive whitespaces already
    // compressed above).  Since p >= q, we can tell if we need to strip a
    // trailing space from q by looking at the end of p.  We must not look at
    // the last character of p, though, if p is an empty string.
    Boolean adjust_q = (p != start) && _isspace(p[-1]);

    // We encountered a the end_char or a zero-terminator.

    *q = *p;

    if (adjust_q)
    {
        q--;
    }

    // If q got behind p, it is safe and necessary to null-terminate q

    if (q != p)
    {
        *q = '\0';
    }
}
예제 #28
0
_CODE_ACCESS int isspace(int c)
{
    return(_isspace(c));
}
예제 #29
0
char *_costume_get_string(const pcostumestrx cxstrlist, const pcostumex cxlist, const CHAR *target, const CHAR *format)
{
	char *ret = (char *) malloc (sizeof(char) * 1024);
	char *ptr = ret, *tmpptr, *tarptr;
	char tmp;
	char _temp[20] = {0,}; // find temp
	u32 inttmp;
	int count;
	pcostumex costmp;
	pcostumestrx cosstrtmp;
	BOOL not;

#define CONDITION(x) ((x) && not) || (!(x) && !not)
	tarptr = target;
	_costume_ict = format;
	zeroset(ret, sizeof(char) * 1024);
	
	do {
		switch(*_costume_ict++)
		{
		case '+': // add variable to ret
			switch(*_costume_ict++) {
			case _COTM_VARIABLE:
				for (count = 0; _isalnumub((int)(*_costume_ict)); _costume_ict++, count++)
					_temp[count] = *_costume_ict;
				_temp[count] = 0;
				
				if (NULL == (costmp = _costume_find_variable(cxlist, _temp)))
					return -1; // error
				inttmp = costmp->data;

				tmpptr = __itoa(inttmp);
				for (; *tmpptr; tmpptr++)
					*ptr++ = *tmpptr;

				break;

			case _COTM_STRVARIABLE:
				for (count = 0; _isalnumub((int)(*_costume_ict)); _costume_ict++, count++)
					_temp[count] = *_costume_ict;
				_temp[count] = 0;
				
				if (NULL == (cosstrtmp = _costume_find_strvariable(cxstrlist, _temp)))
					return -1; // error

				tmpptr = cosstrtmp->data;
				for (; *tmpptr; tmpptr++)
					*ptr++ = *tmpptr;

				break;

			case '*': // *x, *@int, *$str, *!x
			RE1:
				switch(*_costume_ict++) {
				case '!':
					switch(*_costume_ict++) {
					case 's': while (CONDITION(_isspace(*tarptr))) *ptr++ = *tarptr++; break;
					case 'S': while (CONDITION(!_isspace(*tarptr))) *ptr++ = *tarptr++; break;
					case 'd': while (CONDITION(_isnumeric(*tarptr))) *ptr++ = *tarptr++; break;
					case 'D': while (CONDITION(!_isnumeric(*tarptr))) *ptr++ = *tarptr++; break;
					case 'w': while (CONDITION(_isalnumub(*tarptr))) *ptr++ = *tarptr++; break;
					case 'W': while (CONDITION(!_isalnumub(*tarptr))) *ptr++ = *tarptr++; break;
					case '\\':
						switch(*_costume_ict++)
						{
						case 'n': while (CONDITION(*tarptr == '\n')) *ptr++ = *tarptr++; break;
						case 'r': while (CONDITION(*tarptr == '\r')) *ptr++ = *tarptr++; break;
						case 't': while (CONDITION(*tarptr == '\t')) *ptr++ = *tarptr++; break;
						case 'f': while (CONDITION(*tarptr == '\f')) *ptr++ = *tarptr++; break;
						default: while(CONDITION(*tarptr == *(_costume_ict-1))) *ptr++ = *tarptr++; break;
						}
						break;

					}
					not = TRUE;
					break;

				case '\\':
					switch(*_costume_ict++)
					{
					case 'n': if(CONDITION(*tarptr == '\n')) *ptr++ = *tarptr++; break;
					case 'r': if(CONDITION(*tarptr == '\r')) *ptr++ = *tarptr++; break;
					case 't': if(CONDITION(*tarptr == '\t')) *ptr++ = *tarptr++; break;
					case 'f': if(CONDITION(*tarptr == '\f')) *ptr++ = *tarptr++; break;
					default: if(CONDITION(*tarptr == *(_costume_ict-1))) *ptr++ = *tarptr++; break;
					}
					not = TRUE;
					break;

				case '^': // not
					not = FALSE;
					goto RE1;
					break;

				default:
					if(_isalnumub((int)(*_costume_ict))) {
						if(CONDITION(*tarptr == *_costume_ict)) 
							*ptr++ = *tarptr++;
						not = TRUE;
					}
					break;
				}
				break;

			}
			break;

		case '*': // *x, *@int, *$str, *!x
		RE2:
			switch(*_costume_ict++) {
			case '!':
				switch(*_costume_ict++) {
				case 's': while (CONDITION(_isspace(*tarptr))) tarptr++; break;
				case 'S': while (CONDITION(!_isspace(*tarptr))) tarptr++; break;
				case 'd': while (CONDITION(_isnumeric(*tarptr))) tarptr++; break;
				case 'D': while (CONDITION(!_isnumeric(*tarptr))) tarptr++; break;
				case 'w': while (CONDITION(_isalnumub(*tarptr))) tarptr++; break;
				case 'W': while (CONDITION(!_isalnumub(*tarptr))) tarptr++; break;
				case '\\':
					switch(*_costume_ict++)
					{
					case 'n': while (CONDITION(*tarptr == '\n')) tarptr++; break;
					case 'r': while (CONDITION(*tarptr == '\r')) tarptr++; break;
					case 't': while (CONDITION(*tarptr == '\t')) tarptr++; break;
					case 'f': while (CONDITION(*tarptr == '\f')) tarptr++; break;
					default: while(CONDITION(*tarptr == *(_costume_ict-1))) tarptr++; break;
					}
					break;

				}
				not = TRUE;
				break;

			case '\\':
				switch(*_costume_ict++)
				{
				case 'n': if(CONDITION(*tarptr == '\n')) tarptr++; break;
				case 'r': if(CONDITION(*tarptr == '\r')) tarptr++; break;
				case 't': if(CONDITION(*tarptr == '\t')) tarptr++; break;
				case 'f': if(CONDITION(*tarptr == '\f')) tarptr++; break;
				default: if(CONDITION(*tarptr == *(_costume_ict-1))) tarptr++; break;
				}
				not = TRUE;
				break;

			case '^': // not
				not = FALSE;
				goto RE2;
				break;

			default:
				if(_isalnumub((int)(*_costume_ict))) {
					if(CONDITION(*tarptr == *_costume_ict)) 
						*tarptr++;
					not = TRUE;
				}
				break;
			}
			break;

		case '/': // Delimiter
			break;

		case '\\':
			switch(*_costume_ict++)
			{
			case 'n': *ptr++ = '\n'; break;
			case 'r': *ptr++ = '\r'; break;
			case 't': *ptr++ = '\t'; break;
			case 'f': *ptr++ = '\f'; break;
			default: *ptr++ = *(_costume_ict-1); break;
			}
			break;

		default:
			if (_isalnum((int)(tmp = *(_costume_ict - 1)))) {
				*ptr++ = tmp;
				for (; _isalnum((int)*_costume_ict); _costume_ict++)
					*ptr++ = *_costume_ict;
			}
			break;
		}
	} while (*_costume_ict && *_costume_ict != ']');
	return ret;
}
예제 #30
0
_CODE_ACCESS int iswspace(wint_t c)
   { return (c == WEOF || (char)c != c) ? 0 : _isspace((char)c); }