Exemple #1
0
/*
 * Splits the string into two using the given delimeter and outputs
 * result to both the variable out1 and out2.
 */
void stringSplit(char* s, char delimiter, char* out1, char* out2){
    int i;
    int o = 0;
    for (i = 0; i < stringLength(s); i++) {
        if (s[i] == delimiter) {
            o = i+1;
            if (i != stringLength(s)) {
                out1[i]='\0';
            }
        }
        if (!o){
            out1[i] = s[i];

        }
        else{
            out2[i-o] = s[i];
        }
    }
    if(!o){
        out1[i] = '\0';
        out2[0] = '\0';
    }
    else{
        out2[i-o] = '\0';
    }
    return;

}
bool endsWith(const char* str, const char* substr)
{
	int len = stringLength(str);
	int len2 = stringLength(substr);
	if (len2 > len) return false;
	return equalStrings(str + len - len2, substr);
}
/**
* 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
Exemple #4
0
int substring(const char source[], int start, int count)
{

  char result[count + 1];
  int stringLength(const char string[]);
  int sourceLength = stringLength(source);
  int i;

  // What to do if the count is off the end of the string
  if (count > (sourceLength - 1))
  // Would have subtracted 1 but need space for "null" character as well
    count = (sourceLength - start );

  int j = 0;
  for(i = start; i <= count; ++i)
  {

    result[j] = source[i];
    ++j;
    if (i == count)
      result[i] = '\0';

  }

  for (i = 0; i < (stringLength(result)); ++i)
    printf("%c", result[i]);

  printf("\nDone\n");

  return 0;

}
void testInputCases()
{
	int i,length1,length2;
	char *input;
	struct testcases
	{
		char *input1;
		char *input2;
		char *output;
	}test[5] = {
					{"saiseshu","seshugsaisss","seshu"},//input2>input1
					{"azqpyzaz","zqpzqpyz","zqpyz"},//updating the result from zqp to zqpyz
					{"i am a good boy","am i good boy"," good boy"},//input1>input2
					{"mmmwmmm","gsffswhshh","w"},//having chance to getting  result f since input2 has ff as the part
					{"qwerty","asdfg",""}//no common substring
				};
	for(i=0;i<5;i++)
	{
		length1=stringLength(test[i].input1);
		length2=stringLength(test[i].input2);
		input=stringManage(test[i].input1,'#',test[i].input2,'$',length1,length2);
		if(isEqual(getResult(input,length1,length2),test[i].output))
			printf("pass\n");
		else
			printf("fail\n",getResult(input,length1,length2));
	}
}
int main(void)
{   
    printf("%i  ", stringLength("stringLenght test"));
    printf("%i  ", stringLength(""));
    printf("%i\n", stringLength("complete"));
    
    return 0;
}
Exemple #7
0
int main(void) {
    int stringLength(const char *string);

    printf("%i, ", stringLength("stringLength test"));
    printf("%i, ", stringLength(""));
    printf("%i\n", stringLength("complete"));

    return 0;
}
void JsonSerializer::serialize(const char* label, unsigned int value)
{
	writeBlockComma();
	char tmp[20];
	writeString(label);
	toCString(value, tmp, 20);
	m_file.write(" : ", stringLength(" : "));
	m_file.write(tmp, stringLength(tmp));
	m_is_first_in_block = false;
}
Exemple #9
0
 int main (void)
 {
 	int stringLength (const char string[]);
 	const char word1[] = { 'a', 's', 't', 'e', 'r', '\0' };
 	const char word2[] = { 'a', 't', '\0' };
 	const char word3[] = { 'a', 'w', 'e', '\0'};
 	
 	printf ("%i %i %i\n", stringLength (word1), stringLength (word2), stringLength (word3));
 	
 	return 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;

}
END_TEST

START_TEST(stringLengthTest)
{
#line 14
	int i;
	i = stringLength("test");

	fail_unless(i == 4, "did not return 4 for the word test");
	fail_unless(stringLength("") == 0, "did not return 0 for empty string");

}
Exemple #12
0
/*
 * Find the lengths of three strings.
 */
