void create(ClientMap& clientMap, char ID[], char plainPwd[], TABLE& id_table) { //clientMap.showMap(); if(clientMap.search(ID) != nullptr) { printf("ID %s exists, ", ID); // show 10 unused ID int count = 0; NextWordGenerator gen(ID); while(count != 10) { char *next = gen.getNext(); if(clientMap.search(next) == nullptr) // if the ID doesn't exist, show it { printf("%s%c", next, (count == 9) ? '\n' : ','); count++; } } return; } int pos = id_table.insert(ID); char encryptedPwd[110]; md5(encryptedPwd, plainPwd); clientMap.insert(ID, encryptedPwd, pos); printf("success\n"); return; }
void ParseEnumDeclaration(TABLE *table) { SYM *sp; TYP *tp; if( lastst == id) { if((sp = search(lastid,&tagtable)) == NULL) { sp = allocSYM(); sp->tp = TYP::Make(bt_enum,1); sp->storage_class = sc_type; sp->SetName(*(new std::string(lastid))); sp->tp->sname = new std::string(*sp->name); NextToken(); if( lastst != begin) error(ERR_INCOMPLETE); else { tagtable.insert(sp); NextToken(); ParseEnumerationList(table); } } else NextToken(); head = sp->tp; } else { tp = allocTYP(); // fix here tp->type = bt_enum; tp->size = 1; if( lastst != begin) error(ERR_INCOMPLETE); else { NextToken(); ParseEnumerationList(table); } head = tp; } }
int StructDeclaration::Parse(int ztype) { SYM *sp; TYP *tp; int ret; int psd; ENODE nd; ENODE *pnd = &nd; sp = nullptr; psd = isStructDecl; isStructDecl++; ret = 0; bit_offset = 0; bit_next = 0; bit_width = -1; if(lastst == id) { if((sp = tagtable.Find(lastid,false)) == NULL) { sp = allocSYM(); sp->SetName(*(new std::string(lastid))); sp->tp = allocTYP(); sp->tp->type = (e_bt)ztype; sp->tp->typeno = typeno++; sp->tp->lst.Clear(); sp->storage_class = sc_type; sp->tp->sname = new std::string(*sp->name); sp->tp->alignment = 0; NextToken(); if (lastst == kw_align) { NextToken(); sp->tp->alignment = GetIntegerExpression(&pnd); } // Could be a forward structure declaration like: // struct buf; if (lastst==semicolon) { ret = 1; tagtable.insert(sp); NextToken(); } // Defining a pointer to an unknown struct ? else if (lastst == star) { tagtable.insert(sp); } else if(lastst != begin) error(ERR_INCOMPLETE); else { tagtable.insert(sp); NextToken(); ParseMembers(sp, sp->tp,ztype); } } // Else it is a known structure else { NextToken(); if (lastst==kw_align) { NextToken(); sp->tp->alignment = GetIntegerExpression(&pnd); } if (lastst==begin) { NextToken(); ParseMembers(sp,sp->tp,ztype); } } head = sp->tp; } // Else there was no tag identifier else { tp = allocTYP(); tp->type = (e_bt)ztype; tp->typeno = typeno++; tp->sname = new std::string(""); if (lastst==kw_align) { NextToken(); tp->alignment = GetIntegerExpression(&pnd); } if( lastst != begin) error(ERR_INCOMPLETE); else { NextToken(); ParseMembers(sp,tp,ztype); } head = tp; } isStructDecl = psd; return ret; }
// Class declarations have the form: // // class identifier [: base class] // { // class members // } // // We could also have a forward reference: // // class identifier; // // Or a pointer to a class: // // class *identifier; // int ClassDeclaration::Parse(int ztype) { SYM *sp, *bcsp; int ret; int psd; ENODE nd; ENODE *pnd = &nd; char *idsave; int alignment; SYM *cls; cls = currentClass; dfs.puts("<ParseClassDeclaration>\n"); alignment = 0; isTypedef = TRUE; NextToken(); if (lastst != id) { error(ERR_SYNTAX); goto lxit; } // ws = allocSYM(); idsave = my_strdup(lastid); // ws->name = idsave; // ws->storage_class = sc_typedef; // Passes lastid onto struct parsing psd = isStructDecl; isStructDecl++; ret = 0; bit_offset = 0; bit_next = 0; bit_width = -1; dfs.printf("---------------------------------"); dfs.printf("Class decl:%s\n", lastid); dfs.printf("---------------------------------"); if((sp = tagtable.Find(std::string(lastid),false)) == NULL) { sp = allocSYM(); sp->SetName(*(new std::string(lastid))); sp->tp = nullptr; NextToken(); dfs.printf("A"); if (lastst == kw_align) { NextToken(); alignment = GetIntegerExpression(&pnd); } else alignment = AL_STRUCT; // Could be a forward structure declaration like: // struct buf; if (lastst==semicolon) { dfs.printf("B"); ret = 1; printf("classdecl insert1\r\n"); tagtable.insert(sp); NextToken(); } // Defining a pointer to an unknown struct ? else if (lastst == star) { dfs.printf("C"); printf("classdecl insert2\r\n"); tagtable.insert(sp); } else if (lastst==colon) { dfs.printf("D"); NextToken(); // Absorb and ignore public/private keywords if (lastst == kw_public || lastst==kw_private) NextToken(); if (lastst != id) { error(ERR_SYNTAX); goto lxit; } bcsp = tagtable.Find(std::string(lastid),false); if (bcsp==nullptr) { error(ERR_UNDEFINED); goto lxit; } dfs.printf("E"); // Copy the type chain of base class //sp->tp = TYP::Copy(bcsp->tp); // Start off at the size of the base. sp->tp = allocTYP(); sp->tp->lst.SetBase(bcsp->GetIndex()); dfs.printf("Set base class: %d\n", sp->tp->lst.base); sp->tp->size = bcsp->tp->size; sp->tp->type = (e_bt)ztype; sp->tp->typeno = typeno++; sp->tp->sname = new std::string(*sp->name); sp->tp->alignment = alignment; sp->storage_class = sc_type; NextToken(); if (lastst != begin) { error(ERR_INCOMPLETE); goto lxit; } /* sp->tp = allocTYP(); sp->tp->typeno = typeno++; sp->tp->sname = new std::string(*sp->name); sp->tp->alignment = alignment; sp->tp->type = (e_bt)ztype; sp->tp->lst.SetBase(bcsp->GetIndex()); sp->storage_class = sc_type; */ tagtable.insert(sp); NextToken(); currentClass = sp; dfs.printf("f"); ParseMembers(sp,ztype); dfs.printf("G"); } else if(lastst != begin) error(ERR_INCOMPLETE); else { if (sp->tp == nullptr) { sp->tp = allocTYP(); } sp->tp->size = 0; sp->tp->typeno = typeno++; sp->tp->sname = new std::string(*sp->name); sp->tp->alignment = alignment; sp->tp->type = (e_bt)ztype; sp->tp->lst.SetBase(0); sp->storage_class = sc_type; tagtable.insert(sp); NextToken(); currentClass = sp; ParseMembers(sp,ztype); } } // Else the class was found in the tag table. else { NextToken(); if (lastst==kw_align) { NextToken(); sp->tp->alignment = GetIntegerExpression(&pnd); } if (lastst==begin) { NextToken(); currentClass = sp; ParseMembers(sp,ztype); } } head = sp->tp; isStructDecl = psd; lxit: isTypedef = TRUE; if (classname) delete classname; classname = new std::string(idsave); currentClass = cls; dfs.puts("</ParseClassDeclaration>\n"); return ret; }