void doFunDec(Type type, TreeNode *p) {
//printf("doFunDec\n");
//printf("TreeNode->state:%s\n", p->state);
TreeNode *p1 = p->firstChild;
char * funcname = (char *)malloc(sizeof(char*)*(strlen((p1->value).idValue)+1));
strcpy(funcname, p1->value.idValue); //得到函数名
if (searchFunc(funcname) != NULL) {
printf("Error type 4 at line %d '&&': function redefined\n", p->line); //函数重复定义
return;
}
funcTableElement *elem = (funcTableElement *)malloc(sizeof(funcTableElement));
elem->name = funcname;
elem->type = type;
elem->argListHeader = NULL;
switch (p->productionRule) {
case 1: {
TreeNode *p3 = p1->rightBrother->rightBrother;
elem->argListHeader = doVarList(p3);
insertFunc(elem);
//if (funcTableHeader == NULL) printf("null in doFunDec");
break;
}
case 2: {
insertFunc(elem);
break;
}
}
}
void init(){
/*
*插入read(),write()函数
*/
char *read_name = (char*)malloc(20);
char *write_name = (char*)malloc(20);
char *field_name = (char*)malloc(20);
strcpy(read_name,"read");
strcpy(write_name,"write");
strcpy(field_name,"a");
Type read_type = (Type)malloc(sizeof(struct Type_));
read_type->kind = basic;
read_type->u.basic = 0;
FieldList read_func = (FieldList)malloc(sizeof(struct FieldList_));
read_func->name = read_name;
read_func->type = read_type;
read_func->tail = NULL;
insertFunc(read_func);
Type write_type = (Type)malloc(sizeof(struct Type_));
write_type->kind = basic;
write_type->u.basic = 0;
Type field_type = (Type)malloc(sizeof(struct Type_));
field_type->kind = basic;
field_type->u.basic = 0;
FieldList write_func = (FieldList)malloc(sizeof(struct FieldList_));
FieldList write_field = (FieldList)malloc(sizeof(struct FieldList_));
write_field->name = field_name;
write_field->type = field_type;
write_field->tail = NULL;
write_func->name = write_name;
write_func->type = write_type;
write_func->tail = write_field;
insertFunc(write_func);
}
static void finishClass(void)
{
SYMBOL *self = makeID(sc_localstatic, &stdpointer, NULL, "$self");
HASHREC *lst;
if (lambdas->captureThis && lambdas->next)
{
SYMBOL *parent = makeID(sc_member, &stdpointer, NULL, "$parent");
lambda_insert(parent, lambdas);
}
self->label = nextLabel++;
insert(self, lambdas->cls->tp->syms);
insertInitSym(self);
createConstructorsForLambda(lambdas->cls);
insertFunc(lambdas->cls, lambdas->func);
createConverter(self);
if (!lambdas->isMutable)
{
TYPE *tp2 = Alloc(sizeof(TYPE));
tp2->type = bt_const;
tp2->size = lambdas->func->tp->size;
tp2->btp = lambdas->func->tp;
lambdas->func->tp = tp2;
}
createCaller();
}
static void createCaller(void)
{
FUNCTIONCALL *params = Alloc(sizeof(FUNCTIONCALL));
TYPE *args = realArgs(lambdas->func);
SYMBOL *func = makeID(sc_member, args, NULL, overloadNameTab[CI_FUNC]);
SYMBOL *lambdaCall = search(isstructured(basetype(lambdas->func->tp)->btp) ? "__lambdaCallS" : "__lambdaCall", globalNameSpace->syms);
BLOCKDATA block1, block2;
STATEMENT *st;
lambdaCall = (SYMBOL *)lambdaCall->tp->syms->table[0]->p;
func->parentClass = lambdas->cls;
func->linkage = lk_virtual;
func->isInline = FALSE;
func->omitFrame = TRUE;
memset(&block1, 0, sizeof(BLOCKDATA));
memset(&block2, 0, sizeof(BLOCKDATA));
insertFunc(lambdas->cls, func);
InsertInline(func);
st = stmtNode(NULL, &block2, isstructured(basetype(lambdas->func->tp)->btp) ? st_expr : st_return);
st->select = varNode(en_func, NULL);
st->select->v.func = params;
params->arguments = Alloc(sizeof(INITLIST));
params->arguments->exp = varNode(en_pc, lambdas->func);
params->arguments->tp = &stdpointer;
params->ascall = TRUE;
params->sp = func;
params->fcall = varNode(en_pc, lambdaCall);
params->functp = func->tp;
st = stmtNode(NULL, &block1, st_block);
st->lower = block2.head;
st->blockTail = block2.blockTail;
func->inlineFunc.stmt = stmtNode(NULL, NULL, st_block);
func->inlineFunc.stmt->lower = block1.head;
func->inlineFunc.stmt->blockTail = block1.blockTail;
}
// these next two rely on the CONST specifier on the func not being set up yet.
static SYMBOL *createPtrCaller(SYMBOL *self)
{
// if the closure is copied then used on another thread yes the resulting
// code can get into a race condition...
INITLIST *args;
FUNCTIONCALL *params = Alloc(sizeof(FUNCTIONCALL));
TYPE *pargs = realArgs(lambdas->func);
SYMBOL *func = makeID(sc_static, pargs, NULL, "$ptrcaller");
SYMBOL *lambdaCall = search(isstructured(basetype(lambdas->func->tp)->btp) ? "__lambdaPtrCallS" : "__lambdaPtrCall", globalNameSpace->syms);
BLOCKDATA block1, block2;
STATEMENT *st;
EXPRESSION *exp = varNode(en_label, self);
lambdaCall = (SYMBOL *)lambdaCall->tp->syms->table[0]->p;
func->parentClass = lambdas->cls;
func->linkage = lk_virtual;
func->isInline = FALSE;
func->omitFrame = TRUE;
deref(&stdpointer, &exp);
memset(&block1, 0, sizeof(BLOCKDATA));
memset(&block2, 0, sizeof(BLOCKDATA));
insertFunc(lambdas->cls, func);
st = stmtNode(NULL, &block2, isstructured(basetype(lambdas->func->tp)->btp) ? st_expr : st_return);
st->select = varNode(en_func, NULL);
st->select->v.func = params;
params->arguments = Alloc(sizeof(INITLIST));
params->arguments->exp = varNode(en_pc, lambdas->func);
params->arguments->tp = &stdpointer;
args = Alloc(sizeof(INITLIST));
args->next = params->arguments;
params->arguments = args;
params->arguments->exp = exp;
params->arguments->tp = &stdpointer;
params->ascall = TRUE;
params->sp = func;
params->fcall = varNode(en_pc, lambdaCall);
params->functp = func->tp;
st = stmtNode(NULL, &block1, st_block);
st->lower = block2.head;
st->blockTail = block2. blockTail;
func->inlineFunc.stmt = stmtNode(NULL, NULL, st_block);
func->inlineFunc.stmt->lower = block1.head;
func->inlineFunc.stmt->blockTail = block1.blockTail;
return func;
}
static void createConverter(SYMBOL *self)
{
SYMBOL *caller = createPtrCaller(self);
TYPE *args = realArgs(lambdas->func);
SYMBOL *func = makeID(sc_member, Alloc(sizeof(TYPE)), NULL, overloadNameTab[CI_CAST]);
BLOCKDATA block1, block2;
STATEMENT *st;
EXPRESSION *exp;
SYMBOL *sym = makeID(sc_parameter, &stdvoid, NULL, AnonymousName());
HASHREC *hr = Alloc(sizeof(HASHREC));
func->tp->type = bt_func;
func->tp->btp = Alloc(sizeof(TYPE));
func->tp->btp->type = bt_pointer;
func->tp->btp->size = getSize(bt_pointer);
func->tp->btp->btp = args;
func->tp->syms = CreateHashTable(1);
func->linkage = lk_virtual;
func->isInline = FALSE;
hr->p = (struct _hrintern_ *)sym;
func->tp->syms->table[0] = hr;
func->parentClass = lambdas->cls;
memset(&block1, 0, sizeof(BLOCKDATA));
memset(&block2, 0, sizeof(BLOCKDATA));
func->castoperator = TRUE;
insertFunc(lambdas->cls, func);
InsertInline(func);
InsertInline(caller);
st = stmtNode(NULL, &block2, st_return);
st->select = varNode(en_pc, caller);
st = stmtNode(NULL, &block1, st_block);
st->lower = block2.head;
st->blockTail = block2. blockTail;
func->inlineFunc.stmt = stmtNode(NULL, NULL, st_block);
func->inlineFunc.stmt->lower = block1.head;
func->inlineFunc.stmt->blockTail = block1.blockTail;
}
int main(int argc,char *argv[]){
char *tok,line[MAX],*filename=argv[1],*initTree="InitTree",*insert="Insert",*delete="Delete",*find="Find",*height="Height",*printTree="PrintTree";
BST **T=(BST**)malloc(sizeof(BST*));
int numOper=2,numLines=0;
//FILE *fileCountLines=fopen(filename,"r");
//while(fgets(line,sizeof line,fileCountLines)!=NULL){
// numLines++;
//}
//fclose(fileCountLines);
numOper=numLines-1;
FILE *file=fopen(filename,"r");
while(fgets(line,sizeof line,file)!=NULL){
trim(line);
tok=strtok(line," ");
if(strcmp(line,initTree)==0){
char *initTreeParam;
tok=strtok(NULL," ");
initTreeParam=tok;
*T=initTreeFunc(initTreeParam);
tok=strtok(NULL," ");
}
else if(strcmp(line,insert)==0){
char *insertParam;
tok=strtok(NULL," ");
insertParam=tok;
insertFunc(insertParam,T);
tok=strtok(NULL," ");
}
else if(strcmp(line,delete)==0){
char *deleteParam;
tok=strtok(NULL," ");
deleteParam=tok;
deleteFunc(deleteParam,T);
tok=strtok(NULL," ");
}
else if(strcmp(line,find)==0){
char *findParam;
tok=strtok(NULL," ");
findParam=tok;
findFunc(findParam,(*T));
tok=strtok(NULL," ");
}
else if(strcmp(line,height)==0){
int height=heightFunc(*T);
printf("%d\n",height);
tok=strtok(NULL," ");
}
else if(strcmp(line,printTree)==0){
int printTreeParam;
tok=strtok(NULL," ");
printTreeParam=atoi(tok);
printTreeFunc(*T,printTreeParam);
tok=strtok(NULL," ");
printf("\n");
}
}
void socketMode(tArvoreBB **tree, FILE **arq)
{
WSADATA wsaData;
WSAStartup(MAKEWORD(2,2), &wsaData);
SOCKET sock = socket(AF_INET, SOCK_STREAM, 0);
char buf[32] = {0}, op = 1;
if(sock != INVALID_SOCKET)
{
struct sockaddr_in serv_addr = {0};
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = INADDR_ANY;
serv_addr.sin_port = htons(PORT);
if(bind(sock, (struct sockaddr*) &serv_addr, sizeof(serv_addr)) == 0)
{
int len;
struct sockaddr_in cli_addr;
SOCKET newsock;
listen(sock, BACKLOG);
len = sizeof(struct sockaddr_in);
newsock = accept(sock, (struct sockaddr *) &cli_addr, &len);
// if (newsock != INVALID_SOCKET)
// printf("Nova conexao: %s:%d\n", inet_ntoa(cli_addr.sin_addr), ntohs(cli_addr.sin_port));
while(op != 0)
{
if (newsock != INVALID_SOCKET)
{
while(recv(newsock, buf, sizeof(buf)-1, 0) <=0);
//printf("received: %s\n", buf);
op = buf[strlen(buf)-1] - 48;
tfunc func;
char buffer[30]={0};
strncpy(buffer, buf, 3);
buffer[3] = '\0';
func.mat = atoi(buffer);
strncpy(func.nome,buf+3,20);
func.nome[20] = '\0';
strncpy(buffer,buf+23,7);
buffer[7] = '\0';
func.sal = atof(buffer);
switch(op)
{
case 1:
{
insertFunc(*arq, tree, func);
break;
}
case 2:
{
alterSalary(arq, *tree, func.mat, func.sal);
break;
}
case 3:
{
deleteFunc(tree,func.mat);
break;
}
case 4:
{
listFunc(*arq, *tree, func.mat);
break;
}
case 5:
listAll(*arq, *tree);
break;
case 6:
listStruct(*tree);
break;
case 7:
reindex(arq, tree);
break;
case 8:
deleteAll(tree, arq);
break;
}
}
else
{
printf("Erro ao conectar\n");
}
}
}
else
{
printf("Erro no bind()\n");
}
}
}
/**
** main function to start the execution
**/
int main(int argc, char *argv[]){
printf("\n\t"
"*********************************************** \n\t"
" Program to implement a hast-table. \n\t"
"(Values inserted from the mentioned input file) \n\t"
"*********************************************** \n \n");
char *filename="input", line[MAX], *tok, *name;
int foundHashSize=0, key, userSelectedOption, isExit=0, searchKey;
/* Just to calculate the size of HashTable */
FILE *file=fopen(filename, "r");
while(fgets(line, sizeof line, file) != NULL){
/* fetching the size of hashTable and breaking */
if(!foundHashSize){
hashSize=atoi(line);
foundHashSize=1;
break;
}
}
fclose(file);
/* Creating the hashTable with the userDefined Size */
foundHashSize=0;
struct myHashTable hashTable[hashSize];
/* Initializing the Bucket with NULL */
int index;
for(index=0;index<hashSize;index++)
hashTable[index].first=NULL;
/* Insert operation of hashtable, is a mandatory operation */
FILE *fileRem=fopen(filename, "r");
printf("\tFollowing elements are inserted with their corresponding bucket number.\n\tCalculated from the hashfunction:- Marks mod %d \n\n",hashSize);
printf("\tHash\n\t");
while(fgets(line, sizeof line, file) != NULL){
/* Skipping the very first line, sice this is just the size of hashTable */
if(!foundHashSize){
foundHashSize=1;
continue;
}
else{
/* tokenizing the line with colon (:) */
tok=strtok(line, ":");
name=tok;
tok=strtok(NULL, " ");
key=atoi(tok);
tok=strtok(NULL, " ");
/* inserting the tokenized values i.e name and key of the student */
insertFunc(hashTable, name, key);
}
}
fclose(fileRem);
printf("NULL\n\n");
do{
printf("\t"
"Please choose anyone of the options below:- \n\t"
"1] Delete any element. \n\t"
"2] Print the hashTable. \n\t"
"3] Do you want to exit?? \n");
printf("\n\tYour option number: ");
scanf("%d",&userSelectedOption);
printf("\n");
switch(userSelectedOption){
case 1:{
printf("\tPlease enter the key to search: ");
scanf("%d",&searchKey);
deleteFunc(hashTable,searchKey,hashSize);
}
break;
case 2:{
printHashFunc(hashTable,hashSize);
printf("\n\n");
}
break;
case 3:
isExit=1;
break;
default:
printf("Please choose a valid option!!!");
break;
}
}while(!isExit);
return 0;
}
