First working version

1994-02-17 15:40:46 +00:00
parent ac0d59aeaf
commit 988b89b238
4 changed files with 157 additions and 95 deletions
--- a/src/as/asDbLib.c
+++ b/src/as/asDbLib.c
@@ -36,6 +36,7 @@
 #include <dbDefs.h>
 #include <dbStaticLib.h>
 #include <asLib.h>
+#include <dbCommon.h>

 extern struct dbBase *pdbBase;
 static FILE *stream;
@@ -59,8 +60,8 @@ printf("INPUT: %s",my_buffer);
    my_buffer_ptr += n;
    return(n);
 }
-
-static long asDbEnterRecords(void)
+
+static long asDbAddRecords(void)
 {
    DBENTRY		dbentry;
    DBENTRY		*pdbentry=&dbentry;
@@ -75,7 +76,7 @@ static long asDbEnterRecords(void)
 	    precord = pdbentry->precnode->precord;
 	    if(!precord->asp) {
 		status = asAddMember((ASMEMBERPVT *)&precord->asp,precord->asg);
-		if(status) errMessage(status,"asDbEnterRecords:asAddMember");
+		if(status) errMessage(status,"asDbAddRecords:asAddMember");
 		asPutMemberPvt(precord->asp,precord);
 	    }
 	    status = dbNextRecord(pdbentry);
@@ -85,7 +86,7 @@ static long asDbEnterRecords(void)
    dbFinishEntry(pdbentry);
    return(0);
 }
-
+
 int asInit(char *filename)
 {
    long status;
@@ -103,10 +104,10 @@ int asInit(char *filename)
    status = asInitialize(my_yyinput);
    if(fclose(stream)==EOF) errMessage(0,"asInit fclose failure");
    free((void *)my_buffer);
-    asDbEnterRecords();
+    asDbAddRecords();
    return(0);
 }
-
+
 void static myMemberCallback(ASMEMBERPVT memPvt)
 {
    struct dbCommon	*precord;
@@ -120,3 +121,29 @@ int asdbdump()
    asDump(myMemberCallback,NULL);
    return(0);
 }
+
+int astac(char *pname,char *user,char *location)
+{
+    struct dbAddr	*paddr;
+    long		status;
+    ASCLIENTPVT		*pasclientpvt=NULL;
+    struct dbCommon	*precord;
+    struct fldDes	*pflddes;
+
+    paddr = dbCalloc(1,sizeof(struct dbAddr) + sizeof(ASCLIENTPVT));
+    pasclientpvt = (ASCLIENTPVT *)(paddr + 1);
+    status=dbNameToAddr(pname,paddr);
+    if(status) {
+	errMessage(status,"dbNameToAddr error");
+	return(1);
+    }
+    precord = paddr->precord;
+    pflddes = paddr->pfldDes;
+    status = asAddClient(pasclientpvt,(ASMEMBERPVT)precord->asp,
+	(int)pflddes->as_level,user,location);
+    if(status) {
+	errMessage(status,"asAddClient error");
+	return(1);
+    }
+    return(0);
+}
--- a/src/as/asLib.y
+++ b/src/as/asLib.y
@@ -1,12 +1,12 @@
 %{
 static int yyerror();
+static int myParse();
 #include "asLibRoutines.c"
 static int line_num=1;
 static UAG *yyUag=NULL;
 static LAG *yyLag=NULL;
 static ASG *yyAsg=NULL;
 static ASGLEVEL *yyAsgLevel=NULL;
-static int yyLevelLow,yyLevelHigh;
 %}

 %start asconfig
@@ -15,7 +15,6 @@ static int yyLevelLow,yyLevelHigh;
 %token <Str> tokenINP
 %token <Int> tokenINTEGER
 %token <Str> tokenNAME tokenPVNAME tokenSTRING
