void verifyAndOrOp( struct expr_sem *op1, OPERATOR operator, struct expr_sem *op2 )
{
if( (op1->pType->type)==ERROR_t || (op2->pType->type)==ERROR_t ) {
op1->pType->type = ERROR_t;
}
else if( op2->beginningOp != NONE_t ) {
fprintf( stdout, "########## Error at Line#%d: adjacent operator '", linenum); semError = __TRUE;
printOperator( operator );
fprintf( stdout ,"' and '" );
printOperator( op2->beginningOp );
fprintf( stdout ,"' ##########\n" );
op1->pType->type = ERROR_t;
}
else if( (op1->pType->dimNum)!=0 || (op2->pType->dimNum)!=0 ) {
fprintf( stdout, "########## Error at Line#%d: operand(s) between '", linenum ); semError = __TRUE;
printOperator( operator );
fprintf( stdout, "' are array_type ##########\n" );
op1->pType->type = ERROR_t;
}
else if( (op1->pType->type)!=BOOLEAN_t || (op2->pType->type)!=BOOLEAN_t ) {
fprintf( stdout, "########## Error at Line#%d: operand(s) between '", linenum ); semError = __TRUE;
printOperator( operator );
fprintf( stdout, "' are not boolean ##########\n" );
op1->pType->type = ERROR_t;
}
else { // pass verification, result is boolean!
op1->pType->type = BOOLEAN_t;
}
}
void verifyRelOp( struct expr_sem *op1, OPERATOR operator, struct expr_sem *op2 )
{
if( (op1->pType->type)==ERROR_t || (op2->pType->type)==ERROR_t ) {
op1->pType->type = ERROR_t;
}
else if( op2->beginningOp != NONE_t ) {
fprintf( stdout, "########## Error at Line#%d: adjacent operator '", linenum); semError = __TRUE;
printOperator( operator );
fprintf( stdout ,"' and '" );
printOperator( op2->beginningOp );
fprintf( stdout ,"'\n" );
op1->pType->type = ERROR_t;
}
else if( (op1->pType->dimNum)!=0 || (op2->pType->dimNum)!=0 ) {
fprintf( stdout, "########## Error at Line#%d: operand(s) between '", linenum); semError = __TRUE;
printOperator( operator );
fprintf( stdout ,"' are array_type ##########\n" );
op1->pType->type = ERROR_t;
}
else if( !((op1->pType->type==INTEGER_t || op1->pType->type==FLOAT_t || op1->pType->type==DOUBLE_t) && (op2->pType->type==INTEGER_t || op2->pType->type==FLOAT_t || op2->pType->type==DOUBLE_t)) ) {
if( op1->pType->type==BOOLEAN_t && op2->pType->type==BOOLEAN_t && ( operator==EQ_t || operator==NE_t )){}
else{
fprintf( stdout, "########## Error at Line#%d: operand(s) between '", linenum); semError = __TRUE;
printOperator( operator );
fprintf( stdout, "' are not integer/real or the same type##########\n" );
op1->pType->type = ERROR_t;
}
}
else { // pass verification, result is boolean!
op1->pType->type = BOOLEAN_t;
}
}
void verifyRelOp( struct expr_sem *op1, OPERATOR operator, struct expr_sem *op2 )
{
if( (op1->pType->type)==ERROR_t || (op2->pType->type)==ERROR_t ) {
op1->pType->type = ERROR_t;
}
else if( op2->beginningOp != NONE_t ) {
fprintf( stdout, "<Error> found in Line %d: adjacent operator '", linenum);
printOperator( operator );
fprintf( stdout ,"' and '" );
printOperator( op2->beginningOp );
fprintf( stdout ,"'\n" );
op1->pType->type = ERROR_t;
}
else if( (op1->pType->dimNum)!=0 || (op2->pType->dimNum)!=0 ) {
fprintf( stdout, "<Error> found in Line %d: operand(s) between '", linenum);
printOperator( operator );
fprintf( stdout ,"' are array_type \n" );
op1->pType->type = ERROR_t;
}
else if( !((op1->pType->type==INTEGER_t || op1->pType->type==REAL_t ) && (op2->pType->type==INTEGER_t || op2->pType->type==REAL_t)) ) {
fprintf( stdout, "<Error> found in Line %d: operand(s) between '", linenum);
printOperator( operator );
fprintf( stdout, "' are not integer or real \n" );
op1->pType->type = ERROR_t;
}
else { // pass verification, result is boolean!
op1->pType->type = BOOLEAN_t;
}
}
void verifyArithmeticOp( struct expr_sem *op1, OPERATOR operator, struct expr_sem *op2 )
{
if( (op1->pType->type)==ERROR_t || (op2->pType->type)==ERROR_t ) {
op1->pType->type = ERROR_t;
}
else if( op2->beginningOp != NONE_t ) {
fprintf( stdout, "########## Error at Line#%d: adjacent operator '", linenum); semError = __TRUE;
printOperator( operator );
fprintf( stdout ,"' and '" );
printOperator( op2->beginningOp );
fprintf( stdout ,"'\n" );
op1->pType->type = ERROR_t;
}
else if( (op1->pType->dimNum)!=0 || (op2->pType->dimNum)!=0 ) {
fprintf( stdout, "########## Error at Line#%d: operand(s) between '", linenum); semError = __TRUE;
printOperator( operator );
fprintf( stdout ,"' are array_type ##########\n" );
op1->pType->type = ERROR_t;
}
else {
if( op1->pType->type==STRING_t && op2->pType->type==STRING_t ) { // string concatenation
fprintf( stdout, "########## Error at Line#%d: operand(s) between '", linenum); semError = __TRUE;
printOperator( operator );
fprintf( stdout ,"' are string type ##########\n" );
}
else if( ((op1->pType->type==INTEGER_t || op1->pType->type==FLOAT_t || op1->pType->type==DOUBLE_t) && \
(op2->pType->type==INTEGER_t || op2->pType->type==FLOAT_t || op2->pType->type==DOUBLE_t)) ) { // need to consider type coercion
if( op1->pType->type==INTEGER_t && op2->pType->type==INTEGER_t ) {
op1->pType->type = INTEGER_t;
}
else {
if(op1->pType->type==DOUBLE_t || op2->pType->type==DOUBLE_t){
op1->pType->type = DOUBLE_t;
}
else
op1->pType->type = FLOAT_t;
}
}
else { // fail verify, dump error message
fprintf( stdout, "########## Error at Line#%d: operand(s) between '", linenum); semError = __TRUE;
printOperator( operator );
fprintf( stdout, "' are not integer/real ##########\n" );
op1->pType->type = ERROR_t;
}
}
}
void printSubExpr(Node* n)
{
switch (n->type)
{
case ntVal:
printVal(n);
break;
case ntVar:
printVarName(n);
break;
case ntOperator:
printf("(");
if (n->op == opCond)
{
printSubExpr(n->child[2]);
printf("?");
printSubExpr(n->child[0]);
printf(":");
printSubExpr(n->child[1]);
}
else if (operatorIsBinary(n->op))
{
printSubExpr(n->child[0]);
printOperator(n->op);
printSubExpr(n->child[1]);
}
else
{
if (operatorIsPostUnary(n->op))
{
printSubExpr(n->child[0]);
printOperator(n->op);
}
else
{
printOperator(n->op);
if (n->op == opSizeOf) printf(" ");
printSubExpr(n->child[0]);
}
}
printf(")");
break;
}
}
// ----------------------------------------------------------- Print operators stack
void printAtors( const Stack Ators )
{
Iter si = newIter( Ators );
printf( "\nStack has %d items: bottom<[ ", sizeStack( Ators ) );
while (hasNextIter( si )) {
printOperator( (const Operator) nextIter( si ) );
}
printf( " ]>top\n" );
freeIter( si );
}
void verifyModOp( struct expr_sem *op1, struct expr_sem *op2 )
{
if( (op1->pType->type)==ERROR_t || (op2->pType->type)==ERROR_t ) {
op1->pType->type = ERROR_t;
}
else if( op2->beginningOp != NONE_t ) {
fprintf( stdout, "########## Error at Line#%d: adjacent operator 'mod", linenum); semError = __TRUE;
fprintf( stdout ,"' and '" );
printOperator( op2->beginningOp );
fprintf( stdout ,"'\n" );
op1->pType->type = ERROR_t;
}
else if( (op1->pType->dimNum)!=0 || (op2->pType->dimNum)!=0 ) {
fprintf( stdout, "########## Error at Line#%d: operand(s) between 'mod' are array_type\n", linenum ); semError = __TRUE;
op1->pType->type = ERROR_t;
}
else if( (op1->pType->type)!=INTEGER_t || (op2->pType->type)!=INTEGER_t ) {
fprintf( stdout, "########## Error at Line#%d: operand(s) between 'mod' are not integer\n", linenum ); semError = __TRUE;
op1->pType->type = ERROR_t;
}
else { // pass verify
op1->pType->type = INTEGER_t;
}
}
