/*!
@brief try to get one parameter in []
@param p string to obtain parameter
@return true if string is returned else false
*/
bool Parser::_get_param_ncom(TokenString *p)
{
bool whitechar = false;
char wchar;
_readchar();
if (isspace(_char))
{
whitechar = true;
if (_char==cr)
_char=newline;
wchar = _char;
}
else
_putback();
_skip_whitechars();
_readchar();
if (_char != lbracket )
{
_in.putback(_char);
if (whitechar)
_in.putback(wchar);
return false;
}
_readchar();
while (_char != rbracket && !_isend)
{
*p << _char;
_readchar();
}
if (_char != rbracket)
return false;
else
return true;
}
/*!
@brief skip all white character in the stream
*/
void Parser::_skip_whitechars(void)
{
_readchar();
while ( !_isend && isspace(_char) )
{
_readchar();
}
if (!_isend)
_in.putback(_char);
}
void Parser::_skip_comment()
{
while (_char!=newline && !_isend)
{
_readchar();
}
_out << std::endl;
_skip_whitechars(); // skip all whitechars on new line
}
size_t
fread(void* a, size_t size, size_t nelem, FILE* str)
{
size_t ns = (size * nelem);
size_t n;
if ((ns == 0) || (a == NULL) || (str == NULL))
return 0;
_LOCK_FILE(str);
if (str->nback > 0)
{
/* If there are ungetc'd characters and there's room in the buffer,
then restore the characters. Anything that doesn't fit gets
flushed. This may violate the guarantee that at least one
ungetc must work. */
while ((str->nback > 0) && (str->_Next > str->_Buf))
{
--str->_Next;
#if (BYTES_PER_WORD==1)
*((unsigned char*) str->_Next) = str->_Back[--str->nback];
#else
if (str->_Mode & M_BINARY) {
*((unsigned char*) str->_Next) = str->_Back[--str->nback];
} else {
DEPOSIT_BYTE(*WORD_ADDR(str->_Next),
str->_Next,
str->_Back[--str->nback]);
}
#endif
}
str->_Rend = str->rsave;
}
#if (BYTES_PER_WORD==1)
n = _readbinary(a,ns,str);
#else
if ((BYTES_PER_WORD==1) || (str->_Mode & M_BINARY))
n = _readbinary(a,ns,str);
else
n = _readchar(a,ns,str);
#endif
_UNLOCK_FILE(str);
return n / size;
}
/*!
@brief return one token from stream
*/
void Parser::_readnexttoken()
{
_tokenstring.clean();
if (_skip_whitec)
{
_skip_whitechars();
}
if (_isend)
{
_token = tok_isend;
return ;
}
_readchar();
if (isspace(_char))
{
_tokenstring << _char;
_token = _char;
return ;
} else
if (ispunct(_char))
{
_token = _char;
_tokenstring << _char;
return;
} else
{
while (iscesym(_char) && !_isend)
{
/* create string from chars */
_tokenstring << _char;
_readchar();
}
if (!_isend) _in.putback(_char);
_token = tok_word;
}
// _tokenstring.print();
}
/*!
@brief try to find begin/end parameter
@return parameter of \begin or \end
*/
TokenString Parser::_get_begroup(void)
{
_skip_whitechars();
_readchar();
if (_char != lbrace )
return TokenString();
_skip_whitechars();
_readnexttoken();
TokenString pom(_tokenstring);
_skip_whitechars();
_readnexttoken();
if (_token != rbrace)
{
//std::cerr << "Chybny parametr u end/begin" << std::endl;
return TokenString();
}
return pom;
}
/*!
@brief try to recognize parameters in command \command{p1}[p2]
@param p1 will be filled with compulsory parameters (params. in {})
@param p2 will be filled with non-compulsory parameters (params in [])
@return number of parameters 0=none, 1=only comp, 2=only non-comp, 4=comp+non-comp
*/
int Parser::_get_params(TokenString *p1, TokenString *p2)
{
int save_c;
int ret = 1;
bool there_was_space = false;
_skip_whitechars();
_readchar();
if (_char != lbrace && _char != lbracket )
{
_in.putback(_char);
return 0;
}
save_c = _char;
_skip_whitechars();
if (save_c == lbrace)
{
p1->clean();
_readchar();
while (_char != rbrace && !_isend)
{
*p1 << _char;
_readchar();
}
if (isspace(_char))
{
_skip_whitechars();
there_was_space = true;
}
_readchar();
if (_char == lbracket)
{
p2->clean();
_readchar();
while (_char != rbracket && !_isend)
{
*p2 << _char;
_readchar();
}
_in.putback(_char);
ret=4;
} else { if (there_was_space) { _in.putback(' '); }; _in.putback(_char);}
} else
{
p2->clean();
_readchar();
while (_char != rbracket && !_isend)
{
*p2 << _char;
_readchar();
}
ret=2;
if (isspace(_char))
{
_skip_whitechars();
there_was_space = true;
}
_readchar();
if (_char == lbrace)
{
p1->clean();
_readchar();
while (_char != rbrace && !_isend)
{
*p1 << _char;
_readchar();
}
//_in.putback(_char);
ret=4;
} else { if (there_was_space) { _in.putback(' '); } ; _in.putback(_char);}
}
return ret;
}
/*!
@brief return one token from stream
*/
Token Parser::GetToken(void)
{
_readnexttoken();
switch (_token)
{
case backslash:
_getcommand();
break;
case cr:
break;
case newline:
_printtoken(); // \n latex bere jako whitespace
_skip_whitechars(); // vse bile, co je na zacatku noveho radku se ignoruje
break;
case space:
case tab:
_printtoken(); // vice whitespace se bere jako jedna whitespace
_skip_whitechars();
break;
case tok_word:
_printtoken();
break;
case percent:
_skip_comment();
break;
case accent1: // oteviraci uvozovky se delaji pomoci ''
_readchar();
if ( _char == accent1)
{
_token = quote;
_tokenstring.clean();
_tokenstring << '\"';
} else
{
_in.putback(_char);
}
_printtoken();
break;
case accent2: // uzaviraci uvozovky se delaji pomoci ``
_readchar();
if ( _char == accent2)
{
_token = quote;
_tokenstring.clean();
_tokenstring << '\"';
} else
{
_in.putback(_char);
}
_printtoken();
break;
case hyphen:
_tokenstring.clean();
_readchar();
if ( _char == hyphen )
{
_readchar();
if ( _char == hyphen )
{
_tokenstring << "—";
}
else
{
_in.putback(_char);
_tokenstring << "–";
}
} else
{
_in.putback(_char);
_tokenstring << "­";
}
_printtoken();
break;
case tilda:
_tokenstring.clean();
_tokenstring << " ";
_printtoken();
break;
default:
_printtoken();
break;
}
return _token;
}
chtype
tgetch(int interpret)
{
int i = 0, j, collapse = 1;
#define WAIT3 333
chtype inp;
chtype *inputQ = cur_term->_input_queue;
char *chars_onQ = &(cur_term->_chars_on_queue);
#ifdef SYSV
/*
* Register the fact that getch is being used so
* that typeahead checking can be done.
* This code should GO AWAY when a poll() or FIONREAD can
* be done on the file descriptor as then the check
* will be non-destructive.
*/
cur_term->fl_typeahdok = TRUE;
#endif /* SYSV */
/* ask for input */
if (cur_term->_ungotten > 0) {
cur_term->_ungotten--;
/* decode an ungetch()'d character */
inp = -inputQ[0];
} else {
/* Only read a character if there is no typeahead/peekahead. */
if (*chars_onQ == 0) {
/* (*chars_onQ)++; MR */
#ifdef FIONREAD
inp = _readchar();
#else /* FIONREAD */
inp = (chtype) _pk();
if ((int)inp == ERR) {
/*
* interpret is set to 0 so that down below we don't
* drop into getkey since we already know there can't be
* a key that starts with -1. Also, we don't want to
* access funckeystarter[-1].
*/
interpret = FALSE;
}
#endif /* FIONREAD */
(*chars_onQ)++;
} else
inp = inputQ[0];
#ifdef DEBUG
if (outf)
fprintf(outf, "TGETCH read '%s'\n", unctrl(inp));
#endif /* DEBUG */
/* Check for arrow and function keys */
if (interpret && cur_term->funckeystarter[inp])
collapse = _getkey(interpret - 1, &inp);
}
/* Collapse the input queue to remove the escape */
/* sequence from the stack. */
j = *chars_onQ;
(*chars_onQ) -= collapse;
while (collapse < j)
inputQ[i++] = inputQ[collapse++];
return (inp);
}
