void test_stringTrim_should_trim_both_sides3(void) {
    Text *text = textNew(" \t\t BeedFack \t\t    ");
    String *str = stringNew(text);
    stringTrim(str);
    TEST_ASSERT_EQUAL(4,str->start);
    TEST_ASSERT_EQUAL(8,str->length);
}
void test_stringTrim_should_trim_both_sides(void) {
    Text *text = textNew("  \t \t \t  VeaLer     ");
    String *str = stringNew(text);
    stringTrim(str);
    TEST_ASSERT_EQUAL(9,str->start);
    TEST_ASSERT_EQUAL(6,str->length);
}
void test_stringTrim_should_trim_both_sides2(void) {
    Text *text = textNew("  GaLger \t\t    ");
    String *str = stringNew(text);
    stringTrim(str);
    TEST_ASSERT_EQUAL(2,str->start);
    TEST_ASSERT_EQUAL(6,str->length);
}
コード例 #4
0
/**
* To extract the argument of address
*
* Input:
*	String	the whole argument
* 
* Return the value of the address
* Throw if value is invalid
*/
int extractValue(String *arguments){
	
	char *returnChar;
	int returnInt;
	String *string;
	stringTrimLeft(arguments);
	
	if(stringCharAt(arguments,0) == ',')
		stringRemoveChar(arguments);
		
	if(stringCharAt(arguments,0) == ';' || stringLength(arguments) == 0)
		
		Throw(ERR_NO_ARGUMENT);
		
	string = stringRemoveWordNotContaining(arguments,",;");
	stringTrim(string);
	
	if(stringLength(string) == 0)
		Throw(ERR_EMPTY_ARGUMENT);
		
	returnChar = stringSubstringInChar(string,0,string->length);
	returnInt = evaluate(returnChar);
	
		
	free(string);
	
	return returnInt;
} //pass to jason
コード例 #5
0
ファイル: g15macro.c プロジェクト: garismaatti/g15daemon
void renderSelectionList()
{
	// Draws the three presets in the list (Selected-1,Selected,Selected+1)
	// Find config id to render
	pthread_mutex_lock(&gui_select);
	/*static*/ int tmpRenderConfID = 0;

	// Render first entry
	if (gui_selectConfig > 0)
		tmpRenderConfID = gui_selectConfig-1;
	else
		tmpRenderConfID = numConfigs;

	char* renderLine = stringTrim((char*)getConfigName(tmpRenderConfID),25);
	g15r_renderString(canvas, (unsigned char*)renderLine, 0, G15_TEXT_MED, 1, 17);
	free(renderLine);
	renderLine = NULL;


	// Render middle entry available for selection
	renderLine = stringTrim((char*)getConfigName(gui_selectConfig),25);

	g15r_renderString(canvas, (unsigned char*)renderLine, 0, G15_TEXT_MED, 1, 26);
	free(renderLine);
	renderLine = NULL;

	// Render third (last) entry
	if (gui_selectConfig < numConfigs)
		tmpRenderConfID = gui_selectConfig+1;
	else
		tmpRenderConfID = 0;
	pthread_mutex_unlock(&gui_select);

	renderLine = stringTrim((char*)getConfigName(tmpRenderConfID),25);
	g15r_renderString(canvas, (unsigned char*)renderLine, 0, G15_TEXT_MED, 1, 35);
	free(renderLine);
	renderLine = NULL;

	// Make middle look selected by inverting colours
	g15r_pixelReverseFill(canvas, 0, 24, 121, 33, 0,G15_COLOR_BLACK);

	g15_send(g15screen_fd,(char *)canvas->buffer,G15_BUFFER_LEN);
	pthread_mutex_lock(&gui_select);
	gui_oldConfig = gui_selectConfig;
	pthread_mutex_unlock(&gui_select);
}
コード例 #6
0
ファイル: Unit.cpp プロジェクト: Jarreddebeer/SoFiA
std::string Unit::printString(const unsigned int mode)
{
    std::string result;
    std::string unicodeExp[10] = {"⁰", "¹", "²", "³", "⁴", "⁵", "⁶", "⁷", "⁸", "⁹"};
    
    if(prefixes != 0)
    {
        std::string strPre = numberToString<int>(prefixes);
        
        if(mode == UNIT_EXP)
        {
            for(int j = 0; j < 10; j++)
            {
                stringReplace(strPre, numberToString<int>(j), unicodeExp[j]);
            }
            
            stringReplace(strPre, "-", "⁻");
            
            result.append("10" + strPre);
        }
        else
        {
            result.append("10^" + strPre);
        }
    }
    
    for(size_t i = 0; i < UNIT_NUMBER_BASE_UNITS; i++)
    {
        if(units[i] == 1)
        {
            result.append(" " + baseUnitList[i]);
        }
        else if(units[i] != 0)
        {
            std::string strExp = numberToString<int>(units[i]);
            
            if(mode == UNIT_EXP)
            {
                for(int j = 0; j < 10; j++)
                {
                    stringReplace(strExp, numberToString<int>(j), unicodeExp[j]);
                }
                
                stringReplace(strExp, "-", "⁻");
                
                result.append(" " + baseUnitList[i] + strExp);
            }
            else
            {
                result.append(" " + baseUnitList[i] + "^" + strExp);
            }
        }
    }
    
    stringTrim(result);
    
    return result;
}
コード例 #7
0
/**
* To extract the argument of access or banked
*
* Input:
*	String	the whole argument
* 
* Return the value of access/banked
* Throw if value is invalid
*/
int extractAccessBanked(String *arguments){
	char location;
	char *returnChar;
	int returnInt;
	String *string;
	String *banked = stringNew(textNew("BANKED")); //1
	String *access = stringNew(textNew("ACCESS")); //0
	
	if(stringCharAt(arguments,0) == ',')
		stringRemoveChar(arguments);
		
	if(stringLength(arguments) == 0 ||stringCharAt(arguments,0) == ';')
		
		Throw(ERR_NO_ARGUMENT);
		
	stringTrimLeft(arguments);
	
	if(stringLength(arguments) == 0 ||stringCharAt(arguments,0) == ';')
		Throw(ERR_EMPTY_ARGUMENT);
		
	string = stringRemoveWordNotContaining(arguments,",;");
	
	stringTrim(string);
	
	if(stringLength(string) == 0){
		if(stringCharAt(arguments,0) == ',')
			stringRemoveChar(arguments);
		Throw(ERR_EMPTY_ARGUMENT);
	}
	
	else if(stringLength(string) == 6){
		
		if(stringIsEqual(string,banked))
			returnInt = 1;
		else if(stringIsEqual(string,access))
			returnInt = 0;
		else{
			returnChar = stringSubstringInChar(string,0,string->length);
			returnInt =  evaluate(returnChar);
		}
	}
	else{
		returnChar = stringSubstringInChar(string,0,string->length);
		returnInt = evaluate(returnChar);
	}
	
	if(stringCharAt(arguments,0) == ',')
		stringRemoveChar(arguments);
	
	free(string);
	return returnInt;

}
コード例 #8
0
/**
* To extract the argument of location to save
*
* Input:
*	String	the whole argument
* 
* Return the value of the location
* Throw if value is invalid
*/
int extractDestination(String *arguments){
	
	
	char location;
	char *returnChar;
	int returnInt;
	String *string;
	
	if(stringCharAt(arguments,0) == ',')
		stringRemoveChar(arguments);
	
	if(stringLength(arguments) == 0 ||stringCharAt(arguments,0) == ';')
		
		Throw(ERR_NO_ARGUMENT);
		
	stringTrimLeft(arguments);
	
	if(stringLength(arguments) == 0 || stringCharAt(arguments,0)== ';')
		Throw(ERR_EMPTY_ARGUMENT);
		
	string = stringRemoveWordNotContaining(arguments,",;");
	stringTrim(string);
	
	if(stringLength(string) == 0){
		if(stringCharAt(arguments,0) == ',')
			stringRemoveChar(arguments);
		Throw(ERR_EMPTY_ARGUMENT);
	}
	
	else if(stringLength(string) == 1){
		location = stringCharAt(string,0);
		if(location == 'F')
			returnInt = 1;
		else if(location == 'W')
			returnInt = 0;
		else{
			returnChar = stringSubstringInChar(string,0,string->length);
			returnInt =  evaluate(returnChar);
		}
	}
	else{
		returnChar = stringSubstringInChar(string,0,string->length);
		returnInt = evaluate(returnChar);
	}
	
	
	free(string);
	return returnInt;
	

}//if f, return 1, w is 0
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);
}
コード例 #10
0
//bool TTecladoPantalla::gestionTeclado(char *textoBusqueda)
bool TTecladoPantalla::gestionTeclado()
{
   	char *arrayLetras = {"abcdefghijklmnñopqrstuvwxyz0123456789 "};
   	int tamArrayletras = strlen(arrayLetras);
    int posArrayLetras = -1;
    bool salir = false;
    int posTriangulo = 0;
    //char textoBusqueda[numLetras];
    //memset(textoBusqueda,' ',sizeof(textoBusqueda)/sizeof(char));
    bool editarPalabra = false;
    int posMenuTeclado = 0;

    Clear();
    this->miImagen->fondoCirculos();
    pintarPalabraBuscar(textoBusqueda,0,0, false);

    SDL_UpdateRect(screen, 0, 0, 0, 0);

    bool pressed = false;
    bool first_press = true;
    unsigned int last_press = 0;
    int inicio = SDL_GetTicks();
    int tiempo_empleado = 0;

    while (!salir)
    {
        /* Check for events */
        SDL_Event event;
        while (SDL_PollEvent(&event) && !salir)
        {
             switch (event.type)
             {
                case SDL_KEYDOWN:
                case SDL_JOYBUTTONDOWN:
                    pressed = true;
                    last_press = SDL_GetTicks();
                    break;
                case SDL_KEYUP:
                case SDL_JOYBUTTONUP:
                    pressed = false;
                    first_press = true;
                    break;
                default: break;

             }//switch (event.type)

        }//while (SDL_PollEvent

        if (pressed)
        {
            if (last_press < (SDL_GetTicks() - this->key_init_delay) || first_press)
            {
                first_press = false;
                inicio = SDL_GetTicks();

                    if (event.key.keysym.sym == SDLK_RETURN || event.jbutton.button == GP2X_BUTTON_B)
                    {
                        pressed = false;
                        //Orden de editar el texto
                        if (editarPalabra)
                        {
                            posMenuTeclado = 2;
                            editarPalabra = false;
                        }
                        else
                        {
                            if (posMenuTeclado == 0) editarPalabra = true;
                            else editarPalabra = false;

                            //Orden de borrar el texto
                            if (posMenuTeclado == 1)
                            {
                                memset(textoBusqueda,' ',numLetras);
                                textoBusqueda[numLetras] = '\0';
                                //strcpy(textoBusqueda,"");
                                posTriangulo = 0;
                            }
                            else
                            if (posMenuTeclado == 2)
                            {
                                stringTrim(textoBusqueda);
                                if (strcmp(textoBusqueda," ") != 0)
                                {
                                    return true;
                                }
                                else
                                {
                                    memset(textoBusqueda,' ',numLetras);
                                    textoBusqueda[numLetras] = '\0';
                                }
                            }
                            else
                            if (posMenuTeclado == 3)
                            {
                                salir = true;
                            }
                        }
                        pintarPalabraBuscar(textoBusqueda,posTriangulo,posMenuTeclado, editarPalabra);
                    }
                    else
                    if (event.key.keysym.sym == SDLK_ESCAPE || event.jbutton.button == GP2X_BUTTON_X)
                    {
                        pressed = false;
                        if (editarPalabra == true) editarPalabra = false;
                        else salir = true;
                        pintarPalabraBuscar(textoBusqueda,posTriangulo,posMenuTeclado, editarPalabra);
                    }
                    else
                    if (!editarPalabra)
                    {
                        if (event.key.keysym.sym == SDLK_RIGHT || event.jbutton.button == GP2X_BUTTON_RIGHT)
                        {
                            if (posMenuTeclado < 3) posMenuTeclado++;
                        }
                        else
                        if (event.key.keysym.sym == SDLK_LEFT || event.jbutton.button == GP2X_BUTTON_LEFT)
                        {
                            if (posMenuTeclado > 0) posMenuTeclado--;
                        }

                        pintarPalabraBuscar(textoBusqueda,posTriangulo,posMenuTeclado, editarPalabra);
                    }
                    else
                    {

                        if (event.key.keysym.sym == SDLK_RIGHT || event.jbutton.button == GP2X_BUTTON_RIGHT)
                        {
                            if (posTriangulo < numLetras-1)
                            {
                                posTriangulo++;
                                posArrayLetras = -1;
                            }
                            pintarPalabraBuscar(textoBusqueda,posTriangulo,posMenuTeclado, editarPalabra);

                        }
                        else
                        if (event.key.keysym.sym == SDLK_LEFT || event.jbutton.button == GP2X_BUTTON_LEFT)
                        {
                            if (posTriangulo > 0)
                            {
                                posTriangulo--;
                                posArrayLetras = -1;
                            }
                            pintarPalabraBuscar(textoBusqueda,posTriangulo,posMenuTeclado, editarPalabra);
                        }
                        else
                        if (event.key.keysym.sym == SDLK_UP || event.jbutton.button == GP2X_BUTTON_UP)
                        {
                            if (posArrayLetras < tamArrayletras-1) posArrayLetras++;
                            else posArrayLetras = 0;
                            textoBusqueda[posTriangulo] = arrayLetras[posArrayLetras];
                            pintarPalabraBuscar(textoBusqueda,posTriangulo,posMenuTeclado, editarPalabra);

                        }
                        else
                        if (event.key.keysym.sym == SDLK_DOWN || event.jbutton.button == GP2X_BUTTON_DOWN)
                        {
                            if (posArrayLetras > 0) posArrayLetras--;
                            else posArrayLetras = tamArrayletras-1;
                            textoBusqueda[posTriangulo] = arrayLetras[posArrayLetras];
                            pintarPalabraBuscar(textoBusqueda,posTriangulo,posMenuTeclado, editarPalabra);
                        }
                        else if (event.key.keysym.sym == SDLK_BACKSPACE)
                        {
                            if (posTriangulo > 0) posTriangulo--;
                            textoBusqueda[posTriangulo] = ' ';
                            pintarPalabraBuscar(textoBusqueda,posTriangulo,posMenuTeclado, editarPalabra);
                        }
                        else if (posTriangulo < numLetras)
                        {
                         //printf("la pulsada es: %c\n",event.key.keysym.sym);
                         textoBusqueda[posTriangulo] = event.key.keysym.sym;
                         pintarPalabraBuscar(textoBusqueda,posTriangulo,posMenuTeclado, editarPalabra);
                         posTriangulo++;

                        }
                    }
            }//if (last_press
        }//if (pressed)

        tiempo_empleado = SDL_GetTicks() - inicio;
        if ( tiempo_empleado < this->key_delay)
        {
            SDL_Delay(this->key_delay - tiempo_empleado);
        }

    }//while (!salir)
    SDL_UpdateRect(screen, 0, 0, 0, 0);
    return false;
}
コード例 #11
0
ファイル: Unit.cpp プロジェクト: Jarreddebeer/SoFiA
int Unit::set(const std::string &value)
{
    this->clear();
    
    std::string unitString = value;
    stringTrim(unitString);
    
    if(unitString.empty()) return 0;
    
    stringReplace(unitString, "**", "");                   // remove exponentiation symbols
    stringReplace(unitString, "^",  "");
    stringReplace(unitString, "*",  " ");                  // replace multiplication symbols with space for tokenising
    stringReplace(unitString, "/",  " /");                 // pad division symbols with space for tokenising
    while(stringReplace(unitString, "/ ", "/") == 0);      // remove all spaces after division symbols
    
    std::vector<std::string> tokens;
    
    // Tokenise string using spaces:
    if(stringTok(unitString, tokens, " ") != 0)
    {
        std::cerr << "Error (Unit): Failed to tokenise unit string." << std::endl;
        this->clear();
        return 1;
    }
    
    if(tokens.size() < 1)
    {
        std::cerr << "Error (Unit): Failed to tokenise unit string." << std::endl;
        this->clear();
        return 1;
    }
    
    // Loop through all tokens:
    for(size_t i = 0; i < tokens.size(); i++)
    {
        int factorDiv = 1;     // Will become -1 if division sign '/' found.
        int exponent  = 1;     // Exponent of the unit; defaults to 1 if unspecified.
        
        
        // Check for division symbol:
        
        if(tokens[i].substr(0, 1) == "/")
        {
            tokens[i] = tokens[i].substr(1, tokens[i].size() - 1);
            factorDiv = -1;
        }
        
        // Extract exponent:
        
        size_t posExp = tokens[i].find_first_of("+-0123456789");
        
        if(posExp != std::string::npos)
        {
            exponent = stringToNumber<int>(tokens[i].substr(posExp));
        }
        
        exponent *= factorDiv;
        
        // Only proceed if unit is not unity:
        if(exponent != 0 and tokens[i] != "1")
        {
            // Extract base unit and prefix:
            bool success = false;
            
            std::map<std::string, std::vector<int> >::const_iterator iterUnit = unitMap.begin();
            do
            {
                std::map<std::string, int>::const_iterator iterPrefix = prefixMap.begin();
                do
                {
                    std::string searchKey = iterPrefix->first + iterUnit->first;
                    
                    if(searchKey == tokens[i].substr(0, posExp))
                    {
                        success = true;
                        
                        int prefix = iterPrefix->second;
                        std::vector<int> unit(iterUnit->second);
                        
                        // Take care of special case 'kg':
                        if(iterUnit->first == "g") prefix -= 3;
                        
                        for(size_t ii = 0; ii < UNIT_NUMBER_BASE_UNITS; ii++)
                        {
                            units[ii] += unit[ii] * exponent;
                        }
                        
                        prefixes += prefix * exponent;
                    }
                    
                    iterPrefix++;
                }
                while(success == false and iterPrefix != prefixMap.end());
                
                iterUnit++;
            }
            while(success == false and iterUnit != unitMap.end());
            
            if(success == false)
            {
                std::cerr << "Error (Unit): Unknown unit: \'" << value << "\'."   << std::endl;
                std::cerr << "              Creating dimensionless unit instead." << std::endl;
                clear();
                return 1;
            }
        }
    }
    
    return 0;
}
コード例 #12
0
	bool append_file(const char* path,const char* file_name,MPQPackage* pPkg,FILE* fp_log)
	{
 		if ( !path || !file_name || !pPkg)
 		{
 			return false;
 		}
 
		string fullPathKey = stringTrim(path,"\n");
		string filePathKey = stringTrim(file_name,"\n");
		if ( filePathKey.empty() )
		{
			return false;
		}
		if ( fullPathKey.empty() )
		{
			fullPathKey = filePathKey;
		}
		else
		{
			fullPathKey.append("/");
			fullPathKey.append(filePathKey);
		}

 		FILE* fp = fopen(fullPathKey.c_str(),"rb");
 		if ( !fp )
 		{
			if ( fp_log )
			{
				fprintf(fp_log,"can't open file %s\n",fullPathKey.c_str());
			}
 			return false;
 		}
 
 		// md5 check code
 		MD5 m;
 		m.update(fp);
 
 		fseek(fp,0,SEEK_END);
 		unsigned int file_size = ftell(fp);
		m.update(&file_size,sizeof(unsigned int));
 
 		unsigned char* pData = new unsigned char[file_size];
 		if ( !pData )
 		{
			if ( fp_log )
			{
				fprintf(fp_log,"can't assign memory for file %s\n",fullPathKey.c_str());
			}
 			fclose(fp);
 			return false;
 		}
 
 		fseek(fp,0,SEEK_SET);
 		fread(pData,1,file_size,fp);
 		fclose(fp);

		bool bCompress = true;
		if ((std::string::npos != fullPathKey.find(".jpg")) ||
			(std::string::npos != fullPathKey.find(".png")) ||
			(std::string::npos != fullPathKey.find(".pvr")))
		{
			bCompress = false;
		}
 
 		MPQHashNode* pNode = pPkg->get_hash_node_new(filePathKey.c_str());
 		if ( !pNode )
 		{
 			// no space
			if ( fp_log )
			{
				fprintf(fp_log,"no hash node left for file %s\n",filePathKey.c_str());
			}
 			delete pData;
 			return false;
 		}
 
 		unsigned int blockIndex = pPkg->append_data(pData,file_size,bCompress);
 		if ( blockIndex == MPQ_INVALID )
 		{
 			pPkg->reset_hash_node(pNode);
 			delete pData;
			if ( fp_log )
			{
				fprintf(fp_log,"append data failed for file %s\n",filePathKey.c_str());
			}
 			return false;
 		}
 
 		pNode->block_index = blockIndex;
 		MPQBlock* pBlock = pPkg->get_block(pNode);
 		memcpy(pBlock->md5_code,m.result(),MPQ_MD5_CODE_LEN);
		pBlock->name = filePathKey;
 
 		delete pData;

		if ( fp_log )
		{
			fprintf(fp_log,"added file %s \n",filePathKey.c_str());
		}
		
		return true;
	}
