//DEF074278: Java VM requires more command line testArguments.
void Defect_DEF074278_Part2()
{
TBuf<180> testArguments(_L("one two three four five six seven eight nine ten eleven twelve thirteen fourteen fifteen sixteen seventeen eighteen nineteen twenty twenty-one twenty-two twenty-three twenty-four "));
TBuf<210> inputArguments;
TUint testArgNo = 25;
int argc=0;
char** argv=0;
char** envp=0;
TheTest.Printf(_L("Retrieving the arguments passed in from T_UCRT0P1\n"));
__crt0(argc,argv,envp); // get args & environment from somewhere
//Get all the arguments into a descriptor, beginning at pos 1, as pos 0 contains
//the T_UCRT0P2 exe path and name.
for (TInt i=1; i < argc; i++)
{
char *str=argv[i];
while(*str)
inputArguments.Append((TChar)*str++);
inputArguments.Append(' ');
}
//tests all the arguments were passed to the new process correctly.
TheTest.Printf(_L("Checking all arguements were passed to the new process correctly... "));
TEST(testArguments == inputArguments );
TEST2(testArgNo, argc);
exit(0);
}
int main(int argc, char **argv) {
char buffer[1024];
int decpt, sign;
char *rve;
pspDebugScreenInit();
pspDebugScreenPrintf("%d", 0);
checkSetLessThan();
checkLeftShift();
checkRightShift();
/*
dtoa(double d, int mode, int ndigits, int *decpt, int *sign, char **rve);
*/
emitString((char *)_itoa(12345678, buffer, 10));
emitLong(0x0123456789ABCDEFL);
emitLong(testArguments(0x100, 0x1234567800000000L, 9.0f));
test();
checkFloat24(1.0f);
emitFloat(2.0f / GlobalFloat);
//emitString(dtoa(1234.567, 0, 10, &decpt, &sign, &rve));
return 0;
}
void verify(struct a_NODE * node_p)
{
struct a_NODE * aux;
if(node_p)
{
struct a_NODE node_ = *node_p;
switch(node_.token)
{
// TOKENS
case LIT_TRUE:
break;
case LIT_FALSE:
break;
case LIT_INTEGER:
break;
case TK_IDENTIFIER:
break;
case LIT_CHAR:
break;
case LIT_STRING:
break;
// LIST
case LIST:
verify((node_.sons[0]));
verify((node_.sons[1]));
break;
// TYPE
case KW_BOOL:
break;
case KW_WORD:
break;
case KW_BYTE:
break;
// FUNC_DECLARATION
case ARGUMENTS:
verify((node_.sons[0]));
verify((node_.sons[1]));
if((node_.sons[2])!=NULL)
{
verify((node_.sons[2]));
}
break;
case D_NODE: // GAMBIARRATION
verify((node_.sons[0]));
verify((node_.sons[1]));
break;
case FUNC_DECLARATION:
/*node_.sons[1]->node->type = ID_FUNC;
if(node_.sons[0]->token == KW_BOOL)
node_.sons[1]->node->dataType = ID_BOOL;
else if(node_.sons[0]->token == KW_WORD)
node_.sons[1]->node->dataType = ID_WORD;
else if(node_.sons[0]->token == KW_BYTE)
node_.sons[1]->node->dataType = ID_BYTE;
currentFunction = node_.sons[1]->node;
aux = node_.sons[2];
for(aux = node_.sons[2] ; aux != NULL ; aux = aux->sons[2])
{
aux->sons[1]->node->type = ID_SCALAR;
if(aux->sons[0]->token == KW_BOOL)
{
aux->sons[1]->node->dataType = ID_BOOL;
}
else if(aux->sons[0]->token == KW_WORD)
{
aux->sons[1]->node->dataType = ID_WORD;
}
else if(aux->sons[0]->token == KW_BYTE)
{
aux->sons[1]->node->dataType = ID_BYTE;
}
node_.sons[1]->node->args = insertInIntList(aux->sons[0]->token,node_.sons[1]->node->args);
}
*/
currentFunction = node_.sons[1]->node;
verify((node_.sons[3])); // SEMPRE D_NODE , GAMBIARRATIONN
break;
// DECLARATIONS
case PROG:
verify((node_.sons[0]));
verify((node_.sons[1]));
break;
case DECLARATION:
if(node_.sons[1]->node->type != SYMBOL_IDENTIFIER)
{hasError++;printf("Semantic error on line %d: variable %s already declared \n",node_.lineNumber,node_.sons[1]->node->value);}
else
{
if(node_.sons[0]->token == KW_BOOL)
node_.sons[1]->node->dataType = ID_BOOL;
else if(node_.sons[0]->token == KW_WORD)
node_.sons[1]->node->dataType = ID_WORD;
else if(node_.sons[0]->token == KW_BYTE)
node_.sons[1]->node->dataType = ID_BYTE;
node_.sons[1]->node->type = ID_SCALAR;
if(!(
(node_.sons[0]->token == KW_BOOL && (node_.sons[2]->token == LIT_TRUE || node_.sons[2]->token == LIT_FALSE)) ||
(((node_.sons[0]->token == KW_WORD) || (node_.sons[0]->token == KW_BYTE)) && ((node_.sons[2]->token == LIT_INTEGER)||(node_.sons[2]->token == LIT_CHAR)))))
{hasError++;printf("Semantic error on line %d: Scalar initialized wrong.\n",node_.lineNumber);}
}
break;
case DECLARATION_POINTER:
if(node_.sons[1]->node->type != SYMBOL_IDENTIFIER)
{hasError++;printf("Semantic error on line %d: variable already declared\n",node_.lineNumber);}
else
{
if(node_.sons[0]->token == KW_BOOL)
node_.sons[1]->node->dataType = ID_BOOL;
else if(node_.sons[0]->token == KW_WORD)
node_.sons[1]->node->dataType = ID_WORD;
else if(node_.sons[0]->token == KW_BYTE)
node_.sons[1]->node->dataType = ID_BYTE;
node_.sons[1]->node->type = ID_POINTER;
}
break;
case DECLARATION_VEC:
if(node_.sons[1]->node->type != SYMBOL_IDENTIFIER)
{hasError++;printf("Semantic error on line %d: variable already declared\n",node_.lineNumber);}
else
{
if(node_.sons[0]->token == KW_BOOL)
node_.sons[1]->node->dataType = ID_BOOL;
else if(node_.sons[0]->token == KW_WORD)
node_.sons[1]->node->dataType = ID_WORD;
else if(node_.sons[0]->token == KW_BYTE)
node_.sons[1]->node->dataType = ID_BYTE;
node_.sons[1]->node->type = ID_VECTOR;
if(!isInt(node_.sons[2]))
{hasError++;printf("Semantic error on line %d: Vector with not-integer size\n",node_.lineNumber);}
}
break;
case DECLARATION_VEC_INIT:
if(node_.sons[1]->node->type != SYMBOL_IDENTIFIER)
{hasError++;printf("Semantic error on line %d: variable already declared\n",node_.lineNumber);}
else
{
if(node_.sons[0]->token == KW_BOOL)
node_.sons[1]->node->dataType = ID_BOOL;
else if(node_.sons[0]->token == KW_WORD)
node_.sons[1]->node->dataType = ID_WORD;
else if(node_.sons[0]->token == KW_BYTE)
node_.sons[1]->node->dataType = ID_BYTE;
node_.sons[1]->node->type = ID_VECTOR;
if(!isInt(node_.sons[2]))
{hasError++;printf("Semantic error on line %d: Vector with not-integer size\n",node_.lineNumber);}
if(!(node_.sons[3]->token == LIST))
{hasError++;printf("Semantic error on line %d: Vector initialized wrong.\n",node_.lineNumber);}
}
break;
// EXPRESSION
case '&':
if(!(node_.sons[0]->node->type==ID_SCALAR))
{hasError++;printf("Semantic error: getting reference for not-scalar on line %d\n",node_.lineNumber);}
verify(node_.sons[0]);
break;
case POINTER:
if(!(node_.sons[0]->node->type==ID_POINTER))
{hasError++;printf("Semantic error: using not-pointer as pointer on line %d\n",node_.lineNumber);}
verify(node_.sons[0]);
break;
case '*':
if(!(isInt(node_.sons[0]) && isInt(node_.sons[1])))
{hasError++;printf("Semantic error: multiplying not integer on line %d\n",node_.lineNumber);}
verify(node_.sons[0]);
verify(node_.sons[1]);
break;
case '(':
verify((node_.sons[0]));
break;
case '+':
if(!(isInt(node_.sons[0]) && isInt(node_.sons[1])))
{hasError++;printf("Semantic error: adding not integer on line %d\n",node_.lineNumber);}
verify(node_.sons[0]);
verify(node_.sons[1]);
break;
case '-':
if(!(isInt(node_.sons[0]) && isInt(node_.sons[1])))
{hasError++;printf("Semantic error: subtracting not integer on line %d\n",node_.lineNumber);}
verify(node_.sons[0]);
verify(node_.sons[1]);
break;
case '/':
if(!(isInt(node_.sons[0]) && isInt(node_.sons[1])))
{hasError++;printf("Semantic error: dividing not integer on line %d\n",node_.lineNumber);}
verify(node_.sons[0]);
verify(node_.sons[1]);
break;
case OR:
if(!(isBoolean(node_.sons[0]) && isBoolean(node_.sons[1])))
{hasError++;printf("Semantic error: '||' with not boolean on line %d\n",node_.lineNumber);}
verify(node_.sons[0]);
verify(node_.sons[1]);
break;
case AND:
if(!(isBoolean(node_.sons[0]) && isBoolean(node_.sons[1])))
{hasError++;printf("Semantic error: '&&' with not boolean on line %d\n",node_.lineNumber);}
verify(node_.sons[0]);
verify(node_.sons[1]);
break;
case LE:
verify(node_.sons[0]);
verify(node_.sons[1]);
break;
case EQ:
verify(node_.sons[0]);
verify(node_.sons[1]);
break;
case GE:
verify(node_.sons[0]);
verify(node_.sons[1]);
break;
case NE:
verify(node_.sons[0]);
verify(node_.sons[1]);
break;
case '>':
if(!(isInt(node_.sons[0]) && isInt(node_.sons[1])))
{hasError++;printf("Semantic error: '>' with not integer on line %d\n",node_.lineNumber);}
verify(node_.sons[0]);
verify(node_.sons[1]);
break;
case '<':
if(!(isInt(node_.sons[0]) && isInt(node_.sons[1])))
{hasError++;printf("Semantic error: '<' with not integer on line %d\n",node_.lineNumber);}
verify(node_.sons[0]);
verify(node_.sons[1]);
break;
case VECCALL:
if(node_.sons[0]->node->type == SYMBOL_IDENTIFIER)
{hasError++;printf("Semantic error: Vector %s not declared used on line %d\n",node_.sons[0]->node->value,node_.lineNumber);}
if(!isInt(node_.sons[1]))
{hasError++;printf("Semantic error: Vector index not integer on line %d\n",node_.lineNumber);}
if(!(node_.sons[0]->node->type==ID_VECTOR))
{hasError++;printf("Semantic error: Something not-vector used as vector on line %d\n",node_.lineNumber);}
break;
case NORMAL:
if(node_.sons[0]->node->type == SYMBOL_IDENTIFIER)
{hasError++;printf("Semantic error: Variable %s not declared used on line %d\n",node_.sons[0]->node->value,node_.lineNumber);}
if(node_.sons[0]->node->type != ID_SCALAR && node_.sons[0]->node->type != ID_POINTER)
{hasError++;printf("Semantic error: Something not-scalar used as scalar on line %d\n",node_.lineNumber);}
break;
// FUNCALL ARGCALL CMD_SEQ
case FUNCALL:
if(node_.sons[0]->node->type == SYMBOL_IDENTIFIER)
{hasError++;printf("Semantic error: Function %s not yet declared used on line %d\n",node_.sons[0]->node->value,node_.lineNumber);}
if(!(node_.sons[0]->node->type==ID_FUNC))
{hasError++;printf("Semantic error: Something not-function used as function on line %d\n",node_.lineNumber);}
testArguments(node_.sons[0]->node,node_.sons[1]);
break;
case ARGCALL:
break;
case CMD_SEQ:
verify((node_.sons[0]));
verify((node_.sons[1]));
break;
// OUTPUT
case OUTPUT_L:
verify(node_.sons[0]);
verify(node_.sons[1]);
break;
// CMD
case INPUT:
verify(node_.sons[0]);
break;
case OUTPUT:
verify(node_.sons[0]);
break;
case RETURN:
if(!currentFunction)
{hasError++;printf("Semantic error: 'return' in wrong place on line %d\n",node_.lineNumber);}
else if(currentFunction->dataType == ID_WORD)
{
if(!isInt(node_.sons[0]))
{hasError++;printf("Semantic error: wrong return type for function %s, on line %d\n",currentFunction->value,node_.lineNumber);}
}
else if(currentFunction->dataType == ID_BYTE)
{
if(!isInt(node_.sons[0]))
{hasError++;printf("Semantic error: wrong return type for function %s, on line %d\n",currentFunction->value,node_.lineNumber);}
}
else if(currentFunction->dataType == ID_BOOL)
{
if(!isBoolean(node_.sons[0]))
{hasError++;printf("Semantic error: wrong return type for function %s, should be boolean, on line %d\n",currentFunction->value,node_.lineNumber);}
}
break;
case BLOCK:
verify((node_.sons[0]));
break;
case '=':
verify(node_.sons[1]); ////////////////////////////////////////////////////////////////////// REMEMBER
if(node_.sons[0]->token == VECCALL)
{
if(!(node_.sons[0]->sons[0]->node->type == ID_VECTOR))
{hasError++;printf("Semantic error: not-vector used as vector on line %d\n",node_.lineNumber);}
if(!isInt(node_.sons[0]->sons[1]))
{hasError++;printf("Semantic error: vector index is not integer on line %d\n",node_.lineNumber);}
if(node_.sons[0]->sons[0]->node->dataType == ID_WORD)
{
if(!isInt(node_.sons[1]))
{hasError++;printf("Semantic error: atributing to integer vector from not-integer on line %d\n",node_.lineNumber);}
}
else if(node_.sons[0]->sons[0]->node->dataType == ID_BYTE)
{
if(!isInt(node_.sons[1]))
{hasError++;printf("Semantic error: atributing to integer vector from not-integer on line %d\n",node_.lineNumber);}
}
else if(node_.sons[0]->sons[0]->node->dataType == ID_BOOL)
{
if(!isBoolean(node_.sons[1]))
{hasError++;printf("Semantic error: atributing to boolean vector from not-boolean on line %d\n",node_.lineNumber);}
}
else
{hasError++;printf("Semantic error: identifier %s not declared on line %d\n",node_.sons[0]->node->value,node_.lineNumber);}
}
else if(node_.sons[0]->token == POINTER)
{
if(node_.sons[0]->sons[0]->node->type != ID_POINTER)
{hasError++;printf("Semantic error: dereferencing non-pointer on line %d\n",node_.lineNumber);}
if(node_.sons[0]->sons[0]->node->dataType == ID_WORD)
{
if(!isInt(node_.sons[1]))
{hasError++;printf("Semantic error: atributing to integer scalar from not-integer on line %d\n",node_.lineNumber);}
}
else if(node_.sons[0]->sons[0]->node->dataType == ID_BYTE)
{
if(!isInt(node_.sons[1]))
{hasError++;printf("Semantic error: atributing to integer scalar from not-integer on line %d\n",node_.lineNumber);}
}
else if(node_.sons[0]->sons[0]->node->dataType == ID_BOOL)
{
if(!isBoolean(node_.sons[1]))
{hasError++;printf("Semantic error: atributing to boolean scalar from not-boolean on line %d\n",node_.lineNumber);}
}
else
{hasError++;printf("Semantic error: identifier %s not declared on line %d\n",node_.sons[0]->node->value,node_.lineNumber);}
}
else if(node_.sons[0]->node->type == ID_POINTER)
{
if(!isPt(node_.sons[1]))
{
{hasError++;printf("Semantic error: atributin a non-pointer to a pointer on line %d\n",node_.lineNumber);}
}
}
else if(node_.sons[0]->node->type == ID_SCALAR)
{
if(node_.sons[0]->node->type == ID_VECTOR)
{hasError++;printf("Semantic error: vector used as not-vector on line %d\n",node_.lineNumber);}
if(node_.sons[0]->node->dataType == ID_WORD)
{
if(!isInt(node_.sons[1]))
{hasError++;printf("Semantic error: atributing to integer scalar from not-integer on line %d\n",node_.lineNumber);}
}
else if(node_.sons[0]->node->dataType == ID_BYTE)
{
if(!isInt(node_.sons[1]))
{hasError++;printf("Semantic error: atributing to integer scalar from not-integer on line %d\n",node_.lineNumber);}
}
else if(node_.sons[0]->node->dataType == ID_BOOL)
{
if(!isBoolean(node_.sons[1]))
{hasError++;printf("Semantic error: atributing to boolean scalar from not-boolean on line %d\n",node_.lineNumber);}
}
else
{hasError++;printf("Semantic error: identifier %s not declared on line %d\n",node_.sons[0]->node->value,node_.lineNumber);}
}
else
{
{hasError++;printf("Semantic error: atributing to non-variable on line %d\n",node_.lineNumber);}
}
break;
case IF_THEN:
if(!isBoolean(node_.sons[0]))
{hasError++;printf("Semantic error: if called with not-boolean on line %d\n",node_.lineNumber);}
verify(node_.sons[1]);
break;
case IF_THEN_ELSE:
if(!isBoolean(node_.sons[0]))
{hasError++;printf("Semantic error: if called with not-boolean on line %d\n",node_.lineNumber);}
verify(node_.sons[1]);
verify(node_.sons[2]);
break;
case LOOP :
if(!isBoolean(node_.sons[0]))
{hasError++;printf("Semantic error: loop called with not-boolean on line %d\n",node_.lineNumber);}
verify(node_.sons[1]);
break;
// DEFAULT
default:
break;
} // switch
} // if node
}
