bool ToolBox::isdigit(std::string str, bool deci)
{
bool point = false;
bool expo = false;
bool in = false;
for (std::string::iterator it=str.begin(); it!=str.end(); ++it)
{
//std::cout << str.size() ;
if (in == false && isnumber(it))
{
in = true;
}
if (!(isexpo(str, it, expo) || (isvirg(str, it, point, in) && deci) || issign(str, it, in) || isnumber(it)))
{
//std::cout << "return " << *it <<"|"<< std::endl;
return false;
}
//if (!((*it >= '0' && *it <= '9') || (*it == '.' && !point && deci == true && it!=str.end() - 1)
// || (*it == '-' && in == false) || (*it == '+' && in == false) ))
// return false;
//point = (*it == '.') ? true : point;
}
if (!in)
return false;
return true;
}
void Lexer::ScanFloat()
{
char ch = NextChar();
if (isdigit(PeekAtChar()))
{
m_tokenType = FloatingConst;
do
{
*tp++ = ch;
ch = NextChar();
} while (isdigit(ch));
// Read the exponent, if any
if (ch == 'e' || ch == 'd' || ch == 'q')
{
char peek = PeekAtChar();
if (isdigit(peek) || issign(peek))
{
if (issign(peek))
{
NextChar();
if (!isdigit(PeekAtChar()))
{
PushBack(peek);
PushBack(ch);
return;
}
ch = peek;
}
else
ch = NextChar();
*tp++ = 'e';
do
{
*tp++ = ch;
ch = NextChar();
} while (isdigit(ch));
}
}
}
PushBack(ch);
}
static int getop2(char *s)
{
int c;
/* skip the white space */
while (isspace(c = *s = mygetchar()) && c != '\n')
;
s[1] = '\0';
if (!isdigit(c) && !issign(c) && c != '.') {
return c;
}
/* scan the char after the sign */
if (issign(c)) {
if (isdigit(c = mygetchar())) {
*++s = c;
} else {
myungetc(c);
return *s;
}
}
/* scan for the integral part */
while (isdigit(c = mygetchar())) {
*++s = c;
}
/* not a digit, is it a decimal point? */
if (c == '.') {
*++s = c;
/* scan for the floating part */
while (isdigit(c = mygetchar())) {
*++s = c;
}
}
if (c != EOF) {
myungetc(c);
}
*++s = '\0';
return NUMBER;
}
static int
read_sign(const char **s,
char **b)
{
int sign = '?';
if (issign(**s)) {
sign = **b = **s;
(*s)++;
(*b)++;
}
return sign;
}
inline bool isFloat(const char* s) {
if (!s) return false;
if (!strcmp(s, "NaN")) return true;
if (issign(*s)) s++;
if (!strcmp(s, "Infinity")) return true;
if (*s == '\0') return false;
while (isdigit(*s)) s++;
if (*s == '.') {
s++;
while (isdigit(*s)) s++;
}
if (*s == 'e' || *s == 'E') {
s++;
if (issign(*s)) s++;
if (!isdigit(*s)) return false;
while (isdigit(*s)) s++;
}
return *s == '\0';
}
static int
read_comp(const char **s, int strict,
VALUE *ret, char **b)
{
char *bb;
int sign;
VALUE num, num2;
bb = *b;
sign = read_sign(s, b);
if (isimagunit(**s)) {
(*s)++;
num = INT2FIX((sign == '-') ? -1 : + 1);
*ret = rb_complex_new2(ZERO, num);
return 1; /* e.g. "i" */
}
if (!read_rat_nos(s, strict, b)) {
**b = '\0';
num = str2num(bb);
*ret = rb_complex_new2(num, ZERO);
return 0; /* e.g. "-" */
}
**b = '\0';
num = str2num(bb);
if (isimagunit(**s)) {
(*s)++;
*ret = rb_complex_new2(ZERO, num);
return 1; /* e.g. "3i" */
}
if (**s == '@') {
int st;
(*s)++;
bb = *b;
st = read_rat(s, strict, b);
**b = '\0';
if (strlen(bb) < 1 ||
!isdecimal(*(bb + strlen(bb) - 1))) {
*ret = rb_complex_new2(num, ZERO);
return 0; /* e.g. "1@-" */
}
num2 = str2num(bb);
*ret = rb_complex_polar(num, num2);
if (!st)
return 0; /* e.g. "1@2." */
else
return 1; /* e.g. "1@2" */
}
if (issign(**s)) {
bb = *b;
sign = read_sign(s, b);
if (isimagunit(**s))
num2 = INT2FIX((sign == '-') ? -1 : + 1);
else {
if (!read_rat_nos(s, strict, b)) {
*ret = rb_complex_new2(num, ZERO);
return 0; /* e.g. "1+xi" */
}
**b = '\0';
num2 = str2num(bb);
}
if (!isimagunit(**s)) {
*ret = rb_complex_new2(num, ZERO);
return 0; /* e.g. "1+3x" */
}
(*s)++;
*ret = rb_complex_new2(num, num2);
return 1; /* e.g. "1+2i" */
}
/* !(@, - or +) */
{
*ret = rb_complex_new2(num, ZERO);
return 1; /* e.g. "3" */
}
}
inline bool isInteger(const char* s) {
if (!s) return false;
if (issign(*s)) s++;
while (isdigit(*s)) s++;
return *s == '\0';
}
l_R(int poststar, int reqint)
#endif
{
char s[FMAX+EXPMAXDIGS+4];
register int ch;
register char *sp, *spe, *sp1;
long e, exp;
int havenum, havestar, se;
if (!poststar) {
if (f__lcount > 0)
return(0);
f__lcount = 1;
}
#ifdef Allow_TYQUAD
f__llx = 0;
#endif
f__ltype = 0;
exp = 0;
havestar = 0;
retry:
sp1 = sp = s;
spe = sp + FMAX;
havenum = 0;
switch(GETC(ch)) {
case '-': *sp++ = ch; sp1++; spe++;
case '+':
GETC(ch);
}
while(ch == '0') {
++havenum;
GETC(ch);
}
while(isdigit(ch)) {
if (sp < spe) *sp++ = ch;
else ++exp;
GETC(ch);
}
if (ch == '*' && !poststar) {
if (sp == sp1 || exp || *s == '-') {
errfl(f__elist->cierr,112,"bad repetition count");
}
poststar = havestar = 1;
*sp = 0;
f__lcount = atoi(s);
goto retry;
}
if (ch == '.') {
#ifndef ALLOW_FLOAT_IN_INTEGER_LIST_INPUT
if (reqint)
errfl(f__elist->cierr,115,"invalid integer");
#endif
GETC(ch);
if (sp == sp1)
while(ch == '0') {
++havenum;
--exp;
GETC(ch);
}
while(isdigit(ch)) {
if (sp < spe)
{ *sp++ = ch; --exp; }
GETC(ch);
}
}
havenum += sp - sp1;
se = 0;
if (issign(ch))
goto signonly;
if (havenum && isexp(ch)) {
#ifndef ALLOW_FLOAT_IN_INTEGER_LIST_INPUT
if (reqint)
errfl(f__elist->cierr,115,"invalid integer");
#endif
GETC(ch);
if (issign(ch)) {
signonly:
if (ch == '-') se = 1;
GETC(ch);
}
if (!isdigit(ch)) {
bad:
errfl(f__elist->cierr,112,"exponent field");
}
e = ch - '0';
while(isdigit(GETC(ch))) {
e = 10*e + ch - '0';
if (e > EXPMAX)
goto bad;
}
if (se)
exp -= e;
else
exp += e;
}
(void) Ungetc(ch, f__cf);
if (sp > sp1) {
++havenum;
while(*--sp == '0')
++exp;
if (exp)
sprintf(sp+1, "e%ld", exp);
else
sp[1] = 0;
f__lx = atof(s);
#ifdef Allow_TYQUAD
if (reqint&2 && (se = sp - sp1 + exp) > 14 && se < 20) {
/* Assuming 64-bit longint and 32-bit long. */
if (exp < 0)
sp += exp;
if (sp1 <= sp) {
f__llx = *sp1 - '0';
while(++sp1 <= sp)
f__llx = 10*f__llx + (*sp1 - '0');
}
while(--exp >= 0)
f__llx *= 10;
if (*s == '-')
f__llx = -f__llx;
}
#endif
}
else
f__lx = 0.;
if (havenum)
f__ltype = TYLONG;
else
switch(ch) {
case ',':
case '/':
break;
default:
if (havestar && ( ch == ' '
||ch == '\t'
||ch == '\n'))
break;
if (nml_read > 1) {
f__lquit = 2;
return 0;
}
errfl(f__elist->cierr,112,"invalid number");
}
return 0;
}
/*
* Gets the next token from the `lexfile` FILE stream.
* Side effects:
* - If the TokenType has an associated string, it is found in global `lexstr`.
* - If the TokenType has an associated integer value, look in global `lexint`.
*/
TokenType next_tok(void) {
if (!curr_char) eat(); // Eat first char.
while (curr_char != EOF) {
lo_col = curr_col; // Save first col of the token.
// Newline.
if (curr_char == '\n') {
eat();
return TOK_NL;
}
// Skip whitespace.
if (isspace(curr_char)) {
eat();
continue;
}
// Skip comments until next line.
if (curr_char == ';') {
do {
eat();
} while (curr_char != '\n' && curr_char != EOF);
continue;
}
// id ::= [A-Za-z$_][A-Za-z_$0-9]*
// reg ::= r([0-9]|1[0-5])[abcd] | rs | re[0-6] | rk[0-7]
// label ::= <nonopcode id>:
if (is_idstart(curr_char)) {
int i;
// TODO: Make this loop prettier.
for (i = 0; curr_char != EOF; i++) {
lexstr[i] = curr_char;
if (is_idcont(peek())) {
eat();
} else {
break;
}
}
lexstr[++i] = '\0';
eat(); // Advance to next char after the identifier.
// Register?
if (lexstr[0] == 'r') {
// Long or short
if (is_long_reg(lexstr))
return TOK_GL_REG;
if (is_short_reg(lexstr))
return TOK_GS_REG;
// Extra
if (is_extra_reg(lexstr))
return TOK_E_REG;
// Kernel
if (is_kernel_reg(lexstr))
return TOK_K_REG;
}
// Directive?
if (is_dtv(lexstr)) {
return TOK_DATA_SEG;
}
// Instruction?
if (isInstruction(lexstr))
return TOK_INSTR;
// Label?
if (curr_char == ':') {
eat(); // Eat the ':'
return TOK_LABEL;
}
// Plain identfier
return TOK_ID;
}
// chr_lit ::= '[^\\']'
if (curr_char == '\'') {
eat(); // Get inner char.
if (curr_char == '\\') {
lexstr[0] = escape(eat());
} else {
lexstr[0] = curr_char;
}
lexstr[1] = '\0';
eat(); // Reach the closing quote.
// Error: for situations like '\'
if (curr_char != '\'') {
jas_err("Character literal missing closing quote.",
curr_line, lo_col, curr_col);
return TOK_UNK;
}
eat(); // Get rid of ' and advance.
return TOK_CHR_LIT;
}
// str_lit ::= "(\\.|[^\\"])*"
if (curr_char == '"') {
eat(); // Get first char of string.
// Let by escape chars, but not single \ or ".
int i;
for (i = 0; curr_char != '"'; i++) {
// Check that we don't close reach EOF before the close ".
if (curr_char == EOF) {
jas_err("EOF while parsing string literal.",
curr_line, curr_col, curr_col);
return TOK_UNK;
}
if (curr_char == '\\') {
lexstr[i] = escape(eat());
} else {
lexstr[i] = curr_char;
}
eat();
}
lexstr[i] = '\0';
eat(); // Get rid of the " and advance.
return TOK_STR_LIT;
}
// num_lit ::= [+-][1-9][0-9]* | [+-]0[0-7]* | [+-]0x[0-9A-Fa-f]+
// | [+-]0b[01]+
if ((issign(curr_char) && isdigit(peek())) || isdigit(curr_char)) {
int base = 10; // Numeric base for interpreting the literal.
int chars_read; // Keep track of how many columns we move forward.
int sign = +1;
// Grab sign if it exists.
if (issign(curr_char)) {
sign = (curr_char == '+' ? +1 : -1);
eat(); // Get next number character.
}
// Choose base by prefix:
if (curr_char == '0') {
int next = peek();
if (next == 'x' || next == 'X') {
base = HEX_BASE;
} else if (next == 'b' || next == 'B') {
base = BIN_BASE;
} else {
base = OCT_BASE;
}
}
// Re-place sign back into lexstr for strtol.
if (sign == +1) {
lexstr[0] = '+';
} else {
lexstr[0] = '-';
}
// Copy in whole num literal, keep track of columns.
chars_read = fgets_base(lexstr + 1, lexfile, base);
curr_col += chars_read;
// Convert to integer value, using saved sign.
lexint = sign * strtol(lexstr, NULL, base);
// Check for `int` size (we can support max of 32 bits)
if (lexint < INT_MIN || UINT_MAX < lexint) {
jas_err("Integer larger than 32 bits.",
curr_line, lo_col, curr_col);
}
return TOK_NUM;
}
// Let by various punctuation:
switch (curr_char) {
case ',': eat(); return TOK_COMMA;
case '.': eat(); return TOK_DOT;
case '+': eat(); return TOK_PLUS;
case '-': eat(); return TOK_MINUS;
case '[': eat(); return TOK_LBRACKET;
case ']': eat(); return TOK_RBRACKET;
}
jas_err("Unknown character encountered.", curr_line, lo_col, lo_col);
eat(); // Advance to next char.
}
return TOK_EOF;
}
l_R(int poststar)
#endif
{
char s[FMAX+EXPMAXDIGS+4];
register int ch;
register char *sp, *spe, *sp1;
long e, exp;
int havenum, havestar, se;
if (!poststar) {
if (f__lcount > 0)
return(0);
f__lcount = 1;
}
f__ltype = 0;
exp = 0;
havestar = 0;
retry:
sp1 = sp = s;
spe = sp + FMAX;
havenum = 0;
switch(GETC(ch)) {
case '-': *sp++ = ch; sp1++; spe++;
case '+':
GETC(ch);
}
while(ch == '0') {
++havenum;
GETC(ch);
}
while(isdigit(ch)) {
if (sp < spe) *sp++ = ch;
else ++exp;
GETC(ch);
}
if (ch == '*' && !poststar) {
if (sp == sp1 || exp || *s == '-') {
errfl(f__elist->cierr,112,"bad repetition count");
}
poststar = havestar = 1;
*sp = 0;
f__lcount = atoi(s);
goto retry;
}
if (ch == '.') {
GETC(ch);
if (sp == sp1)
while(ch == '0') {
++havenum;
--exp;
GETC(ch);
}
while(isdigit(ch)) {
if (sp < spe)
{ *sp++ = ch; --exp; }
GETC(ch);
}
}
havenum += sp - sp1;
se = 0;
if (issign(ch))
goto signonly;
if (havenum && isexp(ch)) {
GETC(ch);
if (issign(ch)) {
signonly:
if (ch == '-') se = 1;
GETC(ch);
}
if (!isdigit(ch)) {
bad:
errfl(f__elist->cierr,112,"exponent field");
}
e = ch - '0';
while(isdigit(GETC(ch))) {
e = 10*e + ch - '0';
if (e > EXPMAX)
goto bad;
}
if (se)
exp -= e;
else
exp += e;
}
(void) Ungetc(ch, f__cf);
if (sp > sp1) {
++havenum;
while(*--sp == '0')
++exp;
if (exp)
sprintf(sp+1, "e%ld", exp);
else
sp[1] = 0;
f__lx = atof(s);
}
else
f__lx = 0.;
if (havenum)
f__ltype = TYLONG;
else
switch(ch) {
case ',':
case '/':
break;
default:
if (havestar && ( ch == ' '
||ch == '\t'
||ch == '\n'))
break;
if (nml_read > 1) {
f__lquit = 2;
return 0;
}
errfl(f__elist->cierr,112,"invalid number");
}
return 0;
}