コード例 #13
0
	unsigned long packWithConfig(const char* path,const char* mpq,const char* config)
	{
		FILE* fp_config = fopen(config,"r+");
		if ( !fp_config )
		{
			return 0;
		}

		vector<string> pack_files;
		while( !feof(fp_config) )
		{
			char szBuffer[MAX_PATH] = "";
			fgets(szBuffer,MAX_PATH,fp_config);
			string fileKey = stringTrim(szBuffer,"\n");
			fileKey = stringTrim(fileKey," ");
			if ( !fileKey.empty() )
			{
				pack_files.push_back(fileKey);
			}
		}

		fclose(fp_config);

		MPQPackage* pPkg = new MPQPackage();
		if ( !pPkg || !pPkg->create(mpq) )
		{
			if ( pPkg )
			{
				delete pPkg;
			}
			return 0;
		}

		FILE* fp_log = fopen("log.txt","w+");

		int pack_count = 0;
		m_pOwner->setRange((int)pack_files.size());
		for ( size_t i = 0;i< pack_files.size(); ++i )
		{
			if( append_file(path,pack_files[i].c_str(),pPkg,fp_log) )
			{
				++pack_count;
			}
			m_pOwner->setPos(i+1);
		}

		if ( fp_log )
		{
			fprintf(fp_log,"file count:%d,packed file count:%d\n",pack_files.size(),pack_count);
			fclose(fp_log);
		}

		if ( pPkg )
		{
			pPkg->format_block_table("packWithConfig.log");
			pPkg->close();
			delete pPkg;
		}

		return pack_count;
	}