-%left O_BRACE C_BRACE O_PAREN C_PAREN

 %union
 {
@@ -31,11 +30,14 @@ asconfig:	asconfig asconfig_item
 	|	asconfig_item

 asconfig_item:	tokenUAG uag_head uag_body
+	|	tokenUAG uag_head
 	|	tokenLAG lag_head lag_body
+	|	tokenLAG lag_head
 	|	tokenASG asg_head asg_body
+	|	tokenASG asg_head
 	;

-uag_head:	O_PAREN tokenNAME C_PAREN
+uag_head:	'(' tokenNAME ')'
 	{
 		yyUag = asUagAdd($2);
 		if(!yyUag) yyerror($2);
@@ -43,7 +45,7 @@ uag_head:	O_PAREN tokenNAME C_PAREN
 	}
 	;

-uag_body:	O_BRACE uag_user_list C_BRACE
+uag_body:	'{' uag_user_list '}'
 	{
 		 ;
 	}
@@ -66,7 +68,7 @@ uag_user_list_name:	tokenNAME
 	}
 	;

-lag_head:	O_PAREN tokenNAME C_PAREN
+lag_head:	'(' tokenNAME ')'
 	{
 		yyLag = asLagAdd($2);
 		if(!yyLag) yyerror($2);
@@ -74,7 +76,7 @@ lag_head:	O_PAREN tokenNAME C_PAREN
 	}
 	;

-lag_body:	O_BRACE lag_user_list C_BRACE
+lag_body:	'{' lag_user_list '}'
 	;

 lag_user_list:	lag_user_list ',' lag_user_list_name
@@ -94,7 +96,7 @@ lag_user_list_name:	tokenNAME
 	}
 	;

-asg_head:	O_PAREN tokenNAME C_PAREN
+asg_head:	'(' tokenNAME ')'
 	{
 		yyAsg = asAsgAdd($2);
 		if(!yyAsg) yyerror($2);
@@ -102,7 +104,7 @@ asg_head:	O_PAREN tokenNAME C_PAREN
 	}
 	;

-asg_body:	O_BRACE asg_body_list C_BRACE
+asg_body:	'{' asg_body_list '}'
 	{
 	}

@@ -112,14 +114,14 @@ asg_body_list:	asg_body_list asg_body_item
 asg_body_item:	inp_config | level_config 
 	;

-inp_config:	tokenINP O_PAREN inp_body C_PAREN
+inp_config:	tokenINP '(' inp_body ')'
 	{
 		long	status;

-		status = asAsgAddInp(yyAsg,$<Str>3,(*(($<Str>1) + 3)-'A'));
+		status = asAsgAddInp(yyAsg,$<Str>3,$<Int>1);
 		if(status) {
 			errMessage(status,"Error while adding INP");
-			yyerror($<Str>1);
+			yyerror($1);
 		}
 		free((void *)$<Str>3);
 	}
@@ -131,11 +133,13 @@ inp_body:	tokenNAME | tokenPVNAME
 level_config:	tokenLEVEL level_head level_body
 	|	tokenLEVEL level_head

