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());
}