コード例 #14
0
ファイル: Token.c プロジェクト: chaosAD/SWD-for-ARM-Cortex-M4
/* To extract out number token , identifier token or operator token from the expression string
 * input :
 *			expression is the string that we wanted to extract the token
 * output :
 *			return number token if number is found in string
 *			return idendifier token if identifier is found in string
 * 			return operator token if operator is found in string
 */
Token *getToken(String *expression)
{	
	Number *num; Identifier *iden; Operator *op; File *file;
	int tempStart = 0 , tempLength = 0, hex = 0;  char *tempIden; //temporary store idendifier name
	stringTrim(expression);	//Remove all the spaces in string
  
	/*Character at first position*/
	int charAtThisPos = expression->startindex;
  
  if(expression->length == 0 || expression->length < 0)
    Throw(ERR_EMPTY_STRING);

	//if character start with numbers it is number token
	else if(stringCharAtInSet(expression , charAtThisPos , numSet))
	{	
		String *removedWord = stringRemoveWordContaining (expression , hexNumSet);	//Remove numbers in string
		tempStart = removedWord->startindex;
		tempLength = removedWord->length;
		char *numSubString = stringSubStringInChars(removedWord , removedWord->length); //Removed numbers become substring
		charAtThisPos = expression->startindex;
    
    if(numSubString[0] == '0' && (numSubString[1] == 'x' || numSubString[1] == 'X'))  {
      sscanf(numSubString, "%x", &hex);
      num = numberNew(hex); //get integer from subStringToInteger and create a new Number Token
      num->line = stringSubString(expression , tempStart , tempLength);
    }
    else if(stringCharAtInSet(expression , charAtThisPos , alphaSet))  {
			Throw(ERR_NOT_NUMBER_TOKEN);
    }
    else {
      int integer = subStringToInteger(numSubString); //Convert substring to integer
      num = numberNew(integer); //get integer from subStringToInteger and create a new Number Token
      num->line = stringSubString(expression , tempStart , tempLength);
    }

		return (Token*)num;
	}
	
  else if(stringCharAtInSet(expression , charAtThisPos, alphaNumericSet) && stringCharAtInSet(expression , charAtThisPos + 1, ":")) 
	{
		String *removedWord = stringRemoveWordContaining (expression , folderNameSet); //Remove identifier from string
		tempStart = removedWord->startindex;
		tempLength = removedWord->length;
		char *fileSubString = stringSubStringInChars(removedWord , removedWord->length); //Removed identifier become substring
		file = fileNew(fileSubString); //create a new identifier token
		file->line = stringSubString(expression , tempStart , tempLength);
		
		return (Token*)file;
	}
  
	//if character start with A~Z/a~z or '_' it is identifier token
	else if(stringCharAtInSet(expression , charAtThisPos , alphaNumericSet)) 
	{
		String *removedWord = stringRemoveWordContaining (expression , alphaNumericSet); //Remove identifier from string
		tempStart = removedWord->startindex;
		tempLength = removedWord->length;
		char *idenSubString = stringSubStringInChars(removedWord , removedWord->length); //Removed identifier become substring
		iden = identifierNew(idenSubString); //create a new identifier token
		iden->line = stringSubString(expression , tempStart , tempLength);
		
		return (Token*)iden;
	}
	
	// if character not start with A~Z/a~z , '_' or numbers it is operator token
	else if(stringCharAtInSet(expression , charAtThisPos , opSet)) 
	{
		String *removedWord = stringRemoveOperator(expression , opSet); //Remove operator in string
		tempStart = removedWord->startindex;
		tempLength = removedWord->length;
		char *opSubString = stringSubStringInChars(removedWord , removedWord->length); //Removed operator become substring	
		op = operatorNewByName(opSubString);
		op->line = stringSubString(expression , tempStart , tempLength);
		
		return (Token*)op;
	}
}