-level_head:	O_PAREN level_range ',' tokenNAME C_PAREN
+level_head:	'(' tokenINTEGER ',' tokenNAME ')'
 	{
 		asAccessRights	rights;

-		if((strcmp($4,"READ")==0)) {
+		if((strcmp($4,"NONE")==0)) {
+			rights=asNOACCESS;
+		} else if((strcmp($4,"READ")==0)) {
 			rights=asREAD;
 		} else if((strcmp($4,"WRITE")==0)) {
 			rights=asWRITE;
@@ -143,32 +147,22 @@ level_head:	O_PAREN level_range ',' tokenNAME C_PAREN
 			yyerror("Illegal access type");
 			rights = asNOACCESS;
 		}
-		yyAsgLevel = asAsgAddLevel(yyAsg,rights,yyLevelLow,yyLevelHigh);
+		yyAsgLevel = asAsgAddLevel(yyAsg,rights,$2);
 		free((void *)$4);
 	}
 	;

-level_range:	tokenINTEGER
-	{
-		yyLevelLow = yyLevelHigh = $1;
-	}
-	|	tokenINTEGER '-' tokenINTEGER
-	{
-		yyLevelLow = $1;
-		yyLevelHigh = $3;
-	}
-	

-level_body:	O_BRACE level_list C_BRACE
+level_body:	'{' level_list '}'
 	;

 level_list:	level_list level_list_item
 	|	level_list_item
 	;

-level_list_item: tokenUAG O_PAREN level_uag_list C_PAREN
-	|	tokenLAG  O_PAREN level_lag_list C_PAREN
-	|	tokenCALC O_PAREN tokenSTRING C_PAREN
+level_list_item: tokenUAG '(' level_uag_list ')'
+	|	tokenLAG  '(' level_lag_list ')'
+	|	tokenCALC '(' tokenSTRING ')'
 	{
 		long status;

@@ -187,8 +181,13 @@ level_uag_list:	level_uag_list ',' level_uag_list_name

 level_uag_list_name:	tokenNAME
 	{
-		if(asAsgLevelUagAdd(yyAsgLevel,$1))
-		    yyerror("Why did asAsgLevelUagAdd fail");
+		long status;
+
+		status = asAsgLevelUagAdd(yyAsgLevel,$1);
+		if(status) {
+		    errMessage(status,"Error while adding UAG");
+		    yyerror($1);
+		}
 		free((void *)$1);
 	}
 	;
@@ -199,8 +198,13 @@ level_lag_list:	level_lag_list ',' level_lag_list_name

 level_lag_list_name:	tokenNAME
 	{
-		if(asAsgLevelLagAdd(yyAsgLevel,$1))
-		    yyerror("Why did asAsgLevelLagAdd fail");
+		long status;
+
+		status = asAsgLevelLagAdd(yyAsgLevel,$1);
+		if(status) {
+		    errMessage(status,"Error while adding LAG");
+		    yyerror($1);
+		}
 		free((void *)$1);
 	}
 	;
--- a/src/as/asLibRoutines.c
+++ b/src/as/asLibRoutines.c
@@ -58,14 +58,12 @@ static LAG *asLagAdd(char *lagName);
 static long asLagAddLocation(LAG *plag,char *location);
 static ASG *asAsgAdd(char *asgName);
 static long asAsgAddInp(ASG *pasg,char *inp,int inpIndex);
-static ASGLEVEL *asAsgAddLevel(ASG *pasg,asAccessRights access,
-	int levlow,int levHigh);
+static ASGLEVEL *asAsgAddLevel(ASG *pasg,asAccessRights access,int level);
 static long asAsgLevelUagAdd(ASGLEVEL *pasglevel,char *name);
 static long asAsgLevelLagAdd(ASGLEVEL *pasglevel,char *name);
 static long asAsgLevelCalc(ASGLEVEL *pasglevel,char *calc);
 static void asCaStart(void);
 static void asCaStop(void);
-static int myParse(ASINPUTFUNCPTR inputfunction);

 long asInitialize(ASINPUTFUNCPTR inputfunction)
 {
@@ -76,7 +74,6 @@ long asInitialize(ASINPUTFUNCPTR inputfunction)
    if(pasbaseold) {
 	asCaStop();
    }
-    asActive = TRUE;
    pasbase = asCalloc(1,sizeof(ASBASE));
    ellInit(&pasbase->uagList);
    ellInit(&pasbase->lagList);
@@ -89,9 +86,10 @@ long asInitialize(ASINPUTFUNCPTR inputfunction)
 	pasbase = pasbaseold;
 	return(status);
    }
+    asActive = TRUE;
    pasg = (ASG *)ellFirst(&pasbase->asgList);
    while(pasg) {
-	pasg->pavalue = asCalloc(ellCount(&pasg->inpList),sizeof(double));
+	pasg->pavalue = asCalloc(ASMAXINP,sizeof(double));
 	pasg = (ASG *)ellNext((ELLNODE *)pasg);
    }
    if(pasbaseold) {
@@ -116,7 +114,7 @@ long asInitialize(ASINPUTFUNCPTR inputfunction)
    return(0);
 }

-long asAddMember(ASMEMBERPVT *asMemberPvt,char *asgName)
+long asAddMember(ASMEMBERPVT *pasMemberPvt,char *asgName)
 {
    ASGMEMBER	*pasgmember;
    ASG		*pgroup;
@@ -124,12 +122,12 @@ long asAddMember(ASMEMBERPVT *asMemberPvt,char *asgName)
    long	status;

    if(!asActive) return(0);
-    if(*asMemberPvt) {
-	pasgmember = *asMemberPvt;
+    if(*pasMemberPvt) {
+	pasgmember = *pasMemberPvt;
    } else {
 	pasgmember = asCalloc(1,sizeof(ASGMEMBER));
 	ellInit(&pasgmember->clientList);
-	*asMemberPvt = pasgmember;
+	*pasMemberPvt = pasgmember;
    }
    pasgmember->asgName = asgName;
    pgroup = (ASG *)ellFirst(&pasbase->asgList);
@@ -211,24 +209,22 @@ void asPutMemberPvt(ASMEMBERPVT asMemberPvt,void *userPvt)
    pasmember->userPvt = userPvt;
 }

-long asAddClient(ASCLIENTPVT *asClientPvt,ASMEMBERPVT asMemberPvt,
+long asAddClient(ASCLIENTPVT *pasClientPvt,ASMEMBERPVT asMemberPvt,
 	int asl,char *user,char *location)
 {
    ASGMEMBER	*pasmember = asMemberPvt;
    ASGCLIENT	*pasclient;
    long	status;
-
    if(!asActive) return(0);
-    pasclient = asCalloc(1,sizeof(ASCLIENTPVT));
-    *asClientPvt = pasclient;
+    pasclient = asCalloc(1,sizeof(ASGCLIENT));
+    *pasClientPvt = pasclient;
    pasclient->pasgMember = asMemberPvt;
    pasclient->level = asl;
    pasclient->user = user;
    pasclient->location = location;
-printf("Calling asCompute\n");
    status = asCompute(pasclient);
    if(status) return(status);
-    if(!asCheckGet((*asClientPvt))) {
+    if(!asCheckGet(pasclient)) {
 	return(S_asLib_noAccess);
    }
    ellAdd(&pasmember->clientList,(ELLNODE *)pasclient);
@@ -285,7 +281,7 @@ void asPutClientPvt(ASCLIENTPVT asClientPvt,void *userPvt)

 long asCompute(ASCLIENTPVT asClientPvt)
 {
-    asAccessRights	access=0;
+    asAccessRights	access=asNOACCESS;
    ASGCLIENT		*pasgClient = asClientPvt;
    ASGMEMBER		*pasgMember = pasgClient->pasgMember;
    ASG			*pasg = pasgMember->pasg;
@@ -296,8 +292,9 @@ long asCompute(ASCLIENTPVT asClientPvt)
    if(!pasg) return(0);
    pasglevel = (ASGLEVEL *)ellFirst(&pasg->levelList);
    while(pasglevel) {
+	if(access == asWRITE) break;
 	if(access>=pasglevel->access) goto next_level;
-	if(!((1<<pasgClient->level)&pasglevel->level_mask)) goto next_level;
+	if(pasgClient->level > pasglevel->level) goto next_level;
 	/*if uagList is empty then no need to check uag*/
 	if(ellCount(&pasglevel->uagList)>0){
 	    ASGUAG	*pasguag;
@@ -352,7 +349,8 @@ next_level:
    pasgClient->access = access;
    return(0);
 }
-
+
+static char *asAccessName[] = {"NONE","READ","WRITE"};
 void asDump(
 	void (*memcallback)(struct asgMember *),
 	void (*clientcallback)(struct asgClient *))
@@ -372,43 +370,62 @@ void asDump(
    puag = (UAG *)ellFirst(&pasbase->uagList);
    if(!puag) printf("No UAGs\n");
    while(puag) {
-	printf("UAG(%s) {",puag->name);
+	printf("UAG(%s)",puag->name);
 	puagname = (UAGNAME *)ellFirst(&puag->list);
+	if(puagname) printf(" {"); else printf("\n");
 	while(puagname) {
 	    printf("%s",puagname->user);
 	    puagname = (UAGNAME *)ellNext((ELLNODE *)puagname);
-	    if(puagname) printf(",");
+	    if(puagname) printf(","); else printf("}\n");
 	}
-	printf("}\n");
 	puag = (UAG *)ellNext((ELLNODE *)puag);
    }
    plag = (LAG *)ellFirst(&pasbase->lagList);
    if(!plag) printf("No LAGs\n");
    while(plag) {
-	printf("LAG(%s) {",plag->name);
+	printf("LAG(%s)",plag->name);
 	plagname = (LAGNAME *)ellFirst(&plag->list);
+	if(plagname) printf(" {"); else printf("\n");
 	while(plagname) {
 	    printf("%s",plagname->location);
 	    plagname = (LAGNAME *)ellNext((ELLNODE *)plagname);
-	    if(plagname) printf(",");
+	    if(plagname) printf(","); else printf("}\n");
 	}
-	printf("}\n");
 	plag = (LAG *)ellNext((ELLNODE *)plag);
    }
    pasg = (ASG *)ellFirst(&pasbase->asgList);
    if(!pasg) printf("No ASGs\n");
    while(pasg) {
-	printf("ASG(%s) {\n",pasg->name);
+	int print_end_brace;
+
+	printf("ASG(%s)",pasg->name);
 	pasginp = (ASGINP *)ellFirst(&pasg->inpList);
+	pasglevel = (ASGLEVEL *)ellFirst(&pasg->levelList);
+	if(pasginp || pasglevel) {
+	    printf(" {\n");
+	    print_end_brace = TRUE;
+	} else {
+	    printf("\n");
+	    print_end_brace = FALSE;
+	}
 	while(pasginp) {
 	    printf("\tINP%c(%s)\n",(pasginp->inpIndex + 'A'),pasginp->inp);
 	    pasginp = (ASGINP *)ellNext((ELLNODE *)pasginp);
 	}
-	pasglevel = (ASGLEVEL *)ellFirst(&pasg->levelList);
 	while(pasglevel) {
-	    printf("\tLEVEL(0x%.2x,%d) {\n",
-		pasglevel->level_mask,pasglevel->access);
+	    int	print_end_brace;
+
+	    printf("\tLEVEL(%d,%s)",
+		pasglevel->level,asAccessName[pasglevel->access]);
 	    pasguag = (ASGUAG *)ellFirst(&pasglevel->uagList);
+	    pasglag = (ASGLAG *)ellFirst(&pasglevel->lagList);
+	    if(pasguag || pasglag || pasglevel->calc) {
+		printf(" {\n");
+		print_end_brace = TRUE;
+	    } else {
+		printf("\n");
+		print_end_brace = FALSE;
+	    }
 	    if(pasguag) printf("\t\tUAG(");
 	    while(pasguag) {
 		printf("%s",pasguag->puag->name);
@@ -423,8 +440,8 @@ void asDump(
 		if(pasglag) printf(","); else printf(")\n");
 	    }
 	    if(pasglevel->calc) printf("\t\tCALC(\"%s\")\n",pasglevel->calc);
+	    if(print_end_brace) printf("\t}\n");
 	    pasglevel = (ASGLEVEL *)ellNext((ELLNODE *)pasglevel);
-	    if(!pasglevel) printf("\t}\n");
 	}
 	pasgmember = (ASGMEMBER *)ellFirst(&pasg->memberList);
 	if(pasgmember) printf("\tMEMBERLIST\n");
@@ -446,7 +463,7 @@ void asDump(
 	    }
 	    pasgmember = (ASGMEMBER *)ellNext((ELLNODE *)pasgmember);
 	}
-	printf("}\n");
+	if(print_end_brace) printf("}\n");
 	pasg = (ASG *)ellNext((ELLNODE *)pasg);
    }
 }
@@ -556,22 +573,26 @@ static UAG *asUagAdd(char *uagName)
    int cmpvalue;

    /*Insert in alphabetic order*/
-    pprev = pnext = (UAG *)ellFirst(&pasbase->uagList);
+    pnext = (UAG *)ellFirst(&pasbase->uagList);
    while(pnext) {
 	cmpvalue = strcmp(uagName,pnext->name);
-	if(cmpvalue > 0) break;
+	if(cmpvalue < 0) break;
 	if(cmpvalue==0) {
 	    errMessage(-1,"Duplicate User Access Group");
 	    return(NULL);
 	}
-	pprev = pnext;
 	pnext = (UAG *)ellNext((ELLNODE *)pnext);
    }
    puag = asCalloc(1,sizeof(UAG)+strlen(uagName)+1);
    ellInit(&puag->list);
    puag->name = (char *)(puag+1);
    strcpy(puag->name,uagName);
-    ellInsert(&pasbase->uagList,(ELLNODE *)pprev,(ELLNODE *)puag);
+    if(pnext==NULL) { /*Add to end of list*/
+	ellAdd(&pasbase->uagList,(ELLNODE *)puag);
+    } else {
+	pprev = (UAG *)ellPrevious((ELLNODE *)pnext);
+        ellInsert(&pasbase->uagList,(ELLNODE *)pprev,(ELLNODE *)puag);
+    }
    return(puag);
 }

@@ -586,7 +607,7 @@ static long asUagAddUser(UAG *puag,char *user)
    ellAdd(&puag->list,(ELLNODE *)puagname);
    return(0);
 }
-
+
 static LAG *asLagAdd(char *lagName)
 {
    LAG *pprev;
@@ -595,22 +616,26 @@ static LAG *asLagAdd(char *lagName)
    int	cmpvalue;

    /*Insert in alphabetic order*/
-    pprev = pnext = (LAG *)ellFirst(&pasbase->lagList);
+    pnext = (LAG *)ellFirst(&pasbase->lagList);
    while(pnext) {
 	cmpvalue = strcmp(lagName,pnext->name);
-	if(cmpvalue > 0) break;
+	if(cmpvalue < 0) break;
 	if(cmpvalue==0) {
 	    errMessage(-1,"Duplicate Location Access Group");
 	    return(NULL);
 	}
-	pprev = pnext;
 	pnext = (LAG *)ellNext((ELLNODE *)pnext);
    }
    plag = asCalloc(1,sizeof(LAG)+strlen(lagName)+1);
    ellInit(&plag->list);
    plag->name = (char *)(plag+1);
    strcpy(plag->name,lagName);
-    ellInsert(&pasbase->lagList,(ELLNODE *)pprev,(ELLNODE *)plag);
+    if(pnext==NULL) { /*Add to end of list*/
+	ellAdd(&pasbase->lagList,(ELLNODE *)plag);
+    } else {
+	pprev = (LAG *)ellPrevious((ELLNODE *)pnext);
+	ellInsert(&pasbase->lagList,(ELLNODE *)pprev,(ELLNODE *)plag);
+    }
    return(plag);
 }

@@ -634,20 +659,19 @@ static ASG *asAsgAdd(char *asgName)
    int cmpvalue;

    /*Insert in alphabetic order*/
-    pprev = pnext = (ASG *)ellFirst(&pasbase->asgList);
+    pnext = (ASG *)ellFirst(&pasbase->asgList);
    while(pnext) {
 	cmpvalue = strcmp(asgName,pnext->name);
-	if(cmpvalue > 0) break;
+	if(cmpvalue < 0) break;
 	if(cmpvalue==0) {
 	    if(strcmp(DEFAULT,pnext->name)==0) {
 		if(ellCount(&pnext->inpList)==0
 		&& ellCount(&pnext->levelList)==0)
 			return(pnext);
 	    }
-	    errMessage(-1,"Access Security Group");
+	    errMessage(S_asLib_dupAsg,NULL);
 	    return(NULL);
 	}
-	pprev = pnext;
 	pnext = (ASG *)ellNext((ELLNODE *)pnext);
    }
    pasg = asCalloc(1,sizeof(ASG)+strlen(asgName)+1);
@@ -656,7 +680,12 @@ static ASG *asAsgAdd(char *asgName)
    ellInit(&pasg->memberList);
    pasg->name = (char *)(pasg+1);
    strcpy(pasg->name,asgName);
-    ellInsert(&pasbase->asgList,(ELLNODE *)pprev,(ELLNODE *)pasg);
+    if(pnext==NULL) { /*Add to end of list*/
+	ellAdd(&pasbase->asgList,(ELLNODE *)pasg);
+    } else {
+	pprev = (ASG *)ellPrevious((ELLNODE *)pnext);
+	ellInsert(&pasbase->asgList,(ELLNODE *)pprev,(ELLNODE *)pasg);
+    }
    return(pasg);
 }

@@ -673,9 +702,8 @@ static long asAsgAddInp(ASG *pasg,char *inp,int inpIndex)
    ellAdd(&pasg->inpList,(ELLNODE *)pasginp);
    return(0);
 }
-
-static ASGLEVEL *asAsgAddLevel(ASG *pasg,asAccessRights access,
-	int levlow,int levHigh)
+
+static ASGLEVEL *asAsgAddLevel(ASG *pasg,asAccessRights access,int level)
 {
    ASGLEVEL	*pasglevel;
    int		bit;
@@ -683,9 +711,7 @@ static ASGLEVEL *asAsgAddLevel(ASG *pasg,asAccessRights access,
    if(!pasg) return(0);
    pasglevel = asCalloc(1,sizeof(ASGLEVEL));
    pasglevel->access = access;
-    for(bit=levlow; bit<=levHigh; bit++) {
-	pasglevel->level_mask |= (1<<bit);
-    }
+    pasglevel->level = level;
    ellInit(&pasglevel->uagList);
    ellInit(&pasglevel->lagList);
    ellAdd(&pasg->levelList,(ELLNODE *)pasglevel);
--- a/src/as/asLib_lex.l
+++ b/src/as/asLib_lex.l
@@ -16,7 +16,11 @@ LAG	{return(tokenLAG);}
 ASG	{return(tokenASG);}
 LEVEL	{return(tokenLEVEL);}
 CALC	{return(tokenCALC);}
-INP[A-L] {return(tokenINP);}
+INP[A-L] {/* If A-L is changed then ASMAXINP must also be changed*/
+	yylval.Int = (unsigned char)yytext[3];
+	yylval.Int -= 'A';
+	return(tokenINP);
+	}

 {integer}+ {
 	sscanf(yytext,"%d",&yylval.Int);
@@ -44,17 +48,18 @@ INP[A-L] {return(tokenINP);}
        return(tokenSTRING);
    }

-"{"     { return(O_BRACE);      }
-"}"     { return(C_BRACE);      }
-"("     { return(O_PAREN);      }
-")"     { return(C_PAREN);      }
-[,\-*]	{ return(yytext[0]);	}
+"{"     { return(yytext[0]);      }
+"}"     { return(yytext[0]);      }
+"("     { return(yytext[0]);      }
+")"     { return(yytext[0]);      }
+","	{ return(yytext[0]);	}
+^#.*
 [ \t\r]	;
 \n      { line_num ++;}
 .       { 
 		char message[20];
 	  
-		sprintf(message,"invalid charecter '%c'",yytext[0]);
+		sprintf(message,"invalid character '%c'",yytext[0]);
 	  	yyerror(message);
 	}