void add_rom(const char *prefix, FILE *file) { int i; t_rom *rom = malloc(sizeof(t_rom)); rom->prefix = prefix; // Load ROM file eat_comment(file); fscanf(file, "%d %d\n", &(rom->words_defined), &(rom->word_size)); rom->data = malloc(rom->words_defined * sizeof(t_value)); for (i = 0; i < rom->words_defined; i++) { eat_comment(file); if (fscanf(file, "/%lu", &(rom->data[i]))) { // ok, value is read } else if (fscanf(file, "x%lx", &(rom->data[i]))) { // ok, value is read } else { rom->data[i] = read_bool(file, NULL); } } rom->next = roms; roms = rom; }
void scan_init(const char *cmdline_program) { if (cmdline_program) { program_fd = -1; /* command line program */ program_string = new_STRING0(strlen(cmdline_program) + 1); strcpy(program_string->str, cmdline_program); /* simulate file termination */ program_string->str[program_string->len - 1] = '\n'; buffp = (UChar *) program_string->str; eof_flag = 1; } else { /* program from file[s] */ scan_open(); buffp = buffer = (UChar *) zmalloc((size_t) (BUFFSZ + 1)); scan_fillbuff(); } #ifdef OS2 /* OS/2 "extproc" is similar to #! */ if (strnicmp(buffp, "extproc ", 8) == 0) eat_comment(); #endif eat_nl(); /* scan to first token */ if (next() == 0) { /* no program */ mawk_exit(0); } un_next(); }
/* * Scan a section name and remember it in `cursec'. */ static void parse_section(FILE *fp) { int c, i, end; /* We've already got the '['. Scan past initial white space. */ c = eat_whitespace(fp); i = 0; end = 0; while (c > 0) { if (i > (bsize-2)) { bsize += 1024; bufr = realloc(bufr, bsize); if (! bufr) { fprintf(stderr, "%s: malloc failed\n", confname); exit(-1); } } switch (c) { case ']': /* found the closing bracked */ bufr[end] = '\0'; if (end == 0) { fprintf(stderr, "%s: empty section name\n", confname); exit(-1); } /* Register a section. */ if (cursec) free(cursec); cursec = strdup(bufr); eat_comment(fp); return; case '\n': i = find_continuation(bufr, i); if (i < 0) { bufr [end] = 0; fprintf(stderr, "%s: invalid line: '%s'\n", confname, bufr); exit(-1); } end = ((i > 0) && (bufr[i-1] == ' ')) ? (i-1) : (i); c = getc(fp); break; default: if (isspace(c)) { bufr[end] = ' '; i = end + 1; c = eat_whitespace(fp); } else { bufr[i++] = c; end = i; c = getc(fp); } break; } } }
void eat_nl(void) /* eat all space including newlines */ { while (1) { switch (scan_code[(UChar) next()]) { case SC_COMMENT: eat_comment(); break; case SC_NL: lineno++; /* FALLTHRU */ case SC_SPACE: break; case SC_ESCAPE: /* bug fix - surprised anyone did this, a csh user with backslash dyslexia.(Not a joke) */ { int c; while (scan_code[NextUChar(c)] == SC_SPACE) { ; /* empty */ } if (c == '\n') token_lineno = ++lineno; else if (c == 0) { un_next(); return; } else { /* error */ un_next(); /* can't un_next() twice so deal with it */ yylval.ival = '\\'; unexpected_char(); if (++compile_error_count == MAX_COMPILE_ERRORS) mawk_exit(2); return; } } break; default: un_next(); return; } } }
void Image::load(const std::string& filename) { std::ifstream ifs(filename.c_str(), std::ios::binary); // check if file exists if (!ifs.is_open()) { std::cout << "Error: Unable to open file \"" << filename << "\"" << std::endl; return; } // we got file std::cout << "Reading file header of \"" << filename << "\"" << std::endl; eat_comment(ifs); // read and evaluate magic number std::string magic_number; ifs >> magic_number; ANYMAP map = PPM; bool ascii = false; if (magic_number.compare("P1") == 0) { // P1 = PBM in ASCII map = PBM; ascii = true; } else if (magic_number.compare("P2") == 0) { // P2 = PGM in ASCII map = PGM; ascii = true; } else if (magic_number.compare("P3") == 0) { // P3 = PPM in ASCII map = PPM; ascii = true; } else if (magic_number.compare("P4") == 0) { // P4 = PBM in binary map = PBM; ascii = false; } else if (magic_number.compare("P5") == 0) { // P5 = PGM in binary map = PGM; ascii = false; } else if (magic_number.compare("P6") == 0) { // P6 = PPM in binary map = PPM; ascii = false; } else { std::cout << "Error, Magic number doesn't fit in anymap format!" << std::endl; ifs.close(); return; } // read width and height int width = 1, height = 1; eat_comment(ifs); ifs >> width; eat_comment(ifs); ifs >> height; // let's hope size is not smaller than 1 if (width < 1 || height < 1) { std::cout << "Error: Unsupported size " << width << "/" << height << std::endl; ifs.close(); return; } // read color depth if not PBM int color_depth = 1; if (magic_number.compare("P1") != 0 && magic_number.compare("P4") != 0) { eat_comment(ifs); ifs >> color_depth; if (color_depth < 1 || color_depth > 255) { std::cout << "Error: Unsupported color depth " << color_depth << std::endl; ifs.close(); return; } }
int yylex(void) { register int c; token_lineno = lineno; #ifdef NO_LEAKS memset(&yylval, 0, sizeof(yylval)); #endif reswitch: switch (scan_code[NextUChar(c)]) { case 0: ct_ret(EOF); case SC_SPACE: goto reswitch; case SC_COMMENT: eat_comment(); goto reswitch; case SC_NL: lineno++; eat_nl(); ct_ret(NL); case SC_ESCAPE: while (scan_code[NextUChar(c)] == SC_SPACE) { ; /* empty */ }; if (c == '\n') { token_lineno = ++lineno; goto reswitch; } if (c == 0) ct_ret(EOF); un_next(); yylval.ival = '\\'; ct_ret(UNEXPECTED); case SC_SEMI_COLON: eat_nl(); ct_ret(SEMI_COLON); case SC_LBRACE: eat_nl(); brace_cnt++; ct_ret(LBRACE); case SC_PLUS: switch (next()) { case '+': yylval.ival = '+'; string_buff[0] = string_buff[1] = '+'; string_buff[2] = 0; ct_ret(INC_or_DEC); case '=': ct_ret(ADD_ASG); default: un_next(); ct_ret(PLUS); } case SC_MINUS: switch (next()) { case '-': yylval.ival = '-'; string_buff[0] = string_buff[1] = '-'; string_buff[2] = 0; ct_ret(INC_or_DEC); case '=': ct_ret(SUB_ASG); default: un_next(); ct_ret(MINUS); } case SC_COMMA: eat_nl(); ct_ret(COMMA); case SC_MUL: test1_ret('=', MUL_ASG, MUL); case SC_DIV: { static const int can_precede_div[] = {DOUBLE, STRING_, RPAREN, ID, D_ID, RE, RBOX, FIELD, GETLINE, INC_or_DEC, -1}; const int *p = can_precede_div; do { if (*p == current_token) { if (*p != INC_or_DEC) { test1_ret('=', DIV_ASG, DIV); } if (next() == '=') { un_next(); ct_ret(collect_RE()); } } } while (*++p != -1); ct_ret(collect_RE()); } case SC_MOD: test1_ret('=', MOD_ASG, MOD); case SC_POW: test1_ret('=', POW_ASG, POW); case SC_LPAREN: paren_cnt++; ct_ret(LPAREN); case SC_RPAREN: if (--paren_cnt < 0) { compile_error("extra ')'"); paren_cnt = 0; goto reswitch; } ct_ret(RPAREN); case SC_LBOX: ct_ret(LBOX); case SC_RBOX: ct_ret(RBOX); case SC_MATCH: string_buff[1] = '~'; string_buff[0] = 0; yylval.ival = 1; ct_ret(MATCH); case SC_EQUAL: test1_ret('=', EQ, ASSIGN); case SC_NOT: /* ! */ if ((c = next()) == '~') { string_buff[0] = '!'; string_buff[1] = '~'; string_buff[2] = 0; yylval.ival = 0; ct_ret(MATCH); } else if (c == '=') ct_ret(NEQ); un_next(); ct_ret(NOT); case SC_LT: /* '<' */ if (next() == '=') ct_ret(LTE); else un_next(); if (getline_flag) { getline_flag = 0; ct_ret(IO_IN); } else ct_ret(LT); case SC_GT: /* '>' */ if (print_flag && paren_cnt == 0) { print_flag = 0; /* there are 3 types of IO_OUT -- build the error string in string_buff */ string_buff[0] = '>'; if (next() == '>') { yylval.ival = F_APPEND; string_buff[1] = '>'; string_buff[2] = 0; } else { un_next(); yylval.ival = F_TRUNC; string_buff[1] = 0; } return current_token = IO_OUT; } test1_ret('=', GTE, GT); case SC_OR: if (next() == '|') { eat_nl(); ct_ret(OR); } else { un_next(); if (print_flag && paren_cnt == 0) { print_flag = 0; yylval.ival = PIPE_OUT; string_buff[0] = '|'; string_buff[1] = 0; ct_ret(IO_OUT); } else ct_ret(PIPE); } case SC_AND: if (next() == '&') { eat_nl(); ct_ret(AND); } else { un_next(); yylval.ival = '&'; ct_ret(UNEXPECTED); } case SC_QMARK: ct_ret(QMARK); case SC_COLON: ct_ret(COLON); case SC_RBRACE: if (--brace_cnt < 0) { compile_error("extra '}'"); eat_semi_colon(); brace_cnt = 0; goto reswitch; } if ((c = current_token) == NL || c == SEMI_COLON || c == SC_FAKE_SEMI_COLON || c == RBRACE) { /* if the brace_cnt is zero , we've completed a pattern action block. If the user insists on adding a semi-colon on the same line we will eat it. Note what we do below: physical law -- conservation of semi-colons */ if (brace_cnt == 0) eat_semi_colon(); eat_nl(); ct_ret(RBRACE); } /* supply missing semi-colon to statement that precedes a '}' */ brace_cnt++; un_next(); current_token = SC_FAKE_SEMI_COLON; return SEMI_COLON; case SC_DIGIT: case SC_DOT: { double d; int flag; if ((d = collect_decimal(c, &flag)) == 0.0) { if (flag) ct_ret(flag); else yylval.ptr = (PTR) & double_zero; } else if (d == 1.0) { yylval.ptr = (PTR) & double_one; } else { yylval.ptr = (PTR) ZMALLOC(double); *(double *) yylval.ptr = d; } ct_ret(DOUBLE); } case SC_DOLLAR: /* '$' */ { double d; int flag; while (scan_code[NextUChar(c)] == SC_SPACE) { ; /* empty */ }; if (scan_code[c] != SC_DIGIT && scan_code[c] != SC_DOT) { un_next(); ct_ret(DOLLAR); } /* compute field address at compile time */ if ((d = collect_decimal(c, &flag)) <= 0.0) { if (flag) ct_ret(flag); /* an error */ else yylval.cp = &field[0]; } else { int ival = d_to_I(d); double dval = (double) ival; if (dval != d) { compile_error("$%g is invalid field index", d); } yylval.cp = field_ptr(ival); } ct_ret(FIELD); } case SC_DQUOTE: return current_token = collect_string(); case SC_IDCHAR: /* collect an identifier */ { char *p = string_buff + 1; SYMTAB *stp; string_buff[0] = (char) c; while (1) { CheckStringSize(p); c = scan_code[NextUChar(*p++)]; if (c != SC_IDCHAR && c != SC_DIGIT) break; } un_next(); *--p = 0; switch ((stp = find(string_buff))->type) { case ST_NONE: /* check for function call before defined */ if (next() == '(') { stp->type = ST_FUNCT; stp->stval.fbp = (FBLOCK *) zmalloc(sizeof(FBLOCK)); stp->stval.fbp->name = stp->name; stp->stval.fbp->code = (INST *) 0; stp->stval.fbp->size = 0; yylval.fbp = stp->stval.fbp; current_token = FUNCT_ID; } else { yylval.stp = stp; current_token = current_token == DOLLAR ? D_ID : ID; } un_next(); break; case ST_NR: NR_flag = 1; stp->type = ST_VAR; /* FALLTHRU */ case ST_VAR: case ST_ARRAY: case ST_LOCAL_NONE: case ST_LOCAL_VAR: case ST_LOCAL_ARRAY: yylval.stp = stp; current_token = current_token == DOLLAR ? D_ID : ID; break; case ST_ENV: stp->type = ST_ARRAY; stp->stval.array = new_ARRAY(); load_environ(stp->stval.array); yylval.stp = stp; current_token = current_token == DOLLAR ? D_ID : ID; break; case ST_FUNCT: yylval.fbp = stp->stval.fbp; current_token = FUNCT_ID; break; case ST_KEYWORD: current_token = stp->stval.kw; break; case ST_BUILTIN: yylval.bip = stp->stval.bip; current_token = BUILTIN; break; case ST_LENGTH: yylval.bip = stp->stval.bip; /* check for length alone, this is an ugly hack */ while (scan_code[NextUChar(c)] == SC_SPACE) { ; /* empty */ }; un_next(); current_token = c == '(' ? BUILTIN : LENGTH; break; case ST_FIELD: yylval.cp = stp->stval.cp; current_token = FIELD; break; default: bozo("find returned bad st type"); } return current_token; } case SC_UNEXPECTED: yylval.ival = c & 0xff; ct_ret(UNEXPECTED); } return 0; /* never get here make lint happy */ }
/* * Scan a parameter name (or name and value pair) and pass the value (or * values) to function pfunc(). */ static void parse_parameter(FILE *fp, void (*pfunc)(char*, char*, char*), int c) { int i = 0; /* position withing bufr */ int end = 0; /* bufr[end] is current end-of-string */ int vstart = 0; /* starting position of the parameter */ /* Loop until we found the start of the value */ while (vstart == 0) { /* Ensure there's space for next char */ if (i > (bsize-2)) { bsize += 1024; bufr = realloc(bufr, bsize); if (! bufr) { fprintf(stderr, "%s: malloc failed\n", confname); exit(-1); } } switch (c) { case '=': if (end == 0) { fprintf(stderr, "%s: invalid parameter name\n", confname); exit(-1); } bufr[end++] = '\0'; i = end; vstart = end; bufr[i] = '\0'; break; case ';': /* comment line */ case '#': c = eat_comment(fp); case '\n': i = find_continuation(bufr, i); if (i < 0) { /* End of line, but no assignment symbol. */ bufr[end]='\0'; fprintf(stderr, "%s: bad line, ignored: `%s'\n", confname, bufr); return; } end = ((i > 0) && (bufr[i-1] == ' ')) ? (i-1) : (i); c = getc(fp); break; case '\0': case EOF: bufr[i] = '\0'; fprintf(stderr, "%s: unexpected end-of-file at %s: func\n", confname, bufr); exit(-1); default: if (isspace(c)) { bufr[end] = ' '; i = end + 1; c = eat_whitespace(fp); } else { bufr[i++] = c; end = i; c = getc(fp); } break; } } /* Now parse the value */ c = eat_whitespace(fp); while (c > 0) { if (i > (bsize-2)) { bsize += 1024; bufr = realloc(bufr, bsize); if (! bufr) { fprintf(stderr, "%s: malloc failed\n", confname); exit(-1); } } switch(c) { case '\r': c = getc(fp); break; case ';': /* comment line */ case '#': c = eat_comment(fp); case '\n': i = find_continuation(bufr, i); if (i < 0) c = 0; else { for (end=i; (end >= 0) && isspace(bufr[end]); end--) ; c = getc(fp); } break; default: bufr[i++] = c; if (! isspace(c)) end = i; c = getc(fp); break; } } bufr[end] = '\0'; pfunc(cursec, bufr, &bufr [vstart]); }
/* * Read configuration file and setup target parameters. */ void target_configure() { FILE *fp; int c; /* * Find the configuration file, if any. * (1) First, try a path from PIC32PROG_CONF_FILE environment variable. * (2) Otherwise, look for a file in the local directory. * (3) Otherwise, use /usr/local/etc/ directory (on Unix) * or a directory where pic32prog.exe resides (on Windows) */ confname = getenv("PIC32PROG_CONF_FILE"); if (! confname) confname = "pic32prog.conf"; if (access(confname, 0) < 0) { #if defined(__CYGWIN32__) || defined(MINGW32) char *p = strrchr(progname, '\\'); if (p) { char *buf = malloc(p - progname + 16); if (! buf) { fprintf(stderr, "%s: out of memory\n", progname); exit(-1); } strncpy(buf, progname, p - progname); strcpy(buf + (p - progname), "\\pic32prog.conf"); confname = buf; } else confname = "c:\\pic32prog.conf"; #else confname = "/usr/local/etc/pic32prog.conf"; #endif } fp = fopen(confname, "r"); if (! fp) { /* No config file available: that's OK. */ return; } bsize = 1024; bufr = (char*) malloc(bsize); if (! bufr) { fprintf(stderr, "%s: malloc failed\n", confname); fclose(fp); exit(-1); } /* Parse file. */ c = eat_whitespace(fp); while (c > 0) { switch (c) { case '\n': /* blank line */ c = eat_whitespace(fp); break; case ';': /* comment line */ case '#': c = eat_comment(fp); break; case '[': /* section header */ parse_section(fp); c = eat_whitespace(fp); break; case '\\': /* bogus backslash */ c = eat_whitespace(fp); break; default: /* parameter line */ parse_parameter(fp, configure_parameter, c); c = eat_whitespace(fp); break; } } configure_parameter("", 0, 0); /* Final call: end of file. */ fclose(fp); if (cursec) { free(cursec); cursec = 0; } free(bufr); bufr = 0; bsize = 0; }