void test_evaluatePrefixesAndNumber_should_stop_the_loop_after_encounter_a_number(void){
CEXCEPTION_T e;
Stack *numberStack=createStack();
Stack *operatorStack=createStack();
Text *newText=textNew("-+-20+");
String *tokenizer = stringNew(newText);
//printf("Test evaluatePrefix should stop the loop after encounter number\n");
Token *token=getToken(tokenizer);
evaluatePrefixesAndNumber(tokenizer,token,numberStack,operatorStack);
TEST_ASSERT_NOT_NULL(token);
TEST_ASSERT_EQUAL_OPERATOR(MINUS_OP,stackPop(operatorStack));
TEST_ASSERT_EQUAL_OPERATOR(PLUS_OP,stackPop(operatorStack));
TEST_ASSERT_EQUAL_OPERATOR(MINUS_OP,stackPop(operatorStack));
TEST_ASSERT_EQUAL_NUMBER(20,stackPop(numberStack));
}
void test_FA_extract1bitsACCESSBANKED_should_throw_error(void){
int value;
int e;
Text *text = textNew("135");
String *str = stringNew(text);
extractACCESSBANKED_ExpectAndThrow(str, 2);
Try{
value = extract1bitsACCESSBANKED(str, 0x123);
}Catch(e){
TEST_ASSERT_EQUAL(ERR_ILLEGAL_ARGUMENT, e);
}
}
void test_evaluatePrefixesAndNumber_should_push_more_than_one_prefix_operator_and_number_into_stack_with_loop(void){
Token *token;
Stack *numberStack=createStack();
Stack *operatorStack=createStack();
Text *newText=textNew("-+14");
String *tokenizer = stringNew(newText);
//printf("Test evaluatePrefix push more than one prefix operator with loop\n");
token=getToken(tokenizer);
evaluatePrefixesAndNumber(tokenizer,token,numberStack,operatorStack);
TEST_ASSERT_EQUAL_OPERATOR(PLUS_OP,stackPop(operatorStack));
TEST_ASSERT_EQUAL_OPERATOR(MINUS_OP,stackPop(operatorStack));
TEST_ASSERT_EQUAL_NUMBER(14,stackPop(numberStack));
TEST_ASSERT_NOT_NULL(token);
}
void test_NS_operand1_ERR_EMPTY_ARGUMENT_should_throw_error(void){
int value;
int e;
Text *text = textNew("135");
String *str = stringNew(text);
extractValue_ExpectAndThrow(str, 3);
Try{
value = NS(str);
}Catch(e){
TEST_ASSERT_EQUAL(ERR_EMPTY_ARGUMENT, e);
}
}
/* Get the substring location out from the string
* input :
* start is the start location for the substring
* length is the total character of the substring
* return :
* return the subString
*/
String *stringSubString(String *str , int start , int length)
{
String *subStr = stringNew(str->string);
if(start >= strlen(subStr->string))
{
subStr->startindex = strlen(subStr->string);
subStr->length = 0;
return subStr;
}
subStr->startindex = start;
subStr->length = length;
// printf("start = %d\n" , subStr->startindex);
// printf("length = %d\n" , subStr->length);
return subStr;
}
/*!
* bmfCreate()
*
* Input: dir (<optional> directory holding pixa of character set)
* fontsize (4, 6, 8, ... , 20)
* Return: bmf (holding the bitmap font and associated information)
*
* Notes:
* (1) If @dir == null, this generates the font bitmaps from a
* compiled string.
* (2) Otherwise, this tries to read a pre-computed pixa file with the
* 95 ascii chars in it. If the file is not found, it then
* attempts to generate the pixa and associated baseline
* data from a tiff image containing all the characters. If
* that fails, it uses the compiled string.
*/
L_BMF *
bmfCreate(const char *dir,
l_int32 fontsize)
{
L_BMF *bmf;
PIXA *pixa;
PROCNAME("bmfCreate");
if (fontsize < 4 || fontsize > 20 || (fontsize % 2))
return (L_BMF *)ERROR_PTR("fontsize must be in {4, 6, ..., 20}",
procName, NULL);
if ((bmf = (L_BMF *)CALLOC(1, sizeof(L_BMF))) == NULL)
return (L_BMF *)ERROR_PTR("bmf not made", procName, NULL);
if (!dir) { /* Generate from a string */
L_INFO("Generating pixa of bitmap fonts from string\n", procName);
pixa = pixaGenerateFontFromString(fontsize, &bmf->baseline1,
&bmf->baseline2, &bmf->baseline3);
} else { /* Look for the pixa in a directory */
L_INFO("Locating pixa of bitmap fonts in a file\n", procName);
pixa = pixaGetFont(dir, fontsize, &bmf->baseline1, &bmf->baseline2,
&bmf->baseline3);
if (!pixa) { /* Not found; make it from a file */
L_INFO("Generating pixa of bitmap fonts from file\n", procName);
pixa = pixaGenerateFontFromFile(dir, fontsize, &bmf->baseline1,
&bmf->baseline2, &bmf->baseline3);
if (!pixa) { /* Not made; make it from a string after all */
L_ERROR("Failed to make font; use string\n", procName);
pixa = pixaGenerateFontFromString(fontsize, &bmf->baseline1,
&bmf->baseline2, &bmf->baseline3);
}
}
}
if (!pixa) {
bmfDestroy(&bmf);
return (L_BMF *)ERROR_PTR("font pixa not made", procName, NULL);
}
bmf->pixa = pixa;
bmf->size = fontsize;
if (dir) bmf->directory = stringNew(dir);
bmfMakeAsciiTables(bmf);
return bmf;
}
void test_FA_operand2_ERR_ILLEGAL_ARGUMENT_should_mock_and_throw_error(void){
int value;
int e;
Text *text = textNew("135");
String *str = stringNew(text);
extractValue_ExpectAndReturn(str, 0x35);
extractACCESSBANKED_ExpectAndThrow(str, 2);
Try{
value = FA(str);
}Catch(e){
TEST_ASSERT_EQUAL(ERR_ILLEGAL_ARGUMENT, e);
}
}
void test_evaluatePrefixesAndNumber_should_throw_error_cannot_convert_prefix(void){
CEXCEPTION_T e;
Token *token;
Stack *numberStack=createStack();
Stack *operatorStack=createStack();
Text *newText=textNew("*18");
String *tokenizer = stringNew(newText);
//printf("Test evaluatePrefix throw error cannot convert to prefix\n");
token=getToken(tokenizer);
Try{
evaluatePrefixesAndNumber(tokenizer,token,numberStack,operatorStack);
TEST_FAIL_MESSAGE("Cannot convert to prefix");
}Catch(e){
TEST_ASSERT_EQUAL(ERR_CANNOT_CONVERT_TO_PREFIX,e);
}
}
void test_evaluatePrefixesAndNumber_should_throw_error_expect_a_number_after_prefix_operator(void){
CEXCEPTION_T e;
Token *token;
Stack *numberStack=createStack();
Stack *operatorStack=createStack();
Text *newText=textNew("-");
String *tokenizer = stringNew(newText);
//printf("Test evaluatePrefix throw error throw error expect a number after prefix operator\n");
token=getToken(tokenizer);
Try{
evaluatePrefixesAndNumber(tokenizer,token,numberStack,operatorStack);
TEST_FAIL_MESSAGE("Cannot expecting number");
}Catch(e){
TEST_ASSERT_EQUAL(ERR_EXPECTING_NUMBER,e);
}
}
void test_fsfd_operand2_ERR_NO_ARGUMENT_should_mock_and_throw_error(void){
int value;
int e;
Text *text = textNew("");
String *str = stringNew(text);
extractValue_ExpectAndThrow(str, 4);
Try{
value = FSFD(str);
}Catch(e){
TEST_ASSERT_EQUAL(ERR_NO_ARGUMENT, e);
}
}
/* To remove words not contain in ContainSet
* input :
* notContainSet is character that don't need to be remove
* return:
* Return the notRemovedWord start index and length
*/
String *stringRemoveWordNotContaining(String *str , char *notContainSet)
{
int i = str->startindex , j = 0 , firstFound = 0 , notInSet = 0;
String *notRemovedWord = stringNew(str->string); //create new String for notRemovedWord
notRemovedWord->length = 0;
while(i < strlen(str->string))
{
while(j != strlen(notContainSet))
{
if(str->string[i] != notContainSet[j])
{
if(!firstFound)
{
notRemovedWord->startindex = i; //first character found
firstFound = 1;
if(i != 0)
str->length = str->length - i;
}
notRemovedWord->length++; //one word is detected in ContainSet
str->startindex = i+1;
str->length--; //decrement once after one word removed
notInSet = 0;
goto jump;
}
if(firstFound == 1)
notInSet = 1;
j++;
}
if(notInSet == 1)
goto end;
jump:
i++;
j = 0;
}
end:
return notRemovedWord;
}
int evaluateExpression(char *expression){
Token *token;
Stack *numberStack=createStack();
Stack *operatorStack=createStack();
if(expression ==NULL){
Throw(ERR_NO_ARGUMENT);
}
Text *newText=textNew(expression);
String *tokenizer = stringNew(newText);
token=getToken(tokenizer);
if(token->type == IDENTIFIER_TOKEN){
Throw(ERR_NOT_ACCEPT_IDENTIFIER);
}else{
while(token!=NULL){
if(isOperator(token)){
if(((Operator*)token)->info->affix!=PREFIX)
tryConvertToPrefix((Operator*)token);
stackPush(token,operatorStack);
}else if(isNumber(token)){
stackPush(token,numberStack);
break;
}else
Throw(ERR_INVALID_IDENTIFIER);
token=getToken(tokenizer);
if(token==NULL)
break;
}
}
while((token=getToken(tokenizer))!=NULL ){
evaluatePostfixesPrefixesAndInfixes(expression,token,numberStack,operatorStack);
}
evaluateAllOperatorOnStack(numberStack,operatorStack);
Number *result=(Number*)stackPop(numberStack);
destroyStack(numberStack);
if(operatorStack !=NULL){
destroyStack(operatorStack);
}
return result->value;
}
/* To remove words contain in ContainSet
* input :
* ContainSet character that need to be remove
* return:
* Return the removedWord start index and length
*/
String *stringRemoveWordContaining(String *str , char *containSet)
{
int i = str->startindex , j = 0 , firstFound = 0 , notInSet = 0;
String *removedWord = stringNew(str->string); //create new String for removedWord
removedWord->length = 0;
while(i < strlen(str->string))
{
while(j != strlen(containSet))
{
if(str->string[i] == containSet[j]) //searching is containSet inside the string
{
if(!firstFound)
{
removedWord->startindex = i; //first character found
firstFound = 1; //make sure this statement wont run again when the first character is found
}
removedWord->length++; //one word is detected in ContainSet
str->startindex = i+1;
notInSet = 0;
goto jump;
}
if(firstFound == 1)
notInSet = 1;
j++;
}
if(notInSet == 1)
goto end;
jump:
i++;
j = 0;
}
end:
str->length = strlen(str->string) - str->startindex;
return removedWord;
}
String *stringRemoveWordContaining(String *string, char containSet[]){
int i = string->start;
int j = 0;
int k = 0;
int status;
int conValue = 0;
String *string2 = stringNew(string->text);
string2->start = string->start;
string2->length = 0;
while(containSet[k] > string->length){
conValue++;
k++;
}
while(string->text->string[i] != 0){
while(containSet[j] != 0){
if(string->text->string[i] == containSet[j]){
string2->length++;
string->start++;
string->length--;
goto getValue;
}else{
status++;
}
j++;
}
if(status >= conValue){
return string2;
}
getValue:
j = 0;
i++;
}
return string2;
}
void test_evaluatePrefixesAndNumber_evaluate_divide_multiply_should_throw_error_expecting_number(void){
CEXCEPTION_T e;
Token *token;
Stack *numberStack=createStack();
Stack *operatorStack=createStack();
Text *newText=textNew("/*");
String *tokenizer = stringNew(newText);
token=getToken(tokenizer);
token=getToken(tokenizer);
Try
{
evaluatePrefixesAndNumber("/*",token,numberStack,operatorStack);
}
Catch(e)
{
TEST_ASSERT_EQUAL(ERR_CANNOT_CONVERT_TO_PREFIX,e);
}
}
/*!
* \brief recogGetClassString()
*
* \param[in] recog
* \param[in] index into array of char types
* \param[out] pcharstr string representation;
* returns an empty string on error
* \return 0 if found, 1 on error
*
* <pre>
* Notes:
* (1) Extracts a copy of the string from sa_text, which
* the caller must free.
* (2) Caller must check the function return value.
* </pre>
*/
l_int32
recogGetClassString(L_RECOG *recog,
l_int32 index,
char **pcharstr)
{
PROCNAME("recogGetClassString");
if (!pcharstr)
return ERROR_INT("&charstr not defined", procName, 1);
*pcharstr = stringNew("");
if (!recog)
return ERROR_INT("recog not defined", procName, 2);
if (index < 0 || index >= recog->setsize)
return ERROR_INT("invalid index", procName, 1);
LEPT_FREE(*pcharstr);
*pcharstr = sarrayGetString(recog->sa_text, index, L_COPY);
return 0;
}
/*!
* \brief makeBarrelshiftString()
*/
static char *
makeBarrelshiftString(l_int32 delx, /* j - cx */
l_int32 dely) /* i - cy */
{
l_int32 absx, absy;
char bigbuf[L_BUF_SIZE];
PROCNAME("makeBarrelshiftString");
if (delx < -31 || delx > 31)
return (char *)ERROR_PTR("delx out of bounds", procName, NULL);
if (dely < -31 || dely > 31)
return (char *)ERROR_PTR("dely out of bounds", procName, NULL);
absx = L_ABS(delx);
absy = L_ABS(dely);
if ((delx == 0) && (dely == 0))
sprintf(bigbuf, "(*sptr)");
else if ((delx == 0) && (dely < 0))
sprintf(bigbuf, "(*(sptr %s))", wplstrm[absy - 1]);
else if ((delx == 0) && (dely > 0))
sprintf(bigbuf, "(*(sptr %s))", wplstrp[absy - 1]);
else if ((delx < 0) && (dely == 0))
sprintf(bigbuf, "((*(sptr) >> %d) | (*(sptr - 1) << %d))",
absx, 32 - absx);
else if ((delx > 0) && (dely == 0))
sprintf(bigbuf, "((*(sptr) << %d) | (*(sptr + 1) >> %d))",
absx, 32 - absx);
else if ((delx < 0) && (dely < 0))
sprintf(bigbuf, "((*(sptr %s) >> %d) | (*(sptr %s - 1) << %d))",
wplstrm[absy - 1], absx, wplstrm[absy - 1], 32 - absx);
else if ((delx > 0) && (dely < 0))
sprintf(bigbuf, "((*(sptr %s) << %d) | (*(sptr %s + 1) >> %d))",
wplstrm[absy - 1], absx, wplstrm[absy - 1], 32 - absx);
else if ((delx < 0) && (dely > 0))
sprintf(bigbuf, "((*(sptr %s) >> %d) | (*(sptr %s - 1) << %d))",
wplstrp[absy - 1], absx, wplstrp[absy - 1], 32 - absx);
else /* ((delx > 0) && (dely > 0)) */
sprintf(bigbuf, "((*(sptr %s) << %d) | (*(sptr %s + 1) >> %d))",
wplstrp[absy - 1], absx, wplstrp[absy - 1], 32 - absx);
return stringNew(bigbuf);
}
/*!
* sarrayGetString()
*
* Input: sarray
* index (to the index-th string)
* copyflag (L_NOCOPY or L_COPY)
* Return: string, or null on error
*
* Notes:
* (1) Legacy usage decrees that we always use 0 to get the
* pointer to the string itself, and 1 to get a copy of
* the string.
* (2) See usage comments at the top of this file.
* (3) To get a pointer to the string itself, use for copyflag:
* L_NOCOPY or 0 or FALSE
* To get a copy of the string, use for copyflag:
* L_COPY or 1 or TRUE
* The const values of L_NOCOPY and L_COPY are guaranteed not
* to change.
*/
char *
sarrayGetString(SARRAY *sa,
l_int32 index,
l_int32 copyflag)
{
PROCNAME("sarrayGetString");
if (!sa)
return (char *)ERROR_PTR("sa not defined", procName, NULL);
if (index < 0 || index >= sa->n)
return (char *)ERROR_PTR("index not valid", procName, NULL);
if (copyflag != L_NOCOPY && copyflag != L_COPY)
return (char *)ERROR_PTR("invalid copyflag", procName, NULL);
if (copyflag == L_NOCOPY)
return sa->array[index];
else /* L_COPY */
return stringNew(sa->array[index]);
}
void test_evaluatePrefixesAndNumber_evaluate_should_push_negative_into_operatorStack_and_5_into_number_stack(void){
Token *token;
Stack *numberStack=createStack();
Stack *operatorStack=createStack();
Text *newText=textNew("-5");
String *tokenizer = stringNew(newText);
//-
token=getToken(tokenizer);
evaluatePrefixesAndNumber("-5",token,numberStack,operatorStack);
TEST_ASSERT_NOT_NULL(token);
TEST_ASSERT_EQUAL_STRING("-",((Operator*)token)->info->symbol);
TEST_ASSERT_EQUAL(MINUS_OP,((Operator*)token)->info->id);
//5
token=getToken(tokenizer);
evaluatePrefixesAndNumber("-5",token,numberStack,operatorStack);
TEST_ASSERT_NOT_NULL(token);
TEST_ASSERT_EQUAL(5,((Number*)token)->value);
}
/*!
* \brief l_genDescrString()
*
* \param[in] filein input file of serialized data
* \param[in] ifunc index into set of functions in generated file
* \param[in] itype index into type of function to be used
* \return description string for this decoding function
*/
static char *
l_genDescrString(const char *filein,
l_int32 ifunc,
l_int32 itype)
{
char buf[256];
char *tail;
PROCNAME("l_genDescrString");
if (!filein)
return (char *)ERROR_PTR("filein not defined", procName, NULL);
splitPathAtDirectory(filein, NULL, &tail);
snprintf(buf, sizeof(buf), " * %-2d %-10s %-14s %s",
ifunc, l_assoc[itype].type, l_assoc[itype].reader, tail);
LEPT_FREE(tail);
return stringNew(buf);
}
void test_evaluatePrefixesAndNumber_evaluate_negative_positive_should_throw_error_expecting_number(void){
CEXCEPTION_T e;
Token *token;
Stack *numberStack=createStack();
Stack *operatorStack=createStack();
Text *newText=textNew("-+");
String *tokenizer = stringNew(newText);
token=getToken(tokenizer);
token=getToken(tokenizer);
token=getToken(tokenizer);
Try
{
evaluatePrefixesAndNumber("-+",token,numberStack,operatorStack);
}
Catch(e)
{
TEST_ASSERT_EQUAL(ERR_EXPECTING_NUMBER,e);
}
}
/*!
* gplotCreate()
*
* Input: rootname (root for all output files)
* outformat (GPLOT_PNG, GPLOT_PS, GPLOT_EPS, GPLOT_X11,
* GPLOT_LATEX)
* title (<optional> overall title)
* xlabel (<optional> x axis label)
* ylabel (<optional> y axis label)
* Return: gplot, or null on error
*
* Notes:
* (1) This initializes the plot.
* (2) The 'title', 'xlabel' and 'ylabel' strings can have spaces,
* double quotes and backquotes, but not single quotes.
*/
GPLOT *
gplotCreate(const char *rootname,
l_int32 outformat,
const char *title,
const char *xlabel,
const char *ylabel)
{
char buf[L_BUF_SIZE];
GPLOT *gplot;
PROCNAME("gplotCreate");
if (!rootname)
return (GPLOT *)ERROR_PTR("rootname not defined", procName, NULL);
if (outformat != GPLOT_PNG && outformat != GPLOT_PS &&
outformat != GPLOT_EPS && outformat != GPLOT_X11 &&
outformat != GPLOT_LATEX)
return (GPLOT *)ERROR_PTR("outformat invalid", procName, NULL);
if ((gplot = (GPLOT *)CALLOC(1, sizeof(GPLOT))) == NULL)
return (GPLOT *)ERROR_PTR("gplot not made", procName, NULL);
gplot->cmddata = sarrayCreate(0);
gplot->datanames = sarrayCreate(0);
gplot->plotdata = sarrayCreate(0);
gplot->plottitles = sarrayCreate(0);
gplot->plotstyles = numaCreate(0);
/* Save title, labels, rootname, outformat, cmdname, outname */
gplot->rootname = stringNew(rootname);
gplot->outformat = outformat;
snprintf(buf, L_BUF_SIZE, "%s.cmd", rootname);
gplot->cmdname = stringNew(buf);
if (outformat == GPLOT_PNG)
snprintf(buf, L_BUF_SIZE, "%s.png", rootname);
else if (outformat == GPLOT_PS)
snprintf(buf, L_BUF_SIZE, "%s.ps", rootname);
else if (outformat == GPLOT_EPS)
snprintf(buf, L_BUF_SIZE, "%s.eps", rootname);
else if (outformat == GPLOT_LATEX)
snprintf(buf, L_BUF_SIZE, "%s.tex", rootname);
else /* outformat == GPLOT_X11 */
buf[0] = '\0';
gplot->outname = stringNew(buf);
if (title) gplot->title = stringNew(title);
if (xlabel) gplot->xlabel = stringNew(xlabel);
if (ylabel) gplot->ylabel = stringNew(ylabel);
return gplot;
}
void test_all(void) {
String *toCompare;
Text *text = textNew(" \t\t ahaha \t\t ");
String *str = stringNew(text);
String *str2 = stringAssign(str);
TEST_ASSERT_EQUAL(2,text->reference);
toCompare = stringDel(str); //still got 1
TEST_ASSERT_EQUAL(2,text->reference);
TEST_ASSERT_EQUAL(1,toCompare->reference);
toCompare = stringDel(str); //no more
//unable to TEST_ASSERT_EQUAL, bad memory because already removed
TEST_ASSERT_EQUAL(1,text->reference);
stringTrim(str);
TEST_ASSERT_EQUAL(4,str->start);
TEST_ASSERT_EQUAL(5,str->length);
}
void test_evaluatePrefixesAndNumber_evaluate_multiply_should_throw_error_cannot_convert_to_prefix_operator(void){
CEXCEPTION_T e;
Token *token;
Stack *numberStack=createStack();
Stack *operatorStack=createStack();
Text *newText=textNew("*");
String *tokenizer = stringNew(newText);
//(
token=getToken(tokenizer);
Try
{
evaluatePrefixesAndNumber("*",token,numberStack,operatorStack);
TEST_FAIL_MESSAGE("Should throw Error no expression ");
}
Catch(e)
{
TEST_ASSERT_EQUAL(ERR_CANNOT_CONVERT_TO_PREFIX ,e);
}
}
void test_evaluatePrefixesAndNumber_evaluate_opening_bracket_7(void){
Token *token;
Stack *numberStack=createStack();
Stack *operatorStack=createStack();
Text *newText=textNew("(7");
String *tokenizer = stringNew(newText);
//(
token=getToken(tokenizer);
evaluatePrefixesAndNumber("(7",token,numberStack,operatorStack);
TEST_ASSERT_NOT_NULL(token);
TEST_ASSERT_EQUAL_STRING("(",((Operator*)token)->info->symbol);
TEST_ASSERT_EQUAL(OPENING_BRACKET_OP,((Operator*)token)->info->id);
//7
token=getToken(tokenizer);
evaluatePrefixesAndNumber("(7",token,numberStack,operatorStack);
TEST_ASSERT_NOT_NULL(token);
TEST_ASSERT_EQUAL(7,((Number*)token)->value);
}
String *stringRemoveWordNotContaining(String *string, char *delimiters){
int i = string->start;
int j = 0;
String *string2 = stringNew(string->text);
string2->start = 0;
string2->length = 0;
while(string->text->string[i] != 0){
while(delimiters[j] != 0){
if(string->text->string[i] == delimiters[j]){
string2->start = string->start;
string2->length = i - string->start;
string->start = i;
string->length = string->length - i;
return string2;
}else{
j++;
}
/*if(string->text->string[i] == delimiters[j]){
end = i;
}
if(string->text->string[i] == delimiters[j + 1]){
start = i;
}
string->start = start;
string->length = (end - start) + 1;
string2->length = (string->start - string2->start);
*/
}
j = 0;
i++;
}
return string2;
}
String *stringRemoveWordNotContaining(String *string,char delimiters[]){
int i=0,j=0;
String *stringA = stringNew(string->text);
stringA->length = 0;
while(string->text->string[i]!=0){
while(delimiters[j] != 0){
if(string->text->string[i] == delimiters[j]){
stringA->start = string->start;
stringA->length = i-string->start;
string->start = i;
string->length = string->length - stringA->length ;
return stringA;
}
j++;
}
j=0;
i++;
}
return stringA;
}
String *stringRemoveWordContaining(String *string,char containSet[]){
int i=string->start;
int j=0,k=0;
int value=0;
int returnValue = 0;
String *stringA = stringNew(string->text);
stringA->length = 0;
stringA->start = string->start;
for(k = 0; containSet[k] > string->length ; k++){
value++;
}
while(string->text->string[i] != 0){
while(containSet[j] != 0){
if(string->text->string[i] == containSet[j]){
string->start ++;
string->length --;
stringA->length ++;
goto here;
}else{
returnValue++;
}
j++;
}if(returnValue>=value){
goto come;
}
here:
j=0;
i++;
}
come:
return stringA;
}
void evaluatePrefixesAndNumber(char *expression,Token *token,Stack *numberStack,Stack *operatorStack){
Text *newText=textNew(expression);
String *tokenizer = stringNew(newText);
if(token==NULL){
Throw(ERR_EXPECTING_NUMBER);
}else {
while(1){
if(isNumber(token)){
stackPush(token,numberStack);
break;
}else if(isOperator(token)){
if(((Operator*)token)->info->affix !=PREFIX)
tryConvertToPrefix((Operator*)token);
stackPush(token,operatorStack);
}else
Throw(ERR_INVALID_IDENTIFIER);
token=getToken(tokenizer);
if(token==NULL)
break;
}
}
}
/*******************************************************************************************
* This function is to evaluate the expression which contains numbers and operators and
* return the results in number form.
* This function is a prototype function which use as reference to
* improve in the evaluateExpression(char*expression) function.
* Thus, this function could not evaluate expression like -2,*2,(((2))), +-+-2... *
* input : expression
* output : none
* return : ((Number*)token)->value
*
********************************************************************************************/
int evaluate(char *expression){
Token *token;
Number *result;
Stack *numberStack=createStack();
Stack *operatorStack=createStack();
if(expression ==NULL){
Throw(ERR_NO_ARGUMENT);
}
Text *newText=textNew(expression);
String *tokenizer = stringNew(newText);
while((token=getToken(tokenizer))!=NULL ){
if(isNumber(token)){
stackPush(token,numberStack);
} else if(isOperator(token)) {
if(((Operator*)token)->info->id==OPENING_BRACKET_OP || ((Operator*)token)->info->id==CLOSING_BRACKET_OP) {
tryEvaluatePrefixOperatorOnStackThenPush((Operator*)token,numberStack,operatorStack);
} else{
tryEvaluateOperatorOnStackThenPush((Operator*)token,numberStack,operatorStack);
}
}
}
if(operatorStack == NULL){
operatorPrefixEvaluate(numberStack ,(Operator*)token);
}else{
evaluateAllOperatorOnStack(numberStack,operatorStack);
}
result=(Number*)stackPop(numberStack);
destroyStack(numberStack);
if(operatorStack !=NULL){
destroyStack(operatorStack);
}
return result->value;
}