int main (void) {
    // String as an array
    char string1[] = "firstString";
    // String as a pointer to array
    char *string2 = "secondString";

    printf("Size of \"%s\" is %d\n", string1, stringLength(string1));
    printf("Size of \"%s\" is %d\n", string2, stringLength(string2));
    // Length of string literal
    printf("Size of \"%s\" is %d\n", "thirdString", stringLength("thirdString"));

    return EXIT_SUCCESS;
}
/**
* 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
Exemple #14
0
int areStringsEqual(char* x, char* y) {
    int lengthX = stringLength(x);
    int lengthY = stringLength(y);
    if (lengthX != lengthY) {
        return 0;
    }
    int i;
    for (i = 0; x[i] != '\0' || y[i] != '\0'; i++) {
        if (x[i] != y[i]) {
            return 0;
        }
    }
    return 1;
}
Exemple #15
0
void insertString (char source[], char insert[], int index)
{
    int stringLength (const char string[]);
    int i, sourceLen, insertLen;
    
    sourceLen = stringLength(source);
    insertLen = stringLength(insert);
    
    for (i = sourceLen; i >= index; --i)
        source[i + insertLen] = source[i];
    
    for (i = 0; i < insertLen; ++i)
        source[i + index] = insert[i];
}
Exemple #16
0
OsFile& OsFile::operator <<(float value)
{
	char buf[128];
	toCString(value, buf, lengthOf(buf), 7);
	write(buf, stringLength(buf));
	return *this;
}
Exemple #17
0
OsFile& OsFile::operator <<(u64 value)
{
	char buf[30];
	toCString(value, buf, lengthOf(buf));
	write(buf, stringLength(buf));
	return *this;
}
Exemple #18
0
TestResult* stringLengthTestTemplate(char* x, int expected, char* testName) {
    int actual = stringLength(x);
    TestResult* r = malloc(sizeof(TestResult));
    r -> testName = "stringLengthTest";
    r -> passed = areIntEqual(actual, expected);
    return r;
}
Exemple #19
0
	void fillDeviceList(const char* dev, DeviceList& device_list) override
	{
		const char* token = nullptr;

		int device_index = 0;
		const char* end = dev + stringLength(dev);

		while (end > dev)
		{
			token = reverseFind(dev, token, ':');
			char device[32];
			if (token)
			{
				copyNString(device, (int)sizeof(device), token + 1, int(end - token - 1));
			}
			else
			{
				copyNString(device, (int)sizeof(device), dev, int(end - dev));
			}
			end = token;
			device_list.m_devices[device_index] = getDevice(device);
			ASSERT(device_list.m_devices[device_index]);
			++device_index;
		}
		device_list.m_devices[device_index] = nullptr;
	}
Exemple #20
0
/*Even more stylish animation of provided string*/
void neonAnimation(char* text, int line)
{
	int i = 0, origin = 0, length = 0;

	length = stringLength(text);
	origin = 40 - (length/2);

	/*Print it on the center of chosen line*/
	for (i = 0; i <= length; i++)
	{
		move(line, origin+i);
		printw("%c", text[i]);
		wrefresh(stdscr);
		Sleep (NORMSPEED);
	}
	i = 0;

	/*De-print it*/
	for (i = 0; i <= length; i++)
	{
		move(line, origin+i);
		printw(" ");
		wrefresh(stdscr);
		Sleep (NORMSPEED);
	}
}
Exemple #21
0
/*This function additionally moves the cursor just behind the string that has
 *been just printed*/
