int otherFor(char* direccion, char* dir) { char nombre[6]; char found = 0; char sectorNumber; char otro[6]; int indexx; int n; int y; int b=0; int w=0; int z = 0; char token [10]; int toks = CountTokens(direccion); sectorNumber = 0x01; for (b=0; b<10; b++) token[b]=0x0; while(w < toks) { z = getTok(direccion,token,z); found = 0; for(n=0;n<6;n++) { nombre[n] = token[n]; } for (indexx=0;indexx<15;indexx++) { for(y=0;y<6;y++) { otro[y] = dir[indexx*0x20+y]; //si existe o no el directorio } if(cmp(otro,nombre,6)==1) //si encontramos el directorio { sectorNumber = dir[indexx*0x20+6]; readsector(BASEOFFSET+sectorNumber,dir); w++; found = 1; break; } } if(found == 1) { continue; } w++; } return sectorNumber; }
void strTok(char* path) { int y = CountTokens(path); int i=0; int x=0,w=0; int z = 0; char token [10]; for (i=0; i<10; i++) token[i]=0x0; while(w < y) { z = getTok(path,token,z); w++; } }
JsonNodeT *JsonParse(const char *json) { JsonNodeT *node = NULL; int num = 0; LOG("Lexing JSON."); if (CountTokens(json, &num)) { ParserT parser; /* read tokens into an array */ TokenT *tokens = ReadTokens(json, num); /* now... parse! */ ParserInit(&parser, tokens, num); LOG("Parsing JSON."); if (!ParseValue(&parser, &node)) { #ifdef DEBUG_LEXER LOG("Parse error: %s at token ", parser.errmsg); TokenPrint(&parser.tokens[parser.pos]); #else LOG("Parse error: %s at position %d.", parser.errmsg, parser.tokens[parser.pos].pos); #endif MemUnref(node); node = NULL; } else { LOG("Parsing finished."); } MemUnref(tokens); } return node; }
/* Initializes the block_list with info from a netlist */ void read_netlist(IN const char* net_file, IN int num_types, IN const struct s_type_descriptor block_types[], IN block_type_ptr IO_type, IN int io_ipin, IN int io_opin, OUT subblock_data_t* subblock_data_ptr, OUT int* num_blocks, OUT block_t* block_list[], OUT int* num_nets, OUT net_t* net_list[]) { int i, j, k, l, m; enum { COUNT, LOAD, MAP, STOP } pass; int line, prev_line; enum special_blk overide; char** block_tokens; char** pin_tokens; char** tokens; subblock_t** slist = NULL; int* scount = NULL; block_type_ptr type = NULL; FILE* infile = my_fopen(net_file, "r"); int bcount = 0; block_t* blist = NULL; int ncount = 0; net_t* nlist = NULL; memset(subblock_data_ptr, 0, sizeof(subblock_data_t)); /* Multi-pass load * COUNT *->count blocks *->count nets * * LOAD *->alloc num_subblocks_per_block list *->allocate s_block list at start *->allocate s_net list at start *->count subblocks per block *->sets block names *->sets block types *->allocs block net lists *->sets net names * * MAP *->fills in s_block:nets list *->fills in subblocks */ for (pass = 0; pass < STOP; ++pass) { rewind(infile); line = 0; i = 0; j = 0; overide = NORMAL; /* Alloc the lists */ if (LOAD == pass) { blist = (block_t*)my_malloc(sizeof(block_t) * bcount); memset(blist, 0, (sizeof(block_t) * bcount)); nlist = (net_t*)my_malloc(sizeof(net_t) * ncount); memset(nlist, 0, (sizeof(net_t) * ncount)); slist = (subblock_t**) my_malloc(sizeof(subblock_t*) * bcount); memset(slist, 0, (sizeof(subblock_t*) * bcount)); scount = (int*)my_malloc(sizeof(int) * bcount); memset(scount, 0, (sizeof(int) * bcount)); } /* Read file line by line */ block_tokens = ReadLineTokens(infile, &line); prev_line = line; while (block_tokens) { /* .global directives have special meaning */ if (0 == strcmp(block_tokens[0], ".global")) { if (MAP == pass) { for (l = 0; l < ncount; ++l) { if (0 == strcmp(nlist[l].name, block_tokens[1])) { nlist[l].is_global = TRUE; break; } } if (l == ncount) { printf(ERRTAG "'%s':%d - '.global' specified an invalid net\n", net_file, prev_line); exit(1); } } /* Don't do any more processing on this */ FreeTokens(&block_tokens); block_tokens = ReadLineTokens(infile, &line); prev_line = line; continue; } pin_tokens = ReadLineTokens(infile, &line); if (CountTokens(block_tokens) != 2) { printf(ERRTAG "'%s':%d - block type line should " "be in form '.type_name block_name'\n", net_file, prev_line); exit(1); } if (NULL == pin_tokens) { printf(ERRTAG "'%s':%d - blocks must be follow by a 'pinlist:' line\n", net_file, line); exit(1); } if (0 != strcmp("pinlist:", pin_tokens[0])) { printf(ERRTAG "'%s':%d - 'pinlist:' line must follow " "block type line\n", net_file, line); exit(1); } type = get_type_by_name(block_tokens[0], num_types, block_types, IO_type, net_file, prev_line, &overide); /* Check if we are overiding the pinlist format for this block */ if (overide) { if (CountTokens(pin_tokens) != 2) { /* 'pinlist:' and name */ printf(ERRTAG "'%s':%d - pinlist for .input and .output should " "only have one item.\n", net_file, line); exit(1); } /* Make a new faked token list with 'pinlist:' and then pin mappings and a null */ tokens = (char**)my_malloc(sizeof(char*) * (type->num_type_pins + 2)); l = strlen(pinlist_str) + 1; k = strlen(pin_tokens[1]) + 1; tokens[0] = (char*)my_malloc(sizeof(char) * (k + l)); memcpy(tokens[0], pinlist_str, l * sizeof(char)); memcpy(tokens[0] + l, pin_tokens[1], k * sizeof(char)); /* Set all other pins to open */ for (k = 0; k < type->num_type_pins; ++k) { tokens[1 + k] = "open"; /* free wont be called on this so is safe */ } tokens[1 + k] = NULL; /* End of token list marker */ /* Set the one pin with the value given */ for (k = 0; k < type->num_type_pins; ++k) { switch (overide) { case INPAD: tokens[1 + io_opin] = (tokens[0] + l); break; case OUTPAD: tokens[1 + io_ipin] = (tokens[0] + l); break; } } FreeTokens(&pin_tokens); pin_tokens = tokens; tokens = NULL; } if (CountTokens(pin_tokens) != (type->num_type_pins + 1)) { printf(ERRTAG "'%s':%d - 'pinlist:' line has %d pins instead of " "expect %d pins.\n", net_file, line, CountTokens(pin_tokens) - 1, type->num_type_pins); exit(1); } /* Load block name and type and alloc net list */ if (LOAD == pass) { blist[i].name = my_strdup(block_tokens[1]); blist[i].block_type = type; blist[i].nets = (int*)my_malloc(sizeof(int) * type->num_type_pins); for (k = 0; k < type->num_type_pins; ++k) { blist[i].nets[k] = OPEN; } } /* Examine pin list to determine nets */ for (k = 0; k < type->num_type_pins; ++k) { if (0 != strcmp("open", pin_tokens[1 + k])) { if (DRIVER == type->class_inf[type->pin_class[k]].type) { if (LOAD == pass) { nlist[j].name = my_strdup(pin_tokens[1 + k]); } if (MAP == pass) { blist[i].nets[k] = j; /* If we are net source we don't need to search */ } ++j; /* This was an active netlist */ } else { if (MAP == pass) { /* Map sinks by doing a linear search to find the net */ blist[i].nets[k] = OPEN; for (l = 0; l < ncount; ++l) { if (0 == strcmp(nlist[l].name, pin_tokens[1 + k])) { blist[i].nets[k] = l; break; } } if (OPEN == blist[i].nets[k]) { printf(ERRTAG "'%s':%d - Net '%s' not found\n", net_file, line, pin_tokens [1 + k]); exit(1); } } } } } /* Allocating subblocks */ if (MAP == pass) { /* All blocks internally have subblocks but I/O subblocks are allocated and loaded elsewhere */ if (scount[i] > 0) { slist[i] = (subblock_t*) my_malloc(sizeof(subblock_t) * scount[i]); for (k = 0; k < scount[i]; ++k) { slist[i][k].name = NULL; slist[i][k].clock = OPEN; slist[i][k].inputs = (int*)my_malloc(sizeof(int) * type->max_subblock_inputs); for (l = 0; l < type->max_subblock_inputs; ++l) { slist[i][k].inputs[l] = OPEN; } slist[i][k].outputs = (int*)my_malloc(sizeof(int) * type->max_subblock_outputs); for (l = 0; l < type->max_subblock_outputs; ++l) { slist[i][k].outputs[l] = OPEN; } } } } /* Ignore subblock data */ tokens = ReadLineTokens(infile, &line); prev_line = line; m = 0; while (tokens && (0 == strcmp(tokens[0], "subblock:"))) { if (CountTokens(tokens) != (type->max_subblock_inputs + type->max_subblock_outputs + 1 + /* clocks */ 2)) { /* 'subblock:', name */ printf("subblock wrong pin count, netlist has %d, architecture as %d on line %d \n" , CountTokens(tokens) - 2, (type->max_subblock_inputs + type->max_subblock_outputs + 1), line); exit(1); } /* Count subblocks given */ if (LOAD == pass) { scount[i]++; } /* Load subblock name */ if (MAP == pass) { assert(i < bcount); assert(m < scount[i]); slist[i][m].name = my_strdup(tokens[1]); for (k = 0; k < type->max_subblock_inputs; ++k) { /* Check prefix and load pin num */ l = 2 + k; if (0 == strncmp("ble_", tokens[l], 4)) { /* Skip the 'ble_' part */ slist[i][m].inputs[k] = type->num_type_pins + my_atoi(tokens[l] + 4); } else if (0 != strcmp("open", tokens[l])) { slist[i][m].inputs[k] = my_atoi(tokens[l]); } } for (k = 0; k < type->max_subblock_outputs; ++k) { l = 2 + type->max_subblock_inputs + k; if (0 != strcmp("open", tokens[l])) { slist[i][m].outputs[k] = my_atoi(tokens[l]); } } l = 2 + type->max_subblock_inputs + type->max_subblock_outputs; if (0 != strcmp("open", tokens[l])) { slist[i][m].clock = my_atoi(tokens[l]); } } ++m; /* Next subblock */ FreeTokens(&tokens); tokens = ReadLineTokens(infile, &line); prev_line = line; } if (pass > COUNT) { /* Check num of subblocks read */ if (scount[i] > type->max_subblocks) { printf("too many subblocks on block [%d] %s\n", i, blist[i].name); exit(1); } } ++i; /* End of this block */ FreeTokens(&block_tokens); FreeTokens(&pin_tokens); block_tokens = tokens; } /* Save counts */ if (COUNT == pass) { bcount = i; ncount = j; } } fclose(infile); /* Builds mappings from each netlist to the blocks contained */ sync_nets_to_blocks(bcount, blist, ncount, nlist); /* Send values back to caller */ *num_blocks = bcount; *block_list = blist; *num_nets = ncount; *net_list = nlist; subblock_data_ptr->subblock_inf = slist; subblock_data_ptr->num_subblocks_per_block = scount; }
void mkdir(char* path) { int b=0; int w=0; int z = 0; char token [10]; int toks = CountTokens(path); int k; char r; char mapa[512]; char dir[512]; char nombre[6]; char found = 0; char sectorNumber; char comparar[6]; int x; int n; int y; int sectorLibre = 0; int entrada = 0; int dirindex = 0; int sectcount; readsector(BASEOFFSET,mapa); readsector(BASEOFFSET +1,dir); sectorNumber = 0x01; for (b=0; b<10; b++) token[b]=0x0; while(w < toks) { z = getTok(path,token,z); found = 0; for(n=0;n<6;n++) { nombre[n] = token[n]; } for (x=0;x<15;x++) { for(y=0;y<6;y++) { comparar[y] = dir[x*0x20+y]; //si existe o no el directorio } if(cmp(comparar,nombre,6)==1) //si encontramos el directorio { sectorNumber = dir[x*0x20+6]; readsector(BASEOFFSET+sectorNumber,dir); w++; found = 1; break; } } if(found == 1) { continue; } for (entrada=0; entrada<256; entrada++) if (mapa[entrada]==0) break; if (entrada==256) { printstring("Not enough room for file\n"); return; } mapa[entrada]=0x44; for (x=0;x<15;x++) { dirindex = x*0x20; sectorLibre = dir[dirindex]; //buscamos la primera entrada libre if(sectorLibre==0) { for (k=0; k<6; k++) dir[dirindex+k]=0x20; for (k=0; k<6; k++) { if(nombre[k]==0) break; dir[dirindex+k]=nombre[k]; } dir[dirindex+6] = entrada; break; } } writesector(BASEOFFSET+sectorNumber,dir); writesector(BASEOFFSET,mapa); readsector(BASEOFFSET+entrada,dir); sectorNumber = entrada; w++; } }
void Remove(char* path) { int i; char r; char map[512]; char dir[512]; char nombre[6]; char found = 0; char sectorNumber; char prevSectorNumber; char comparar[6]; int x; int n; int y; int sectorLibre = 0; int entradaMapa = 0; int dirindex = 0; int sectcount; int b=0; int w=0; int z = 0; char token [10]; int toks = CountTokens(path);//cantidad de subdirectorios readsector(BASEOFFSET,map); readsector(BASEOFFSET +1,dir); sectorNumber = 0x01; prevSectorNumber = 0x01; for (b=0; b<10; b++) token[b]=0x0; while(w < toks) { z = getTok(path,token,z); found = 0; for(n=0;n<6;n++) { nombre[n] = token[n]; } for (x=0;x<15;x++) { for(y=0;y<6;y++) { comparar[y] = dir[x*0x20+y]; //copiando el nombre del directorio } if(cmp(comparar,nombre,6)==1) //si encontramos el directorio { prevSectorNumber = sectorNumber; sectorNumber = dir[x*0x20+6]; readsector(BASEOFFSET+sectorNumber,dir); found = 1; break; } } w++; } if(found == 1) { readsector(BASEOFFSET + prevSectorNumber,dir); for(y=0;y<7;y++) { dir[x*0x20+y] = 0; } writesector(BASEOFFSET + prevSectorNumber,dir); }else { printstring("Directorio no Encontrando"); } }
void guardarArchivo(char* direccion, char* content, int size) { int i; char r; int sect; char map[512]; char dir[512]; char nombre[6]; char found = 0; char sectorNumber; char otro[6]; int indexx; int n; int y; int sectorLibre = 0; int entradaMapa = 0; int dirindex = 0; int sectcount; int b=0; int w=0; int z = 0; char token [10]; int toks = CountTokens(direccion); readsector(BASEOFFSET,map); readsector(BASEOFFSET +1,dir); //sectorNumber = otherFor(direccion, dir); sectorNumber = 0x01; for (b=0; b<10; b++) token[b]=0x0; while(w < toks) { z = getTok(direccion,token,z); found = 0; for(n=0;n<6;n++) { nombre[n] = token[n]; } for (indexx=0;indexx<15;indexx++) { for(y=0;y<6;y++) { otro[y] = dir[indexx*0x20+y]; //si existe o no el directorio } if(cmp(otro,nombre,6)==1) //si encontramos el directorio { sectorNumber = dir[indexx*0x20+6]; readsector(BASEOFFSET+sectorNumber,dir); w++; found = 1; break; } } if(found == 1) { continue; } w++; }//busca que es el ultimo token no me acuerdo que hace for (indexx=0;indexx<15;indexx++) { dirindex = indexx*0x20; sectorLibre = dir[dirindex]; //buscamos la primera entrada libre if(sectorLibre==0) { for (i=0; i<6; i++) dir[dirindex+i]=0x20; for (i=0; i<6; i++) { if(nombre[i]==0) break; dir[dirindex+i]=nombre[i]; } break; } } sect = (div(size,512)+1); for(indexx=0;indexx<sect;indexx++) { printnumber(dirindex); entradaM(sect,map,dir,dirindex,content,indexx); } writesector(BASEOFFSET+sectorNumber,dir); writesector(BASEOFFSET,map); return; }
//Public Function 4166 int StringTokenizer::HasMoreTokens() { return(CountTokens()); }
//Public Function 4158 int StringTokenizer::CountTokens(char * DelimiterChar) { SetDelimiterString(DelimiterChar); return(CountTokens()); }