static void macrobody(struct sbuf *sbuf, char *end) { int first = 1; int c; char *req = NULL; cp_back('\n'); cp_copymode(1); while ((c = cp_next()) >= 0) { if (sbuf && !first) sbuf_add(sbuf, c); first = 0; if (c == '\n') { if ((c = cp_next()) != c_cc) { cp_back(c); continue; } req = read_name(n_cp); if (!strcmp(end, req)) { in_push(end, NULL); cp_back(c_cc); break; } if (sbuf) { sbuf_add(sbuf, c_cc); sbuf_append(sbuf, req); } free(req); req = NULL; } } free(req); cp_copymode(0); }
// Search the array of phone records for a number void search_records(PhoneRecord records[], size_t count) { Name name; char answer = 'n'; do { name = read_name(); int index = 0; bool first = true; while((index = find_record(records, index, count, &name)) >= 0) { if(first) { printf_s("The numbers for %s %s are:\n", name.firstname, name.secondname); first = false; } printf_s("%s\n", records[index++].number); if(index >= count) break; } if(first) printf_s("No numbers found for %s %s.\n", name.firstname, name.secondname); printf_s("\nDo you want to search for another name (y or n)? "); scanf_s(" %c" , &answer, sizeof(answer)); }while(tolower(answer) == 'y'); }
struct t_command* read_command( FILE* f ) { char *name = NULL; int value = 0; char *value_str = NULL; struct t_command *command = malloc( sizeof(struct t_command) ); name = read_name( f ); command->name = name; // printf("\nNome: '%s'\n", name); read_equal( f ); value = read_value( f ); if ( value == -1 ) { /* Value is a string */ value_str = read_string( f ); // printf("Stringa('%s')\n", value_str ); command->value_str = value_str; command->type = STRING; } else { // printf("Value: %u\n", value ); command->value_num = value; command->type = NUMERIC; } return command; }
static int read_names(xmlNode *entry_node, display_name_t **dst) { xmlNode *n; display_name_t *name, *last; int res = 0; last = NULL; *dst = NULL; n = entry_node->children; while (n) { if (n->type == XML_ELEMENT_NODE) { if (cmp_node(n, "display-name", rl_namespace) >= 0) { res = read_name(n, &name); if (res == 0) { if (name) { SEQUENCE_ADD((*dst), last, name); name = NULL; } } else break; } } n = n->next; } return res; }
/* read arguments for .nr */ static void mkargs_reg1(struct sbuf *sbuf) { char *s = read_name(n_cp); sbuf_append(sbuf, s); sbuf_add(sbuf, 0); free(s); mkargs_req(sbuf); }
/* read arguments for .ochar */ static void mkargs_ochar(struct sbuf *sbuf) { char *s = read_name(0); sbuf_append(sbuf, s); sbuf_add(sbuf, 0); free(s); mkargs_ds(sbuf); }
/* read the next troff request; return zero if a request was executed. */ int tr_nextreq(void) { char *mac; char *arg0 = NULL; int c; if (!tr_nl) return 1; c = cp_next(); /* transparent line indicator */ if (c == c_ec) { int c2 = cp_next(); if (c2 == '!') { char *args[NARGS + 3] = {"\\!"}; struct sbuf sbuf; sbuf_init(&sbuf); cp_copymode(1); mkargs_eol(&sbuf); cp_copymode(0); chopargs(&sbuf, args + 1); tr_transparent(args); sbuf_done(&sbuf); return 0; } cp_back(c2); } /* not a request, a blank line, or a line with leading spaces */ if (c < 0 || (c != c_cc && c != c_c2 && (c != '\n' || tr_bm < 0) && (c != ' ' || tr_sm < 0))) { cp_back(c); return 1; } cp_reqbeg(); if (c == '\n') { /* blank line macro */ mac = malloc(strlen(map_name(tr_bm)) + 1); strcpy(mac, map_name(tr_bm)); arg0 = dotted(mac, '.'); tr_nextreq_exec(mac, arg0, 0); } else if (c == ' ') { /* leading space macro */ int i; mac = malloc(strlen(map_name(tr_sm)) + 1); strcpy(mac, map_name(tr_sm)); for (i = 0; c == ' '; i++) c = cp_next(); cp_back(c); n_lsn = i; arg0 = dotted(mac, '.'); tr_nextreq_exec(mac, arg0, 0); } else { mac = read_name(n_cp); arg0 = dotted(mac, c); tr_nextreq_exec(mac, arg0, 1); } free(arg0); free(mac); return 0; }
AST_expr* readASTExpr(BufferedReader* reader) { uint8_t type = reader->readByte(); if (VERBOSITY("parsing") >= 2) printf("type = %d\n", type); if (type == 0) return NULL; uint8_t checkbyte = reader->readByte(); assert(checkbyte == 0xae); switch (type) { case AST_TYPE::Attribute: return read_attribute(reader); case AST_TYPE::BinOp: return read_binop(reader); case AST_TYPE::BoolOp: return read_boolop(reader); case AST_TYPE::Call: return read_call(reader); case AST_TYPE::Compare: return read_compare(reader); case AST_TYPE::Dict: return read_dict(reader); case AST_TYPE::DictComp: return read_dictcomp(reader); case AST_TYPE::IfExp: return read_ifexp(reader); case AST_TYPE::Index: return read_index(reader); case AST_TYPE::Lambda: return read_lambda(reader); case AST_TYPE::List: return read_list(reader); case AST_TYPE::ListComp: return read_listcomp(reader); case AST_TYPE::Name: return read_name(reader); case AST_TYPE::Num: return read_num(reader); case AST_TYPE::Repr: return read_repr(reader); case AST_TYPE::Slice: return read_slice(reader); case AST_TYPE::Str: return read_str(reader); case AST_TYPE::Subscript: return read_subscript(reader); case AST_TYPE::Tuple: return read_tuple(reader); case AST_TYPE::UnaryOp: return read_unaryop(reader); default: fprintf(stderr, "Unknown expr node type (parser.cpp:" STRINGIFY(__LINE__) "): %d\n", type); abort(); break; } }
void read_names() { FILE * fp; fp = fopen("../names_table.txt", "r"); if (fp == NULL) exit(EXIT_FAILURE); while (!feof(fp)) { read_name(fp); } fclose(fp); names = inverse_node(names, NULL); }
/* read arguments for .ds and .char */ static void mkargs_ds(struct sbuf *sbuf) { char *s = read_name(n_cp); sbuf_append(sbuf, s); sbuf_add(sbuf, 0); free(s); s = read_string(); if (s) { sbuf_append(sbuf, s); sbuf_add(sbuf, 0); free(s); } jmp_eol(); }
// Function to read an arbitrary number of phone records from the keyboard size_t get_records(PhoneRecord records[], size_t size) { size_t count = 0; char answer = 'y'; do { records[count].name = read_name(); // Read the name printf_s("Enter the number for this name: "); scanf_s(" %[ 0123456789]",records[count++].number, (rsize_t)NUMBER_LEN); // Read the number - including spaces printf_s("Do you want to enter another(y or n)?: "); scanf_s(" %c", &answer, sizeof(answer)); }while(count <= size && tolower(answer) == 'y'); return count; }
/* * dump_name - dump length-prefixed name, align to n-byte boundary * return number of bytes read */ static int dump_name( bool align ) /********************************/ { char name[256]; unsigned len, pad = 0; len = read_name( name ) + 1; Wdputs( name ); if( align ) { pad = align - (len & (align - 1)); } if( pad ) { lseek( Handle, pad, SEEK_CUR ); } return( len + pad + 1 ); }
/* reads in a name from stdin and returns the collection associated with it returns NULL and throws an error if there wasn't any collection by that name */ static void* find_collection_by_name( struct Ordered_container* catalog ) { char name[ NAME_ARRAY_SIZE ]; void* node; read_name( name ); node = OC_find_item_arg( catalog, name, comp_Collection_to_name ); if ( node == NULL ) { print_error( "No collection with that name!\n" ); } return node; }
void Squad::read_data() { if (!m_df || !m_df->memory_layout() || !m_df->memory_layout()->is_valid()) { LOGW << "refresh of squad called but we're not connected"; return; } // make sure our reference is up to date to the active memory layout m_mem = m_df->memory_layout(); TRACE << "Starting refresh of squad data at" << hexify(m_address); //qDeleteAll(m_members); m_members.clear(); read_id(); read_name(); read_members(); }
int main(int argc, char const *argv[]) { struct name myName = {0, 0, 0}; read_name(&myName); printf("status %s\n", myName.status); int i = 0; for (i; i <= myName.count; i++) { printf("%s\n",myName.tok[i]); } return 0; }
static void add_coll( struct Ordered_container* catalog ) { struct Collection* new_coll; char name[ NAME_ARRAY_SIZE ]; read_name( name ); if ( OC_find_item_arg( catalog, name, comp_Collection_to_name ) != NULL ) { print_error( "Catalog already has a collection with this name!\n" ); return; } new_coll = create_Collection( name ); OC_insert( catalog, new_coll ); printf("Collection %s added\n", name ); }
action read_action(deserializer & d) { action_kind k = static_cast<action_kind>(d.read_char()); unsigned rbp; switch (k) { case action_kind::Skip: return notation::mk_skip_action(); case action_kind::Binder: d >> rbp; return notation::mk_binder_action(rbp); case action_kind::Binders: d >> rbp; return notation::mk_binders_action(rbp); case action_kind::Expr: d >> rbp; return notation::mk_expr_action(rbp); case action_kind::Exprs: { name sep; expr rec; optional<expr> ini; bool is_fold_right; d >> sep >> rec; if (d.read_bool()) { ini = read_expr(d); } d >> is_fold_right >> rbp; optional<name> terminator; if (d.read_bool()) terminator = read_name(d); return notation::mk_exprs_action(sep, rec, ini, terminator, is_fold_right, rbp); } case action_kind::ScopedExpr: { expr rec; bool use_lambda_abstraction; d >> rec >> rbp >> use_lambda_abstraction; return notation::mk_scoped_expr_action(rec, rbp, use_lambda_abstraction); } case action_kind::LuaExt: return notation::mk_ext_lua_action(d.read_string().c_str()); case action_kind::Ext: break; } lean_unreachable(); }
void reading (char name_file_case[SIZE_NAME_FILE]) { FILE *file_message, *file_case; exist_file_check(name_file_case); file_case= fopen (name_file_case, "r"); if (file_case == NULL) { std::cerr << "Error opening of file. " << std::endl; exit(1); } read_title(file_case); int size = read_int(file_case); if (size > (SIZE_NAME_FILE)) { std::cerr << "Error reading. File was corrupted. " << std::endl; exit(1); } std::string name_file_message = read_name(size, file_case); file_message = fopen (name_file_message.c_str(), "w+b"); if (file_message == NULL) { std::cerr << "Error opening of file. " << std::endl; exit(1); } size = read_int(file_case); check_size_of_files_reading(file_case, size); read_data(size, file_case, file_message); fclose (file_message); fclose (file_case); }
void init_manager(void) { #ifdef DEBUG printf(DEBUG_ACTIVATED); #endif _GemParBlk.global[0]=0; ap_id = appl_init(); if (!_GemParBlk.global[0]) exit(0); if (ap_id < 0) exit(0); if (!_app) wind_update(BEG_UPDATE); Pdomain(1); check_cookies(); if (_GemParBlk.global[1] != 1) multitask = 1; if ((_GemParBlk.global[0] >= 0x0400) && (multitask)) multitos = 1; allocmode = GLOBAL; if (_app) allocmode |= 3; read_name(); check_info(); if ((!_app) || ((multitos) && (!magix))) { menu_id = menu_register(ap_id,STRING_MENUENTRY); if (menu_id < 0) { if (!_app) wind_update(END_UPDATE); if (multitos) { appl_exit(); exit(0); } else { while (1) evnt_timer(0,1); } } } find_inf(); if (!_app) wind_update(END_UPDATE); Psignal(SIGTERM,sig_handler); Psignal(SIGQUIT,sig_handler); if (!multitask) { char s[256]; strcpy(s,"[0][OLGA v"); strcat(s,OLGAVERSIONSTR); strcat(s," Rev "); strcat(s,OLGAREVISION); strcat(s," ("); strcat(s,OLGADATE); strcat(s,") | |"); strcat(s,MESSAGE_MULTITASKING); form_alert(1,s); if (_app) { #ifdef DEBUG printf(DEBUG_DEACTIVATED); #endif appl_exit(); exit(0); } } if (shutdown) shel_write(9,1,0,NULL,NULL); broadcast_olenew(); }
Token* Scanner::get_token() { Token* t; if (tokens) { t = tokens->token; tokens = tokens->prev; } else { t = NULL; while (t == NULL) { fint c = get_char(); switch (c) { case EOF: depth = 0; t = new Token(Token::ACCEPT, line, column, sourceAddr()); break; case '\n': case '\r': if (depth <= 0 && !is_string_scanner()) { t = new Token(Token::ACCEPT, line, column - 1, sourceAddr() - 1); depth = 0; } break; case ' ': case '\t': case '\v': case '\b': case '\f': break; case '"': t = skip_comment(); break; case '(': depth ++; t = new Token(as_TokenType('('), line, column - 1, sourceAddr() - 1); break; case ')': depth --; t = new Token(as_TokenType(')'), line, column - 1, sourceAddr() - 1); break; case '[': depth ++; t = new Token(as_TokenType('['), line, column - 1, sourceAddr() - 1); break; case ']': depth --; t = new Token(as_TokenType(']'), line, column - 1, sourceAddr() - 1); break; case '.': t = read_dot(); break; case '\'': t = read_string(); break; case '\\': c = get_char(); if (c == '\n' || c == '\r') { // an escaped newline; ignore } else { push_char(c); c = '\\'; t = read_op(c); } break; case '{': t = new Token(Token::ANNOTATION_START, line, column - 1, sourceAddr() - 1); break; case '}': t = new Token(Token::ANNOTATION_END, line, column - 1, sourceAddr() - 1); break; default: if (is_digit(c) || c == '-') t = read_number(c); else if (is_id_alpha(c) || c == ':') t = read_name(c); else if (is_punct(c)) t = read_op(c); else t = TokenizingError("unknown character in input"); } } } if (t && PrintTokens) t->print(); return t; }
int read_elf(char *filename, struct _memory *memory, uint8_t *cpu_type, struct _symbols *symbols) { FILE *in; uint8_t e_ident[16]; int e_shoff; int e_shentsize; int e_shnum; int e_shstrndx; int n; int start, end; struct _elf32_shdr elf32_shdr; long strtab_offset = 0; get_int16_t get_int16; get_int32_t get_int32; memory_clear(memory); //memset(dirty, 0, memory->size); start = -1; end = -1; in = fopen(filename, "rb"); if (in == 0) { return -1; } memset(e_ident, 0, 16); n = fread(e_ident, 1, 16, in); if (e_ident[0] != 0x7f || e_ident[1] != 'E' || e_ident[2] != 'L' || e_ident[3] != 'F') { //printf("Not an ELF file.\n"); fclose(in); return -2; } #define EI_CLASS 4 // 1=32 bit, 2=64 bit #define EI_DATA 5 // 1=little endian, 2=big endian #define EI_OSABI 7 // 0=SysV, 255=Embedded if (e_ident[EI_CLASS] != 1) // let's let other stuff in || e_ident[7]!=0xff) { printf("ELF Error: e_ident shows incorrect type\n"); fclose(in); return -1; } // EI_DATA if (e_ident[EI_DATA] == 1) { memory->endian = ENDIAN_LITTLE; get_int16 = get_int16_le; get_int32 = get_int32_le; } else if (e_ident[EI_DATA] == 2) { memory->endian = ENDIAN_BIG; get_int16 = get_int16_be; get_int32 = get_int32_be; } else { printf("ELF Error: EI_DATA incorrect data encoding\n"); fclose(in); return -1; } get_int16(in); n = get_int16(in); switch(n) { case 8: case 10: *cpu_type = CPU_TYPE_MIPS; break; case 40: *cpu_type = CPU_TYPE_ARM; break; case 83: *cpu_type = CPU_TYPE_AVR8; break; case 105: *cpu_type = CPU_TYPE_MSP430; break; case 118: *cpu_type = CPU_TYPE_DSPIC; break; default: printf("ELF Error: e_machine unknown\n"); fclose(in); return -1; } fseek(in, 32, SEEK_SET); e_shoff = get_int32(in); fseek(in, 46, SEEK_SET); e_shentsize = get_int16(in); e_shnum = get_int16(in); e_shstrndx = get_int16(in); //printf("e_shoff=%d\n", e_shoff); //printf("e_shentsize=%d\n", e_shentsize); //printf("e_shnum=%d\n", e_shnum); //printf("e_shstrndx=%d\n", e_shstrndx); fseek(in, e_shoff + (e_shstrndx * e_shentsize) + 16, SEEK_SET); int stroffset = get_int32(in); char name[32]; // Need to find .strtab so we can fill in symbol names for (n = 0; n < e_shnum; n++) { fseek(in, e_shoff + (n * e_shentsize), SEEK_SET); read_shdr(in, &elf32_shdr, get_int32); if (elf32_shdr.sh_type == SHT_STRTAB) { read_name(in, name, 32, stroffset + elf32_shdr.sh_name); if (strcmp(name, ".strtab") == 0) { strtab_offset = elf32_shdr.sh_offset; break; } } } for (n = 0; n < e_shnum; n++) { // FIXME - a little inefficient eh? fseek(in, e_shoff + (n * e_shentsize), SEEK_SET); read_shdr(in, &elf32_shdr, get_int32); read_name(in, name, 32, stroffset + elf32_shdr.sh_name); //printf("name=%s\n", name); //int is_text = strncmp(name, ".text", 5) == 0 ? 1 : 0; int is_text = (elf32_shdr.sh_flags & SHF_EXECINSTR) != 0 ? 1 : 0; if (is_text || strncmp(name, ".data", 5) == 0 || strcmp(name, ".vectors") == 0) { if (is_text) { if (start == -1) { start = elf32_shdr.sh_addr; } else if (start > elf32_shdr.sh_addr) { start = elf32_shdr.sh_addr; } if (end == -1) { end = elf32_shdr.sh_addr + elf32_shdr.sh_size - 1; } else if (end < elf32_shdr.sh_addr + elf32_shdr.sh_size) { end = elf32_shdr.sh_addr+elf32_shdr.sh_size - 1; } } long marker = ftell(in); fseek(in, elf32_shdr.sh_offset, SEEK_SET); int n; for (n = 0; n < elf32_shdr.sh_size; n++) { if (elf32_shdr.sh_addr + n >= memory->size) break; memory_write_m(memory, elf32_shdr.sh_addr + n, getc(in)); } fseek(in, marker, SEEK_SET); printf("Loaded %d %s bytes from 0x%04x\n", n, name, elf32_shdr.sh_addr); } else if (elf32_shdr.sh_type == SHT_SYMTAB && symbols != NULL) { long marker = ftell(in); fseek(in, elf32_shdr.sh_offset, SEEK_SET); for (n = 0; n < elf32_shdr.sh_size; n += 16) { char name[128]; struct _elf32_sym elf32_sym; elf32_sym.st_name = get_int32(in); elf32_sym.st_value = get_int32(in); elf32_sym.st_size = get_int32(in); elf32_sym.st_info = getc(in); elf32_sym.st_other = getc(in); elf32_sym.st_shndx = get_int16(in); read_name(in, name, 128, strtab_offset + elf32_sym.st_name); printf("symbol %12s 0x%04x\n", name, elf32_sym.st_value); if (elf32_sym.st_info != STT_NOTYPE && elf32_sym.st_info != STT_SECTION && elf32_sym.st_info != STT_FILE) { symbols_append(symbols, name, elf32_sym.st_value); } } fseek(in, marker, SEEK_SET); } } memory->low_address = start; memory->high_address = end; fclose(in); return start; }
static void read_theorem(environment const & env, io_state const &, deserializer & d) { name n = read_name(d); expr t = read_expr(d); expr v = read_expr(d); env->add_theorem(n, t, v); }
static void read_uvar_cnstr(environment const & env, io_state const &, deserializer & d) { name n = read_name(d); level lvl = read_level(d); env->add_uvar_cnstr(n, lvl); }
static void read_variable(environment const & env, io_state const &, deserializer & d) { name n = read_name(d); expr t = read_expr(d); env->add_var(n, t); }
void gdb_save_stacktrace(const char *text_in, const char *text_out){ FILE *fin; FILE *fout; int number = 0; size_t nbytes = 300; fout = fopen(text_out, "w+"); fin = fopen(text_in, "r"); str = (char *) malloc (nbytes + 1); while(1){ size = getline (&str, &nbytes, fin); if (size == -1) break; if (size == 0) break; str[size-1] = '\0'; poz = 4; if(get_char(poz) == '0'){ read_pointer(); poz += 4; } char *func = read_name(); poz += 1; int tmppoz = poz; if (strcmp(func, "gdb_die") == 0) { fprintf(fout, "%s\n", c_rt_lib0get_die_additional_info()); while(get_char(tmppoz) != '"' && get_char(tmppoz) != '\0') ++tmppoz; fprintf(fout, "\""); while(1){ char tmp = get_char(++tmppoz); if(tmp == '"') break; if(tmp == '\0') break; if(tmp == '\\') tmp = get_char(++tmppoz); if(tmp == '"') fprintf(fout, "\""); fprintf(fout, "%c", tmp); } fprintf(fout, "\"\n"); fflush(fout); } tmppoz = size-3; while(is_num(get_char(tmppoz))) --tmppoz; int line = atoi(str+tmppoz+1); if(get_char(tmppoz) == ':') str[tmppoz] = '\0'; while(get_char(tmppoz)!=')') --tmppoz; tmppoz += 5; fprintf(fout, "%d %s %s %d", number, func, str+tmppoz, line); int param = 0; while(1) { if(get_char(poz) == ',') { poz +=2; } else if(get_char(poz) == '(') { poz +=1; if(get_char(poz) == ')') break; } else if(get_char(poz) == ')') { break; } else { break; } char *name = read_name(); void *ptr = NULL; if(get_char(poz) == '='){ ++poz; ptr = read_pointer(); } if(startsWith("___nl__", name) && ptr != NULL){ ImmT saved = dfile0ssave(ptr); NlString* p = toStringIfSim(saved); fprintf(fout, " \"p%d ", param); fprintString(fout, p->s, p->length); fprintf(fout, "\""); } else if(startsWith("___ref___", name) && ptr != NULL && *(ImmT*)ptr != NULL){ ImmT saved = dfile0ssave(*(ImmT*)ptr); NlString* p = toStringIfSim(saved); fprintf(fout, " \"p%d REF ", param); fprintString(fout, p->s, p->length); fprintf(fout, "\""); } else { fprintf(fout, " p%d %s=%p", param, name, ptr); } fflush(fout); ++param; } fprintf(fout, "\n"); fflush(fout); ++number; } free(str); fclose(fin); fclose(fout); }
// --------------------------------------------------------------------------- // Constructeur::ouverture // ------------ bMacMapType::bMacMapType(int t, int *status) :_bse(this){ _bTrace_("bMacMapType::bMacMapType(int,int*)",true); int tbltype; char path[FILENAME_MAX+1],tname[FILENAME_MAX+1]; _iter=NULL; _styles=NULL; _name[0]=0; _idx=_MMAPP_->typesMgr()->count()+1; _rmv=0; read_load_area(); if(!PATH_get(t,&tbltype,path)){ (*status)=-1; _te_("status ="+(*status)+" at PATH_get"); return; } tbltype=get_sign(tbltype); _tm_("opening type with "+(UInt32*)&tbltype+" storage"); *status=_bse.open(path,_MMAPP_->document()->srid(),GetRawPrecisionCoef(_MMAPP_)); if(*status){ _te_("status = "+(*status)+" at new _bse.open "+path); return; } if(((*status)=_bse.h_read(1,kHDR_id_,&_id))){ _te_("status = "+(*status)+" at _bse.h_read kHDR_id_"); return; } if(((*status)=_bse.h_read(1,kHDR_state_,&_state))){ _te_("status = "+(*status)+" at _bse.h_read kHDR_state_"); return; } if(((*status)=_bse.h_read(1,kHDR_kind_,&_kind))){ _te_("status = "+(*status)+" at _bse.h_read kHDR_kind_"); return; } /*if((*status)=_bse.h_read(1,kHDR_bounds_,&_bounds)){ _te_("status = "+(*status)+" at _bse.h_read kHDR_bounds_"); return; }*/ _bounds.top=1-__BOUNDS_MAX__; _bounds.left=1-__BOUNDS_MAX__; _bounds.bottom=1+__BOUNDS_MAX__; _bounds.right=1+__BOUNDS_MAX__; if(((*status)=_bse.h_read(1,kHDR_name_,tname))){ _te_("status = "+(*status)+" at _bse.h_read kHDR_name_"); return; } if(((*status)=_bse.h_read(1,kHDR_precs_,&_precs))){ _te_("status = "+(*status)+" at _bse.h_read kHDR_precs_"); return; } if(((*status)=_bse.h_read(1,kHDR_unit2m_,&_unit2m))){ _te_("status = "+(*status)+" at _bse.h_read kHDR_unit2m_"); return; } if(((*status)=_bse.h_read(1,kHDR_srid_,&_srid))){ _te_("status = "+(*status)+" at _bse.h_read kHDR_srid_"); return; } // snprintf(_name,256,tname); strncpy(_name,tname,sizeof(_name)-1); read_name(path,tname); if((strlen(tname)>0)&&(strcmp(_name,tname))){ _tw_("replacing type name \""+_name+"\" to \""+tname+"\""); // snprintf(_name,256,tname); strncpy(_name,tname,sizeof(_name)-1); if(((*status)=_bse.h_write(1,kHDR_name_,tname))){ _te_("status = "+(*status)+" at _bse.h_write kHDR_name_"); _name[0]=0; return; } } gi_init_p gp={&_bounds,status,SetFlag,GetFlag,GetBounds,ObjIDComp}; _iter=(bGenericGeoIterator*)(extmgr->get_component(kComponentGeoIterator)->i_allocate(tbltype,_MMAPP_,&gp)); if(!_iter){ _te_("no iterator"); (*status)=-1; return; } _styles=new bStyleMgr(this,status); if((*status)){ _te_("status = "+(*status)+" at new bStyleMgr"); return; } _nbalive=0; _nbkilled=0; _nsel=0; _ncnt=0; (*status)=noErr; }
void AsxTokenizer::move_next () { char c; while ((c = read_char ()) != -1) { if (in_data) { bool entirely_whitespace; current_token->set_type (TOKEN_DATA); current_token->set_value (read_data (c, entirely_whitespace)); current_token->set_entirely_whitespace (entirely_whitespace); return; } if (c == OP_OPEN_ELEMENT) { if (is_comment_open (c)) { read_comment (); continue; } current_token->set_type (TOKEN_OPEN_ELEMENT); current_token->set_value (NULL); in_data = false; return; } if (c == OP_CLOSE_ELEMENT) { current_token->set_type (TOKEN_CLOSE_ELEMENT); current_token->set_value (NULL); in_data = true; return; } if (c == OP_ASSIGNMENT) { current_token->set_type (TOKEN_ASSIGNMENT); current_token->set_value (NULL); return; } if (c == OP_SLASH) { current_token->set_type (TOKEN_SLASH); current_token->set_value (NULL); return; } if (g_ascii_isspace (c)) { current_token->set_type (TOKEN_WHITESPACE); current_token->set_value (NULL); return; } if (is_quote_char (c)) { current_token->set_type (TOKEN_QUOTED_STRING); current_token->set_value (read_quoted_string (c)); return; } if (is_name_char (c)) { current_token->set_type (TOKEN_NAME); current_token->set_value (read_name (c)); return; } } current_token->set_type (TOKEN_EOF); current_token->set_value (NULL); }
void main() { char s[100]; read_name(1,s); printf("%s",s); }
/** * params: * the filedes where the data was received. * returns: * 0 if this fd should be taken out of the poll_fd array bcause it already has AS name. * fd if an AS was completed (returns the fd of the events socket) * -1 if there was an error * -2 if client disconnected and should be closed and taken outside the poll_fd array */ static int handle_unc_as_data(int fd) { int i,j,k,len; char *name1; struct as_entry *as; /*first, we see if the data to read is from any of the uncompleted as's*/ for(i=0;i<2*MAX_UNC_AS_NR ;i++) if(unc_as_t[i].valid && unc_as_t[i].fd==fd) break; if(i==2*MAX_UNC_AS_NR){ LM_ERR("has received an fd which is not in uncompleted AS array\n"); return -1; } if(unc_as_t[i].flags & HAS_NAME){/*shouldn't happen, if it has a name, it shouldnt be in fdset[]*/ LM_WARN("this shouldn't happen\n"); return 0;/*already have a name, please take me out the uncompleted AS array*/ } LM_DBG("Reading client name\n"); if(-1==(len=read_name(fd,unc_as_t[i].name,MAX_AS_NAME))){ /*this guy should be disconnected, it sent an AS_NAME too long*/ LM_ERR("Bad name passed from fd\n"); unc_as_t[i].valid=0; unc_as_t[i].flags=0; return -2; }else if(len==-2){ LM_WARN("client disconnected\n"); return -2; } name1=unc_as_t[i].name; /* Check the name isn't already taken */ for(as=as_list;as;as=as->next){ if(as->name.len==len && !memcmp(name1,as->name.s,len)){ if(as->connected){ LM_WARN("AppServer trying to connect with a name already taken (%.*s)\n",len,name1); unc_as_t[i].valid=0; unc_as_t[i].flags=0; return -2; } break; } } if (!as) { LM_ERR("a client tried to connect which is not declared in config. script(%.*s)\n",len,name1); unc_as_t[i].valid=0; unc_as_t[i].flags=0; return -2; } unc_as_t[i].flags |= HAS_NAME; /* the loop's upper bound, * if 'i' is in the lower part, then look for an unc_as in the upper part*/ k=(i>=MAX_UNC_AS_NR?MAX_UNC_AS_NR:2*MAX_UNC_AS_NR); /* the loop's lower bound */ for(j=(i>=MAX_UNC_AS_NR?0:MAX_UNC_AS_NR);j<k;j++) if(unc_as_t[j].valid && (unc_as_t[j].flags & HAS_NAME) && !strcmp(unc_as_t[i].name,unc_as_t[j].name)) break; LM_INFO("Fantastic, we have a new client: %s\n",unc_as_t[i].name); if(j==k)/* the unc_as peer's socket hasn't been found, just take this one out of fdset because it already has its name */ return 0;/*take me out from fdset[]*/ LM_INFO("EUREKA, we have a new completed AS: %s\n",unc_as_t[i].name); /* EUREKA ! we have a sweet pair of AS sockets, with the same name !!*/ if(add_new_as(i<j?i:j,i<j?j:i,as)==-1){ close(unc_as_t[j].fd); close(unc_as_t[i].fd); unc_as_t[j].valid=unc_as_t[i].valid=0; unc_as_t[j].flags=unc_as_t[i].flags=0; return -1; } unc_as_t[j].valid=unc_as_t[i].valid=0; unc_as_t[j].flags=unc_as_t[i].flags=0; return unc_as_t[i<j?i:j].fd; }
void * process_requests(void * arg) { int threadNum = *((int *)arg); int ret; /* return value from a call */ while (true) { struct tdata * local_tdata = removeq(); if (local_tdata->socket == -1) { printf("exiting thread\n"); return NULL; } FILE *logFile; logFile = fopen("log.txt", "a"); int clientd = local_tdata->socket; char buff[MAXBUFF]; /* message buffer */ if ((ret = recv(clientd, buff, MAXBUFF-1, 0)) < 0) { perror("recv()"); return NULL; } buff[ret] = '\0'; // add terminating nullbyte to received array of char printf("Received request (%d chars):\n%s\n", ret, buff); FILE *iFile; struct name myName = {0, 0, 0, 0, -1, 0}; read_name(&myName, buff, ret); pthread_mutex_lock(&lMutex); if ((myName.tok[0][0] == 'Q') && (myName.tok[0][1] == 'U') && (myName.tok[0][2] == 'I') && (myName.tok[0][3] == 'T')) { struct tdata quitTdata = {-1, -1, NULL, NULL}; int j; for (j = 0; j < NUMTHREADS; j++) { printf("TESTING\n"); addq(&quitTdata); } exit(0); } pthread_mutex_unlock(&lMutex); if (myName.tok[1][0] == '/') { memmove(myName.tok[1], myName.tok[1] + 1, strlen(myName.tok[1])); } //print request to log time_t now; now = time(NULL); char timestamp[30]; if(strftime(timestamp, 30, "%a, %d %b %Y %T %Z", gmtime(&now)) == 0) { printf("error: timestamp. Log not accurate.\n"); } pthread_mutex_lock(&lMutex); fprintf(logFile, "%d %d %s \n%d %s %s", local_tdata->request_id, threadNum, timestamp, local_tdata->request_id, myName.tok[0], myName.tok[1]); pthread_mutex_unlock(&lMutex); if (!((myName.tok[0][0] == 'G') && (myName.tok[0][1] == 'E') && (myName.tok[0][2] == 'T'))) //GET syntax check { if ((ret = send(clientd, message4, strlen(message4), 0)) < 0) { perror("send()"); return NULL; } return NULL; } else { printf("testing\n"); printf("opening file: %s\n", myName.tok[1]); iFile = fopen(myName.tok[1], "r"); if (iFile == NULL) { perror ("Error opening file"); if ((ret = send(clientd, message5, strlen(message5), 0)) < 0) { perror("send()"); return NULL; } } else { char sendBuff[MAXBUFF]; // message buffer size_t bufflen = 0; // current capacity of buff size_t nchars; // number of bytes recently read struct stat *stats; stat(myName.tok[1], stats); int numBytes = (int)stats->st_size; char numBytesChar[999]; sprintf(numBytesChar, "%d", numBytes); if ((ret = send(clientd, message1, strlen(message1), 0)) < 0) { perror("send()"); return NULL; } if ((ret = send(clientd, timestamp, strlen(timestamp), 0)) < 0) { perror("send()"); return NULL; } if ((ret = send(clientd, message2, strlen(message2), 0)) < 0) { perror("send()"); return NULL; } if ((ret = send(clientd, numBytesChar, strlen(numBytesChar), 0)) < 0) { perror("send()"); return NULL; } if ((ret = send(clientd, message3, strlen(message3), 0)) < 0) { perror("send()"); return NULL; } while (fgets(sendBuff, MAXBUFF, iFile)) { if ((ret = send(clientd, sendBuff, MAXBUFF-1, 0)) < 0) { perror("send()"); return NULL; } } } } shutdown(clientd, 0); if (myName.tok[3] == NULL) { if ((ret = close(clientd)) < 0) { perror("close(clientd)"); return NULL; } } fclose(logFile); free(local_tdata->link); } }