void printAndWriteFrom(int row, char* text)
{
	int i = 0, length = 0;

	length = stringLength(text);
	/*TODO: Temporary solution for too long strings, need to refine it*/
	if (length > 70)
	{
		length = 70;
	}

	/*Let's first clear what has been written here*/
	move(row, 0);
	for (i = 0; i <= WIDTH-1; i++)
	{
		printw("%c", asciiTerminal[i][row-1]);
	}
	/*And now write what we wan't to write there*/
	move(row, 4);
	for (i = 0; i <= length; i++)
	{
        printw("%c", text[i]);
		wrefresh(stdscr);
		Sleep (TSPEED);
	}
    /*Storage the cursor's position in order to make printFrom place the cursor
    in the right place*/
	move(row,4 + i-1);
	getyx(curscr, curY, curX);
}
Exemple #22
0
/*Stylish animation of one line of text*/
void invardTextLineSlide(int line, char* whatToPrint)
{
	int j, i, length, begin;
    length = stringLength(whatToPrint);
    /*Check parity of length*/
    if (length%2 == 1)
    {
        j = 40 + ((length+1)/2);
    }
    else
    {
        j = 40 + (length/2);
    }
    i = 40 - (length/2);
    /*Will print chosen line from 'borders' of the line, inwards*/
    for (begin = 0; begin <= length; begin++)
    {
        move(line,i);
        printw("%c",whatToPrint[begin]);
        move(line,j);
        printw("%c",whatToPrint[length]);
        wrefresh(stdscr);
        Sleep (FASTSPEED);
        length--;
        j--;
        i++;
    }
}
Exemple #23
0
char* SumCharsAndDigits(const char* str)
{
	int total = 0;
	int i = 0;

	//if(str != NULL) // on vérifie que la chaine est initialisée
	//{
		int length = stringLength(str);
		for(i=0; i<length; ++i)
		{
			if(isdigit(str[i])) //si le caractere est un chiffre
				total += str[i] - '0';
			else 
				total += letterID(str[i]);
		}

		if (total >= 10)
		{
			int res = total % 10; // reste
			int deca = (total - res) / 10; // dizaine
			total = res + deca;
		}

	//}
	return (char)total + '0';
}
Exemple #24
0
/*if last number is 1, it will appear with animation*/
void printCenter(int line, char* whatToPrint, int wantToAnim)
{
	int i = 0, origin = 0, length = 0;

	length = stringLength(whatToPrint);
	origin = 40 - (length/2);

	/*Print it on the center of chosen line*/
	if (wantToAnim == 1)
    {
        for (i = 0; i <= length; i++)
        {
            move(line, origin+i);
            printw("%c", whatToPrint[i]);
            wrefresh(stdscr);
            Sleep (TSPEED);
        }
    }
    else
    {
        for (i = 0; i <= length; i++)
        {
            move(line, origin+i);
            printw("%c", whatToPrint[i]);
        }
        wrefresh(stdscr);
    }
}
END_TEST

START_TEST(concatString2)
{
#line 70
	char* str1;
	char* str2;
	char* str3;
	char* expected;
	char* observed;
	char* test;

	test = "beginning middle end";
	str1 = getSubString(test, 0, 9);
	str2 = getSubString(test, 10, 15);
	str3 = getSubString(test, 16, 19);
	expected = "beginning middle end";
	char* half;
	half = concatString(str1, str2);
	observed = concatString(half, str3);

	fail_unless(strcmp(expected,observed) == 0, "not equal strings");
	fail_unless(stringLength(test) == 20, "fail");	



}
Exemple #26
0
OutputBlob& OutputBlob::operator << (float value)
{
    char tmp[30];
    Lumix::toCString(value, tmp, Lumix::lengthOf(tmp), 6);
    write(tmp, stringLength(tmp));
    return *this;
}
Exemple #27
0
char* concat(char* string1, char* string2) {
    int length1 = stringLength(string1);
    int length2 = stringLength(string2);
    int length = length1 + length2;
    char* string = (char*)malloc(length + 1);
    int i;
    for (i = 0; i < length1; i++) {
        string[i] = string1[i];
    }
    int j;
    for (j = 0; j < length2; j++) {
        string[length1 + j] = string2[j];
    }
    string[length1 + j] = '\0';
    return string;
}
void LuaScript::parseProperties()
{
	static const char* PROPERTY_MARK = "-- LUMIX PROPERTY";
	const int PROPERTY_MARK_LENGTH = stringLength(PROPERTY_MARK);
	const char* str = m_source_code.c_str();
	const char* prop = findSubstring(str, PROPERTY_MARK);
	while (prop)
	{
		const char* token = prop + PROPERTY_MARK_LENGTH + 1;

		Property& property = m_properties.pushEmpty();
		token = getToken(token, property.name, sizeof(property.name));
		char type[50];
		token = getToken(token, type, sizeof(type));
		if (compareString(type, "entity") == 0)
		{
			property.type = Property::ENTITY;
		}
		else if (compareString(type, "float") == 0)
		{
			property.type = Property::FLOAT;
		}
		else
		{
			property.type = Property::ANY;
		}

		prop = findSubstring(prop + 1, PROPERTY_MARK);
	}
}
void JsonSerializer::serializeArrayItem(float value)
{
	writeBlockComma();
	char tmp[20];
	toCString(value, tmp, 20, 8);
	m_file.write(tmp, stringLength(tmp));
	m_is_first_in_block = false;
}
Exemple #30
0
int main()
{
    printf("Please input your characters, no longer than the string size of 50.\n");
    char input[50];
    scanf("%s", input);
    stringLength(input, 50);
    return 0;
}