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