static int scan_number_assignment(struct misc_file_buffer* file, struct scan_token* token, int line) { int rc; rc = scan_number(file, &token->content.number.number, line); if (rc) return rc; skip_blanks(file); if (misc_get_char(file, 0) != '=') { error_reason("Line %d: number expected as keyword", line); return -1; } file->pos++; skip_blanks(file); rc = scan_value_string(file, &token->content.number.value, line); if (rc) return rc; if (skip_trailing_blanks(file)) { error_reason("Line %d: unexpected characters at end of line", line); return -1; } token->id = scan_id_number_assignment; token->line = line; return 0; }
std::string in_numeric_range(cmdline_param const & param, char const * value, void const * range_info) { const char * const MSG = "Error with {1}=\"{2}\": expected a value between " "{3=min} and {4=max} (inclusive), formatted as {5}."; precondition(range_info != nullptr); numeric_range_info const & nri = *reinterpret_cast<numeric_range_info const *>(range_info); number_info info; auto ptr_to_null_char = strchr(value, 0); auto end = scan_number(value, ptr_to_null_char, nri.allowed_formats, info); auto valid = (end == ptr_to_null_char); if (valid) { if (info.format == numeric_formats::floating_point_only) { if (!std::isnan(nri.min) && info.floating_point < nri.min) { valid = false; } else if (!std::isnan(nri.max) && info.floating_point > nri.max) { valid = false; } } else { int64_t n = static_cast<int64_t>(info.whole_number); if (info.negative) { n *= -1; } valid = n >= nri.min && n <= nri.max; } } return valid ? "" : interp(MSG, {param.get_preferred_name(), value, nri.min, nri.max, get_names_for_numeric_formats(nri.allowed_formats)}); }
/* Scan a line of the specified /proc/devices FILE buffer and advance the * current file position pointer respectively. If the current line matches * the correct pattern, fill in the corresponding data into ENTRY and return 0. * Return non-zero otherwise. */ static int scan_dev_entry(struct file_buffer* file, struct proc_dev_entry* entry, int blockdev) { int rc; size_t dev_major; char* name; /* Scan for: (\s*)(\d+)(\s+)(\S+)(\.*)$ */ skip_whitespaces(file); rc = scan_number(file, &dev_major); if (rc) return rc; rc = skip_whitespaces(file); if (rc) return rc; rc = scan_name(file, &name); if (rc) return rc; skip_line(file); entry->device = makedev(dev_major, 0); entry->name = name; entry->blockdev = blockdev; return 0; }
int get_prefix_1(inet_prefix *dst, char *arg, int family) { int err; unsigned plen; char *slash; memset(dst, 0, sizeof(*dst)); if (strcmp(arg, "default") == 0 || strcmp(arg, "any") == 0) { dst->family = family; dst->bytelen = 0; dst->bitlen = 0; return 0; } slash = strchr(arg, '/'); if (slash) *slash = 0; err = get_addr_1(dst, arg, family); if (err == 0) { dst->bitlen = (dst->family == AF_INET6 ? 128 : 32); if (slash) { if (scan_number(slash+1, &plen) || plen > dst->bitlen) { err = -1; goto done; } dst->bitlen = plen; } } done: if (slash) *slash = '/'; return err; }
/****************************************************************** scan() See prlex.h for return values other than characters (i.e. > 256) *******************************************************************/ int scan() { ini_scan(); getachar(); if(Ch == EOF) return(EOF); switch(Ctype[Ch]) { case DI: MY_ASSERT(isdigit(Ch)); /* double check */ case SI: MY_ASSERT(isdigit(Ch) || Ch == '-' || Ch == '+'); return(scan_number(Ch)); case QU: MY_ASSERT(Ch == '"'); scan_string(); return(TOKEN_STRING); case BR: MY_ASSERT(Ch == ')' || Ch == '('); return(Ch); #ifdef CLIPS_SYNTAX case QE: scan_identifier(?); return(TOKEN_VAR); case AL: case AU: case OT: scan_identifier(Ch); return(TOKEN_ATOM); #else case AL: MY_ASSERT(islower(Ch)); scan_identifier(Ch); return(TOKEN_ATOM); case US: MY_ASSERT(Ch == '_'); case AU: scan_identifier(Ch); return(TOKEN_VAR); #endif case CC: return(SCAN_ERR); #ifdef CHARACTER case AP: return(scan_character()); #endif default: return(Ch); } }
char *read_cnumber(struct token *tok, const char *s, const char *e, tok_message_queue *mq) { struct scan_number sn; tok->type = scan_number(&sn, s, e); if (tok->type == TOK_INTEGER) read_integer(&tok->integer, &sn, mq); else read_floating(&tok->floating, &sn, mq); return (char*)sn.end; }
/* Scan a line of the specified /proc/partitions FILE buffer and advance the * current file position pointer respectively. If the current line matches * the correct pattern, fill in the corresponding data into ENTRY and return 0. * Return non-zero otherwise. */ static int scan_part_entry(struct file_buffer* file, struct proc_part_entry* entry) { int rc; size_t dev_major; size_t dev_minor; size_t blockcount; char* name; /* Scan for: (\s*)(\d+)(\s+)(\d+)(\s+)(\d+)(\s+)(\S+)(\.*)$ */ skip_whitespaces(file); rc = scan_number(file, &dev_major); if (rc) return rc; rc = skip_whitespaces(file); if (rc) return rc; rc = scan_number(file, &dev_minor); if (rc) return rc; rc = skip_whitespaces(file); if (rc) return rc; rc = scan_number(file, &blockcount); if (rc) return rc; rc = skip_whitespaces(file); if (rc) return rc; rc = scan_name(file, &name); if (rc) return rc; skip_line(file); entry->device = makedev(dev_major, dev_minor); entry->blockcount = blockcount; entry->name = name; return 0; }
static _TKN_TYPE_ scan_Dgt(_NIL_TYPE_) { return scan_number(); }
int main (int argc, char *argv[]) { const unsigned char *p, *eof; int i; const char *error_string; struct stat sb; Marpa_Config marpa_configuration; Marpa_Grammar g; Marpa_Recognizer r; /* Longest rule is 4 symbols */ Marpa_Symbol_ID rhs[4]; int fd = open (argv[1], O_RDONLY); //initialize a stat for getting the filesize if (fstat (fd, &sb) == -1) { perror ("fstat"); return 1; } //do the actual mmap, and keep pointer to the first element p = (unsigned char *) mmap (0, sb.st_size, PROT_READ, MAP_SHARED, fd, 0); //something went wrong if (p == MAP_FAILED) { perror ("mmap"); return 1; } marpa_c_init (&marpa_configuration); g = marpa_g_new (&marpa_configuration); if (!g) { Marpa_Error_Code errcode = marpa_c_error (&marpa_configuration, &error_string); printf ("marpa_g_new returned %d: %s", errcode, error_string); exit (1); } ((S_begin_array = marpa_g_symbol_new (g)) >= 0) || fail ("marpa_g_symbol_new", g); ((S_begin_object = marpa_g_symbol_new (g)) >= 0) || fail ("marpa_g_symbol_new", g); ((S_end_array = marpa_g_symbol_new (g)) >= 0) || fail ("marpa_g_symbol_new", g); ((S_end_object = marpa_g_symbol_new (g)) >= 0) || fail ("marpa_g_symbol_new", g); ((S_name_separator = marpa_g_symbol_new (g)) >= 0) || fail ("marpa_g_symbol_new", g); ((S_value_separator = marpa_g_symbol_new (g)) >= 0) || fail ("marpa_g_symbol_new", g); ((S_member = marpa_g_symbol_new (g)) >= 0) || fail ("marpa_g_symbol_new", g); ((S_value = marpa_g_symbol_new (g)) >= 0) || fail ("marpa_g_symbol_new", g); ((S_false = marpa_g_symbol_new (g)) >= 0) || fail ("marpa_g_symbol_new", g); ((S_null = marpa_g_symbol_new (g)) >= 0) || fail ("marpa_g_symbol_new", g); ((S_true = marpa_g_symbol_new (g)) >= 0) || fail ("marpa_g_symbol_new", g); ((S_object = marpa_g_symbol_new (g)) >= 0) || fail ("marpa_g_symbol_new", g); ((S_array = marpa_g_symbol_new (g)) >= 0) || fail ("marpa_g_symbol_new", g); ((S_number = marpa_g_symbol_new (g)) >= 0) || fail ("marpa_g_symbol_new", g); ((S_string = marpa_g_symbol_new (g)) >= 0) || fail ("marpa_g_symbol_new", g); ((S_object_contents = marpa_g_symbol_new (g)) >= 0) || fail ("marpa_g_symbol_new", g); ((S_array_contents = marpa_g_symbol_new (g)) >= 0) || fail ("marpa_g_symbol_new", g); rhs[0] = S_false; (marpa_g_rule_new (g, S_value, rhs, 1) >= 0) || fail ("marpa_g_rule_new", g); rhs[0] = S_null; (marpa_g_rule_new (g, S_value, rhs, 1) >= 0) || fail ("marpa_g_rule_new", g); rhs[0] = S_true; (marpa_g_rule_new (g, S_value, rhs, 1) >= 0) || fail ("marpa_g_rule_new", g); rhs[0] = S_object; (marpa_g_rule_new (g, S_value, rhs, 1) >= 0) || fail ("marpa_g_rule_new", g); rhs[0] = S_array; (marpa_g_rule_new (g, S_value, rhs, 1) >= 0) || fail ("marpa_g_rule_new", g); rhs[0] = S_number; (marpa_g_rule_new (g, S_value, rhs, 1) >= 0) || fail ("marpa_g_rule_new", g); rhs[0] = S_string; (marpa_g_rule_new (g, S_value, rhs, 1) >= 0) || fail ("marpa_g_rule_new", g); rhs[0] = S_begin_array; rhs[1] = S_array_contents; rhs[2] = S_end_array; (marpa_g_rule_new (g, S_array, rhs, 3) >= 0) || fail ("marpa_g_rule_new", g); rhs[0] = S_begin_object; rhs[1] = S_object_contents; rhs[2] = S_end_object; (marpa_g_rule_new (g, S_object, rhs, 3) >= 0) || fail ("marpa_g_rule_new", g); (marpa_g_sequence_new (g, S_array_contents, S_value, S_value_separator, 0, MARPA_PROPER_SEPARATION) >= 0) || fail ("marpa_g_sequence_new", g); (marpa_g_sequence_new (g, S_object_contents, S_member, S_value_separator, 0, MARPA_PROPER_SEPARATION) >= 0) || fail ("marpa_g_sequence_new", g); rhs[0] = S_string; rhs[1] = S_name_separator; rhs[2] = S_value; (marpa_g_rule_new (g, S_member, rhs, 3) >= 0) || fail ("marpa_g_rule_new", g); if (0) { (marpa_g_symbol_is_terminal_set (g, S_value_separator, 1) >= 0) || fail ("marpa_g_symbol_is_terminal", g); } (marpa_g_start_symbol_set (g, S_value) >= 0) || fail ("marpa_g_start_symbol_set", g); if (marpa_g_precompute (g) < 0) { marpa_g_error (g, &error_string); puts (error_string); exit (1); } r = marpa_r_new (g); if (!r) { marpa_g_error (g, &error_string); puts (error_string); exit (1); } if (!marpa_r_start_input (r)) { marpa_g_error (g, &error_string); puts (error_string); exit (1); } i = 0; eof = p + sb.st_size; while (p + i < eof) { Marpa_Symbol_ID token; const int start_of_token = i; switch (p[i]) { case '-': case '+': case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': i = scan_number (p + i, eof) - p; token = S_number; break; case '"': i = scan_string (p + i, eof) - p; token = S_string; break; case '[': token = S_begin_array; i++; break; case ']': token = S_end_array; i++; break; case '{': token = S_begin_object; i++; break; case '}': token = S_end_object; i++; break; case ',': token = S_value_separator; i++; break; case ':': token = S_name_separator; i++; break; case 'n': i = scan_constant ("null", (p + i), eof) - p; token = S_null; break; case ' ': case 0x09: case 0x0A: case 0x0D: i++; goto NEXT_TOKEN; default: marpa_g_error (g, &error_string); printf ("lexer failed at char %d: '%c'", i, p[i]); exit (1); } /* Token value of zero is not allowed, so we add one */ if (0) fprintf (stderr, "reading token %ld, %s\n", (long) token, symbol_name (token)); int status = marpa_r_alternative (r, token, start_of_token + 1, 1); if (status != MARPA_ERR_NONE) { Marpa_Symbol_ID expected[20]; int count_of_expected = marpa_r_terminals_expected (r, expected); int i; for (i = 0; i < count_of_expected; i++) { fprintf (stderr, "expecting symbol %ld, %s\n", (long) i, symbol_name (expected[i])); } marpa_g_error (g, &error_string); fprintf (stderr, "marpa_alternative(%p,%ld,%s,%ld,1) returned %d: %s", r, (long) token, symbol_name (token), (long) (start_of_token + 1), status, error_string); exit (1); } status = marpa_r_earleme_complete (r); if (status < 0) { marpa_g_error (g, &error_string); printf ("marpa_earleme_complete returned %d: %s", status, error_string); exit (1); } NEXT_TOKEN:; } { Marpa_Bocage bocage; Marpa_Order order; Marpa_Tree tree; bocage = marpa_b_new (r, -1); if (!bocage) { int errcode = marpa_g_error (g, &error_string); printf ("marpa_bocage_new returned %d: %s", errcode, error_string); exit (1); } order = marpa_o_new (bocage); if (!order) { int errcode = marpa_g_error (g, &error_string); printf ("marpa_order_new returned %d: %s", errcode, error_string); exit (1); } tree = marpa_t_new (order); if (!tree) { Marpa_Error_Code errcode = marpa_g_error (g, &error_string); printf ("marpa_t_new returned %d: %s", errcode, error_string); exit (1); } { Marpa_Value value = NULL; int column = 0; int tree_status; tree_status = marpa_t_next (tree); if (tree_status <= -1) { Marpa_Error_Code errcode = marpa_g_error (g, &error_string); printf ("marpa_t_next returned %d: %s", errcode, error_string); exit (1); } value = marpa_v_new (tree); if (!value) { Marpa_Error_Code errcode = marpa_g_error (g, &error_string); printf ("marpa_v_new returned %d: %s", errcode, error_string); exit (1); } while (1) { Marpa_Step_Type step_type = marpa_v_step (value); Marpa_Symbol_ID token; if (step_type < 0) { Marpa_Error_Code errcode = marpa_g_error (g, &error_string); printf ("marpa_v_event returned %d: %s", errcode, error_string); exit (1); } if (step_type == MARPA_STEP_INACTIVE) { if (0) printf ("No more events\n"); break; } if (step_type != MARPA_STEP_TOKEN) continue; token = marpa_v_token (value); if (1) { if (column > 60) { putchar ('\n'); column = 0; } if (token == S_begin_array) { putchar ('['); column++; continue; } if (token == S_end_array) { putchar (']'); column++; continue; } if (token == S_begin_object) { putchar ('{'); column++; continue; } if (token == S_end_object) { putchar ('}'); column++; continue; } if (token == S_name_separator) { putchar (':'); column++; continue; } if (token == S_value_separator) { putchar (','); column++; continue; } if (token == S_null) { fputs ("undef", stdout); column += 5; continue; } if (token == S_true) { putchar ('1'); column++; continue; } if (token == S_false) { putchar ('0'); column++; continue; } if (token == S_number) { /* We added one to avoid zero * Now we must subtract it */ int i; const int start_of_number = marpa_v_token_value (value) - 1; const int end_of_number = scan_number (p + start_of_number, eof) - p; column += 2 + (end_of_number - start_of_number); /* We output numbers as Perl strings */ putchar ('"'); for (i = start_of_number; i < end_of_number; i++) { putchar (p[i]); } putchar ('"'); continue; } if (token == S_string) { /* We added one to avoid zero * Now we must subtract it, but we also * add one for the initial double quote */ int i; const int start_of_string = marpa_v_token_value (value); /* Subtract one for the final double quote */ const int end_of_string = (scan_string (p + start_of_string, eof) - p) - 1; /* We add back the inital and final double quotes, * and increment the column accordingly. */ column += 2; putchar ('"'); i = start_of_string; while (i < end_of_string) { const unsigned char ch0 = p[i++]; if (ch0 == '\\') { const unsigned char ch1 = p[i++]; switch (ch1) { case '\\': case '/': case '"': case 'b': case 'f': case 'n': case 'r': case 't': /* explicit non-hex JSON escapes are the same * as the Perl escapes */ column += 2; putchar ('\\'); putchar (ch1); continue; case 'u': { int digit; putchar ('x'); putchar ('{'); for (digit = 0; digit < 4; digit++) { const unsigned char hex_ch = p[i + digit]; if ((hex_ch >= 'a' && hex_ch <= 'f') || (hex_ch >= 'A' && hex_ch <= 'F') || (hex_ch >= '0' && hex_ch <= '9')) { printf ("illegal char in JSON hex number at location %d (0x%x): '%c' ", i, hex_ch, hex_ch); exit (1); } putchar (hex_ch); } putchar ('}'); column += 7; i += 4; } continue; default: printf ("illegal escaped char in JSON input (0x%x):'%c' ", i, p[i]); exit (1); } } /* An unescaped JSON char, one that does not need Perl escaping */ if (ch0 == '_' || (ch0 >= '0' && ch0 <= '9') || (ch0 >= 'a' && ch0 <= 'z') || (ch0 >= 'A' && ch0 <= 'Z')) { putchar (ch0); column++; continue; } /* An unescaped JSON char, * but one which quotemeta would escape for Perl */ putchar ('\\'); putchar (ch0); column += 2; continue; } putchar ('"'); continue; } fprintf (stderr, "Unknown symbol %s at %d", symbol_name (token), marpa_v_token_value (value) - 1); exit (1); } } if (column > 60) { putchar ('\n'); column = 0; } } } return 0; }
int scan(scan_info *info) { int err = 0; int sym_code = SVO_NONE; const char **in = &(info->scanner); char tmp[SCAN_SIZE+1]; while((**in != 0) && (isspace(**in))) (*in)++; if(isalpha(**in)){ scan_ident(in,info->token,SCAN_SIZE); sym_code = token_to_id(info->token); if(sym_code == SVO_NONE) sym_code = SVO_IDENT; } else if(isdigit(**in)){ scan_number(in,info->token,SCAN_SIZE); sym_code = SVO_NUMBER; } else{ switch(**in){ case '#': sym_code = SVO_END; break; case '>': case '<': case '=': case '!': scan_comp(in,info->token,SCAN_SIZE); break; case '"': err = scan_string(info,SCAN_SIZE); if(err != SHE_NO_ERROR){ parse_vars_in_string(info->token,tmp,SCAN_SIZE); strncpy(info->token,tmp,SCAN_SIZE); info->token[SCAN_SIZE] = 0; } sym_code = SVO_DQ_STRING; break; case '\'': sym_code = SVO_SQ_STRING; err =scan_string(info,SCAN_SIZE); break; case 0: *(info->token) = 0; sym_code = SVO_END; break; default: info->token[0] = **in; info->token[1] = 0; (*in)++; break; } if(sym_code == SVO_NONE) sym_code = token_to_id(info->token); } info->sym_code = sym_code; return err; }
int luna_scan(luna_lexer_t *self) { int c; token(ILLEGAL); // deferred outdents if (self->outdents) return outdent(self); // scan scan: switch (c = next) { case ' ': case '\t': goto scan; case '(': return token(LPAREN); case ')': return token(RPAREN); case '{': return token(LBRACE); case '}': return token(RBRACE); case '[': return token(LBRACK); case ']': return token(RBRACK); case ',': return token(COMMA); case '.': return token(OP_DOT); case '%': return token(OP_MOD); case '^': return token(OP_BIT_XOR); case '~': return token(OP_BIT_NOT); case '?': return token(QMARK); case ':': return token(COLON); case '@': self->tok.value.as_string = "self"; return token(ID); case '+': switch (next) { case '+': return token(OP_INCR); case '=': return token(OP_PLUS_ASSIGN); default: return undo, token(OP_PLUS); } case '-': switch (next) { case '-': return token(OP_DECR); case '=': return token(OP_MINUS_ASSIGN); default: return undo, token(OP_MINUS); } case '*': switch (next) { case '=': return token(OP_MUL_ASSIGN); case '*': return token(OP_POW); default: return undo, token(OP_MUL); } case '/': return '=' == next ? token(OP_DIV_ASSIGN) : (undo, token(OP_DIV)); case '!': return '=' == next ? token(OP_NEQ) : (undo, token(OP_NOT)); case '=': return '=' == next ? token(OP_EQ) : (undo, token(OP_ASSIGN)); case '&': switch (next) { case '&': return '=' == next ? token(OP_AND_ASSIGN) : (undo, token(OP_AND)); default: return undo, token(OP_BIT_AND); } case '|': switch (next) { case '|': return '=' == next ? token(OP_OR_ASSIGN) : (undo, token(OP_OR)); default: return undo, token(OP_BIT_OR); } case '<': switch (next) { case '=': return token(OP_LTE); case '<': return token(OP_BIT_SHL); default: return undo, token(OP_LT); } case '>': switch (next) { case '=': return token(OP_GTE); case '>': return token(OP_BIT_SHR); default: return undo, token(OP_GT); } case '#': while ((c = next) != '\n' && c) ; undo; goto scan; case '\n': return scan_newline(self); case '"': case '\'': return scan_string(self, c); case 0: if (self->indents) { --self->indents; return token(OUTDENT); } token(EOS); return 0; default: if (isalpha(c) || '_' == c) return scan_ident(self, c); if (isdigit(c) || '.' == c) return scan_number(self, c); error("illegal character"); return 0; } }
int getToken() { char c; if (activeToken) { activeToken = FALSE; return ttype; } // we do not need an else because the function returns in the body // of the if skipSpace(); tokenLength = 0; c = getchar(); switch (c) { case '.': return DOT; case '+': return PLUS; case '-': return MINUS; case '/': return DIV; case '*': return MULT; case '=': return EQUAL; case ':': return COLON; case ',': return COMMA; case ';': return SEMICOLON; case '[': return LBRAC; case ']': return RBRAC; case '(': return LPAREN; case ')': return RPAREN; case '{': return LBRACE; case '}': return RBRACE; case '<': c = getchar(); if (c == '=') return LTEQ; else if (c == '>') return NOTEQUAL; else { ungetc(c,stdin); return LESS; } case '>': c = getchar(); if (c == '=') return GTEQ; else { ungetc(c, stdin); return GREATER; } default : if (isdigit(c)) { ungetc(c,stdin); return scan_number(); } else if (isalpha(c)) { ungetc(c,stdin); return scan_id_or_keyword(); } else if (c == EOF) return EOF; else return ERROR; } }
bool tokz_get_token(Tokenizer *tokz, Token *tok) { int c, c2, e; if (!(tokz->flags&TOKZ_READ_FROM_BUFFER)) assert(tokz->file!=NULL); tok_free(tok); if(!TOK_IS_INVALID(&(tokz->ungettok))){ *tok=tokz->ungettok; tokz->ungettok.type=TOK_INVALID; return TRUE; } while(1){ e=0; do{ c=GETCH(); }while(c!='\n' && c!=EOF && isspace(c)); tok->line=tokz->line; switch(c){ case EOF: TOK_SET_OP(tok, OP_EOF); return TRUE; case '\n': INC_LINE(); if(tokz->flags&TOKZ_IGNORE_NEXTLINE) continue; TOK_SET_OP(tok, OP_NEXTLINE); return TRUE; case '\\': do{ c=GETCH(); if(c==EOF){ TOK_SET_OP(tok, OP_EOF); return FALSE; } if(!isspace(c) && e==0){ e=E_TOKZ_EOL_EXPECTED; tokz_warn_error(tokz, tokz->line, e); if(!(tokz->flags&TOKZ_ERROR_TOLERANT)) return FALSE; } }while(c!='\n'); INC_LINE(); continue; case '#': if(tokz->flags&TOKZ_READ_COMMENTS){ e=scan_line_comment(tok, tokz); break; }else if((e=skip_line_comment(tokz))){ break; } continue; case '/': c2=GETCH(); if(c2=='='){ TOK_SET_OP(tok, OP_AS_DIV); return TRUE; } if(c2!='*'){ UNGETCH(c2); TOK_SET_OP(tok, OP_DIV); return TRUE; } if(tokz->flags&TOKZ_READ_COMMENTS){ e=scan_c_comment(tok, tokz); break; }else if((e=skip_c_comment(tokz))){ break; } continue; case '\"': e=scan_string(tok, tokz, TRUE); break; case '\'': e=scan_char(tok, tokz); break; default: if(('0'<=c && c<='9') || c=='-' || c=='+'){ e=scan_number(tok, tokz, c); break; } if(START_IDENT(c)) e=scan_identifier(tok, tokz, c); else e=scan_op(tok, tokz, c); } if(!e) return TRUE; tokz_warn_error(tokz, tokz->line, e); return FALSE; } }
/* * The scanner * */ int mcy_lex(void) { static const WCHAR ustr_dot1[] = { '.', '\n', 0 }; static const WCHAR ustr_dot2[] = { '.', '\r', '\n', 0 }; static int isinit = 0; int ch; if(!isinit) { isinit++; set_codepage(WMC_DEFAULT_CODEPAGE); add_token(tok_keyword, ustr_codepages, tCODEPAGE, 0, NULL, 0); add_token(tok_keyword, ustr_facility, tFACILITY, 0, NULL, 1); add_token(tok_keyword, ustr_facilitynames, tFACNAMES, 0, NULL, 1); add_token(tok_keyword, ustr_language, tLANGUAGE, 0, NULL, 1); add_token(tok_keyword, ustr_languagenames, tLANNAMES, 0, NULL, 1); add_token(tok_keyword, ustr_messageid, tMSGID, 0, NULL, 1); add_token(tok_keyword, ustr_messageidtypedef, tTYPEDEF, 0, NULL, 1); add_token(tok_keyword, ustr_outputbase, tBASE, 0, NULL, 1); add_token(tok_keyword, ustr_severity, tSEVERITY, 0, NULL, 1); add_token(tok_keyword, ustr_severitynames, tSEVNAMES, 0, NULL, 1); add_token(tok_keyword, ustr_symbolicname, tSYMNAME, 0, NULL, 1); add_token(tok_severity, ustr_error, 0x03, 0, NULL, 0); add_token(tok_severity, ustr_warning, 0x02, 0, NULL, 0); add_token(tok_severity, ustr_informational, 0x01, 0, NULL, 0); add_token(tok_severity, ustr_success, 0x00, 0, NULL, 0); add_token(tok_facility, ustr_application, 0xFFF, 0, NULL, 0); add_token(tok_facility, ustr_system, 0x0FF, 0, NULL, 0); add_token(tok_language, ustr_english, 0x409, 437, ustr_msg00001, 0); } empty_unichar_stack(); while(1) { if(want_line) { while((ch = get_unichar()) != '\n') { if(ch == EOF) xyyerror("Unexpected EOF\n"); push_unichar(ch); } newline(); push_unichar(ch); push_unichar(0); if(!unistrcmp(ustr_dot1, get_unichar_stack()) || !unistrcmp(ustr_dot2, get_unichar_stack())) { want_line = 0; /* Reset the codepage to our default after each message */ set_codepage(WMC_DEFAULT_CODEPAGE); return tMSGEND; } mcy_lval.str = xunistrdup(get_unichar_stack()); return tLINE; } ch = get_unichar(); if(ch == EOF) return EOF; if(ch == '\n') { newline(); if(want_nl) { want_nl = 0; return tNL; } continue; } if(isisochar(ch)) { if(want_file) { int n = 0; while(n < 8 && isisochar(ch)) { int t = char_table[ch]; if((t & CH_PUNCT) || !(t & CH_SHORTNAME)) break; push_unichar(ch); n++; ch = get_unichar(); } unget_unichar(ch); push_unichar(0); want_file = 0; mcy_lval.str = xunistrdup(get_unichar_stack()); return tFILE; } if(char_table[ch] & CH_IDENT) { token_t *tok; while(isisochar(ch) && (char_table[ch] & (CH_IDENT|CH_NUMBER))) { push_unichar(ch); ch = get_unichar(); } unget_unichar(ch); push_unichar(0); if(!(tok = lookup_token(get_unichar_stack()))) { mcy_lval.str = xunistrdup(get_unichar_stack()); return tIDENT; } switch(tok->type) { case tok_keyword: return tok->token; case tok_language: codepage = tok->codepage; /* Fall through */ case tok_severity: case tok_facility: mcy_lval.tok = tok; return tTOKEN; default: internal_error(__FILE__, __LINE__, "Invalid token type encountered\n"); } } if(isspace(ch)) /* Ignore space */ continue; if(isdigit(ch)) return scan_number(ch); } switch(ch) { case ':': case '=': case '+': case '(': case ')': return ch; case ';': while(ch != '\n' && ch != EOF) { push_unichar(ch); ch = get_unichar(); } newline(); push_unichar(ch); /* Include the newline */ push_unichar(0); mcy_lval.str = xunistrdup(get_unichar_stack()); return tCOMMENT; default: xyyerror("Invalid character '%c' (0x%04x)\n", isisochar(ch) && isprint(ch) ? ch : '.', ch); } } }
game* game_from_rle(FILE* rle_file) { char buffer[MAX_LINE_SIZE ]; // need to check if row is larger than expected so allocate larger buffer char* pos; int x = -1, y = -1; int i; int row = 0; int col = 0; int line = 0; int num_repeat; game* g = NULL; while (NULL != fgets(buffer, MAX_LINE_SIZE, rle_file)) { ++line; //Increment current line //printf("Inputting row: %d\n", row); if (buffer[0]=='#') { //Comments, ignore the line continue; } else if (buffer[0] == 'x') { //This is the special line declaring the size of the matrix sscanf(buffer, "x = %d, y = %d", &x, &y); if (x < 0 || y < 0) { fprintf(stderr, "Error reading RLE file.\n"); return NULL; } printf("x=%d, y=%d\n", x, y); g = new_game(y, x*2); //Extra space to the right continue; } pos = buffer; while ( (pos = scan_whitespace(pos)) && ('\0' != *pos) ) { //while we haven't hit the of the line, or gone outside bounds of 2D-array num_repeat = 1; //Number to repeat is 1 by default if (is_number(*pos)) { sscanf(pos, "%d", &num_repeat); //Get the number of times the next character repeats //printf("num_repeat: %d\n", num_repeat); pos = scan_number(pos); //Scan past the number } if (RLE_ENDROW == *pos) { //If we hit the end of row character, increment rows and go to next char for (i = 0; i < num_repeat; i++) { //Make a new row num_repeat times for ( ; col < x; col++) { //Implicitly the end of the row is all dead cells g->board[row][col] = DEAD; } col = 0; //Start at first column of the next row row++; } pos++; continue; } if (RLE_ALIVE == *pos) { for (i = 0; i < num_repeat; i++) { g->board[row][col++] = ALIVE; } pos++; } else if (RLE_DEAD == *pos) { for (i = 0; i < num_repeat; i++) { g->board[row][col++] = DEAD; } pos++; } else if (RLE_ENDFILE == *pos) { printf("RLE INPUT SUCCESSFULLY COMPLETED\n"); return g; } else { fprintf(stderr, "INVALID CHARACTER FOUND IN RLE FILE on line %d, col %d: %c\n", line, pos - buffer, *pos); return NULL; } } } return g; }
token_type getToken() { char c; if (active_token) { active_token = 0; return t_type; } skip_space(); token_length = 0; current_token[0] = '\0'; c = getchar(); switch (c) { case '.': t_type = DOT; return t_type; case '+': t_type = PLUS; return t_type; case '-': t_type = MINUS; return t_type; case '/': t_type = DIV; return t_type; case '*': t_type = MULT; return t_type; case '=': t_type = EQUAL; return t_type; case ':': t_type = COLON; return t_type; case ',': t_type = COMMA; return t_type; case ';': t_type = SEMICOLON; return t_type; case '[': t_type = LBRAC; return t_type; case ']': t_type = RBRAC; return t_type; case '(': t_type = LPAREN; return t_type; case ')': t_type = RPAREN; return t_type; case '<': c = getchar(); if (c == '=') { t_type = LTEQ; } else if (c == '>') { t_type = NOTEQUAL; } else { ungetc(c, stdin); t_type = LESS; } return t_type; case '>': c = getchar(); if (c == '=') { t_type = GTEQ; } else { ungetc(c, stdin); t_type = GREATER; } return t_type; default: if (isdigit(c)) { ungetc(c, stdin); t_type = scan_number(); } else if (isalpha(c)) // token is either keyword or ID { ungetc(c, stdin); t_type = scan_id_keyword(); } else if (c == EOF) { t_type = END_OF_FILE; } else { t_type = ERROR; } return t_type; } }
TSP *tsp_read_data(char *fname) { struct dsa _dsa, *dsa = &_dsa; TSP *tsp = NULL; dsa->fname = fname; xprintf("tsp_read_data: reading TSP data from `%s'...\n", dsa->fname); dsa->fp = fopen(dsa->fname, "r"); if (dsa->fp == NULL) { xprintf("tsp_read_data: unable to open `%s' - %s\n", dsa->fname, strerror(errno)); goto fail; } tsp = xmalloc(sizeof(TSP)); tsp->name = NULL; tsp->type = TSP_UNDEF; tsp->comment = NULL; tsp->dimension = 0; tsp->edge_weight_type = TSP_UNDEF; tsp->edge_weight_format = TSP_UNDEF; tsp->display_data_type = TSP_UNDEF; tsp->node_x_coord = NULL; tsp->node_y_coord = NULL; tsp->dply_x_coord = NULL; tsp->dply_y_coord = NULL; tsp->tour = NULL; tsp->edge_weight = NULL; dsa->seqn = 1; if (get_char(dsa)) goto fail; loop: if (scan_keyword(dsa)) goto fail; if (strcmp(dsa->token, "NAME") == 0) { if (tsp->name != NULL) { xprintf("%s:%d: NAME entry multiply defined\n", dsa->fname, dsa->seqn); goto fail; } if (check_colon(dsa)) goto fail; if (scan_token(dsa, 0)) goto fail; if (strlen(dsa->token) == 0) { xprintf("%s:%d: NAME entry incomplete\n", dsa->fname, dsa->seqn); goto fail; } tsp->name = xmalloc(strlen(dsa->token) + 1); strcpy(tsp->name, dsa->token); xprintf("tsp_read_data: NAME: %s\n", tsp->name); if (check_newline(dsa)) goto fail; } else if (strcmp(dsa->token, "TYPE") == 0) { if (tsp->type != TSP_UNDEF) { xprintf("%s:%d: TYPE entry multiply defined\n", dsa->fname, dsa->seqn); goto fail; } if (check_colon(dsa)) goto fail; if (scan_keyword(dsa)) goto fail; if (strcmp(dsa->token, "TSP") == 0) tsp->type = TSP_TSP; else if (strcmp(dsa->token, "ATSP") == 0) tsp->type = TSP_ATSP; else if (strcmp(dsa->token, "TOUR") == 0) tsp->type = TSP_TOUR; else { xprintf("%s:%d: data type `%s' not recognized\n", dsa->fname, dsa->seqn, dsa->token); goto fail; } xprintf("tsp_read_data: TYPE: %s\n", dsa->token); if (check_newline(dsa)) goto fail; } else if (strcmp(dsa->token, "COMMENT") == 0) { if (tsp->comment != NULL) { xprintf("%s:%d: COMMENT entry multiply defined\n", dsa->fname, dsa->seqn); goto fail; } if (check_colon(dsa)) goto fail; if (scan_comment(dsa)) goto fail; tsp->comment = xmalloc(strlen(dsa->token) + 1); strcpy(tsp->comment, dsa->token); xprintf("tsp_read_data: COMMENT: %s\n", tsp->comment); if (check_newline(dsa)) goto fail; } else if (strcmp(dsa->token, "DIMENSION") == 0) { if (tsp->dimension != 0) { xprintf("%s:%d: DIMENSION entry multiply defined\n", dsa->fname, dsa->seqn); goto fail; } if (check_colon(dsa)) goto fail; if (scan_integer(dsa, 0, &tsp->dimension)) goto fail; if (tsp->dimension < 1) { xprintf("%s:%d: invalid dimension\n", dsa->fname, dsa->seqn); goto fail; } xprintf("tsp_read_data: DIMENSION: %d\n", tsp->dimension); if (check_newline(dsa)) goto fail; } else if (strcmp(dsa->token, "EDGE_WEIGHT_TYPE") == 0) { if (tsp->edge_weight_type != TSP_UNDEF) { xprintf("%s:%d: EDGE_WEIGHT_TYPE entry multiply defined\n", dsa->fname, dsa->seqn); goto fail; } if (check_colon(dsa)) goto fail; if (scan_keyword(dsa)) goto fail; if (strcmp(dsa->token, "GEO") == 0) tsp->edge_weight_type = TSP_GEO; else if (strcmp(dsa->token, "EUC_2D") == 0) tsp->edge_weight_type = TSP_EUC_2D; else if (strcmp(dsa->token, "ATT") == 0) tsp->edge_weight_type = TSP_ATT; else if (strcmp(dsa->token, "EXPLICIT") == 0) tsp->edge_weight_type = TSP_EXPLICIT; else if (strcmp(dsa->token, "CEIL_2D") == 0) tsp->edge_weight_type = TSP_CEIL_2D; else { xprintf("%s:%d: edge weight type `%s' not recognized\n", dsa->fname, dsa->seqn, dsa->token); goto fail; } xprintf("tsp_read_data: EDGE_WEIGHT_TYPE: %s\n", dsa->token); if (check_newline(dsa)) goto fail; } else if (strcmp(dsa->token, "EDGE_WEIGHT_FORMAT") == 0) { if (tsp->edge_weight_format != TSP_UNDEF) { xprintf( "%s:%d: EDGE_WEIGHT_FORMAT entry multiply defined\n", dsa->fname, dsa->seqn); goto fail; } if (check_colon(dsa)) goto fail; if (scan_keyword(dsa)) goto fail; if (strcmp(dsa->token, "UPPER_ROW") == 0) tsp->edge_weight_format = TSP_UPPER_ROW; else if (strcmp(dsa->token, "FULL_MATRIX") == 0) tsp->edge_weight_format = TSP_FULL_MATRIX; else if (strcmp(dsa->token, "FUNCTION") == 0) tsp->edge_weight_format = TSP_FUNCTION; else if (strcmp(dsa->token, "LOWER_DIAG_ROW") == 0) tsp->edge_weight_format = TSP_LOWER_DIAG_ROW; else { xprintf("%s:%d: edge weight format `%s' not recognized\n", dsa->fname, dsa->seqn, dsa->token); goto fail; } xprintf("tsp_read_data: EDGE_WEIGHT_FORMAT: %s\n", dsa->token); if (check_newline(dsa)) goto fail; } else if (strcmp(dsa->token, "DISPLAY_DATA_TYPE") == 0) { if (tsp->display_data_type != TSP_UNDEF) { xprintf("%s:%d: DISPLAY_DATA_TYPE entry multiply defined\n", dsa->fname, dsa->seqn); goto fail; } if (check_colon(dsa)) goto fail; if (scan_keyword(dsa)) goto fail; if (strcmp(dsa->token, "COORD_DISPLAY") == 0) tsp->display_data_type = TSP_COORD_DISPLAY; else if (strcmp(dsa->token, "TWOD_DISPLAY") == 0) tsp->display_data_type = TSP_TWOD_DISPLAY; else { xprintf("%s:%d: display data type `%s' not recognized\n", dsa->fname, dsa->seqn, dsa->token); goto fail; } xprintf("tsp_read_data: DISPLAY_DATA_TYPE: %s\n", dsa->token); if (check_newline(dsa)) goto fail; } else if (strcmp(dsa->token, "NODE_COORD_SECTION") == 0) { int n = tsp->dimension, k, node; if (n == 0) { xprintf("%s:%d: DIMENSION entry not specified\n", dsa->fname, dsa->seqn); goto fail; } if (tsp->node_x_coord != NULL) { xprintf("%s:%d: NODE_COORD_SECTION multiply specified\n", dsa->fname, dsa->seqn); goto fail; } if (check_newline(dsa)) goto fail; tsp->node_x_coord = xcalloc(1+n, sizeof(double)); tsp->node_y_coord = xcalloc(1+n, sizeof(double)); for (node = 1; node <= n; node++) tsp->node_x_coord[node] = tsp->node_y_coord[node] = DBL_MAX; for (k = 1; k <= n; k++) { if (scan_integer(dsa, 0, &node)) goto fail; if (!(1 <= node && node <= n)) { xprintf("%s:%d: invalid node number %d\n", dsa->fname, dsa->seqn, node); goto fail; } if (tsp->node_x_coord[node] != DBL_MAX) { xprintf("%s:%d: node number %d multiply specified\n", dsa->fname, dsa->seqn, node); goto fail; } if (scan_number(dsa, 0, &tsp->node_x_coord[node])) goto fail; if (scan_number(dsa, 0, &tsp->node_y_coord[node])) goto fail; if (check_newline(dsa)) goto fail; } } else if (strcmp(dsa->token, "DISPLAY_DATA_SECTION") == 0) { int n = tsp->dimension, k, node; if (n == 0) { xprintf("%s:%d: DIMENSION entry not specified\n", dsa->fname, dsa->seqn); goto fail; } if (tsp->dply_x_coord != NULL) { xprintf("%s:%d: DISPLAY_DATA_SECTION multiply specified\n", dsa->fname, dsa->seqn); goto fail; } if (check_newline(dsa)) goto fail; tsp->dply_x_coord = xcalloc(1+n, sizeof(double)); tsp->dply_y_coord = xcalloc(1+n, sizeof(double)); for (node = 1; node <= n; node++) tsp->dply_x_coord[node] = tsp->dply_y_coord[node] = DBL_MAX; for (k = 1; k <= n; k++) { if (scan_integer(dsa, 0, &node)) goto fail; if (!(1 <= node && node <= n)) { xprintf("%s:%d: invalid node number %d\n", dsa->fname, dsa->seqn, node); goto fail; } if (tsp->dply_x_coord[node] != DBL_MAX) { xprintf("%s:%d: node number %d multiply specified\n", dsa->fname, dsa->seqn, node); goto fail; } if (scan_number(dsa, 0, &tsp->dply_x_coord[node])) goto fail; if (scan_number(dsa, 0, &tsp->dply_y_coord[node])) goto fail; if (check_newline(dsa)) goto fail; } } else if (strcmp(dsa->token, "TOUR_SECTION") == 0) { int n = tsp->dimension, k, node; if (n == 0) { xprintf("%s:%d: DIMENSION entry not specified\n", dsa->fname, dsa->seqn); goto fail; } if (tsp->tour != NULL) { xprintf("%s:%d: TOUR_SECTION multiply specified\n", dsa->fname, dsa->seqn); goto fail; } if (check_newline(dsa)) goto fail; tsp->tour = xcalloc(1+n, sizeof(int)); for (k = 1; k <= n; k++) { if (scan_integer(dsa, 1, &node)) goto fail; if (!(1 <= node && node <= n)) { xprintf("%s:%d: invalid node number %d\n", dsa->fname, dsa->seqn, node); goto fail; } tsp->tour[k] = node; } if (scan_integer(dsa, 1, &node)) goto fail; if (node != -1) { xprintf("%s:%d: extra node(s) detected\n", dsa->fname, dsa->seqn); goto fail; } if (check_newline(dsa)) goto fail; } else if (strcmp(dsa->token, "EDGE_WEIGHT_SECTION") == 0) { int n = tsp->dimension, i, j, temp; if (n == 0) { xprintf("%s:%d: DIMENSION entry not specified\n", dsa->fname, dsa->seqn); goto fail; } if (tsp->edge_weight_format == TSP_UNDEF) { xprintf("%s:%d: EDGE_WEIGHT_FORMAT entry not specified\n", dsa->fname, dsa->seqn); goto fail; } if (tsp->edge_weight != NULL) { xprintf("%s:%d: EDGE_WEIGHT_SECTION multiply specified\n", dsa->fname, dsa->seqn); goto fail; } if (check_newline(dsa)) goto fail; tsp->edge_weight = xcalloc(1+n*n, sizeof(int)); switch (tsp->edge_weight_format) { case TSP_FULL_MATRIX: for (i = 1; i <= n; i++) { for (j = 1; j <= n; j++) { if (scan_integer(dsa, 1, &temp)) goto fail; tsp->edge_weight[(i - 1) * n + j] = temp; } } break; case TSP_UPPER_ROW: for (i = 1; i <= n; i++) { tsp->edge_weight[(i - 1) * n + i] = 0; for (j = i + 1; j <= n; j++) { if (scan_integer(dsa, 1, &temp)) goto fail; tsp->edge_weight[(i - 1) * n + j] = temp; tsp->edge_weight[(j - 1) * n + i] = temp; } } break; case TSP_LOWER_DIAG_ROW: for (i = 1; i <= n; i++) { for (j = 1; j <= i; j++) { if (scan_integer(dsa, 1, &temp)) goto fail; tsp->edge_weight[(i - 1) * n + j] = temp; tsp->edge_weight[(j - 1) * n + i] = temp; } } break; default: goto fail; } if (check_newline(dsa)) goto fail; } else if (strcmp(dsa->token, "EOF") == 0) { if (check_newline(dsa)) goto fail; goto done; } else { xprintf("%s:%d: keyword `%s' not recognized\n", dsa->fname, dsa->seqn, dsa->token); goto fail; } goto loop; done: xprintf("tsp_read_data: %d lines were read\n", dsa->seqn-1); fclose(dsa->fp); return tsp; fail: if (tsp != NULL) { if (tsp->name != NULL) xfree(tsp->name); if (tsp->comment != NULL) xfree(tsp->comment); if (tsp->node_x_coord != NULL) xfree(tsp->node_x_coord); if (tsp->node_y_coord != NULL) xfree(tsp->node_y_coord); if (tsp->dply_x_coord != NULL) xfree(tsp->dply_x_coord); if (tsp->dply_y_coord != NULL) xfree(tsp->dply_y_coord); if (tsp->tour != NULL) xfree(tsp->tour); if (tsp->edge_weight != NULL) xfree(tsp->edge_weight); xfree(tsp); } if (dsa->fp != NULL) fclose(dsa->fp); return NULL; }
int stream_vscanf (stream_t *stream, const char *fmt, /* Format string for the scanf */ va_list argp) /* Arguments to scanf */ #endif { unsigned char ch, size; unsigned base; unsigned short len; int nmatch, ic; void *ptr; const char *pattern = 0; nmatch = 0; for (;;) switch (ch = FETCH_BYTE (fmt++)) { case '\0': return nmatch; case '%': ch = FETCH_BYTE (fmt++); if (ch == '%') goto def; if (ch != '*') ptr = va_arg (argp, void*); else { ptr = 0; ch = FETCH_BYTE (fmt++); } len = 0; size = REGULAR; while (ch >= '0' && ch <= '9') { len = len*10 + ch - '0'; ch = FETCH_BYTE (fmt++); } if (len == 0) len = 30000; if (ch == 'l') { ch = FETCH_BYTE (fmt++); size = LONG; } else if (ch == 'h') { size = SHORT; ch = FETCH_BYTE (fmt++); } else if (ch == '[') { pattern = fmt; ch = FETCH_BYTE (fmt); if (ch == '^') ch = FETCH_BYTE (++fmt); while (ch != 0 && ch != ']') ch = FETCH_BYTE (++fmt); if (ch != 0) ++fmt; ch = '['; } if (ch >= 'A' && ch <= 'Z') { ch = ch + 'a' - 'A'; size = LONG; } switch (ch) { case 0: return -1; case 'c': if (len == 30000) len = 1; goto string; case 's': case '[': string: if (scan_string (stream, (char*) ptr, ch, len, pattern) && ptr) ++nmatch; break; case 'o': base = 8 | snoUnsigned; goto number; case 'x': base = 16 | snoUnsigned; goto number; case 'd': base = 10; goto number; case 'u': base = 10 | snoUnsigned; number: if (scan_number (stream, ptr, base, len, size) && ptr) ++nmatch; break; } if (feof (stream)) return nmatch ? nmatch : -1; break; case ' ': case '\n': case '\t': /* Skip spaces. */ for (;;) { ic = peekchar (stream); if (ic < 0) break; if (! ISSPACE ((unsigned char) ic)) break; getchar (stream); } break; default: def: ic = peekchar (stream); if (ic < 0) return -1; if ((unsigned char) ic != ch) return nmatch; getchar (stream); }