Example #1
0
int main(int argc, char** argv) {
    char copy[10];
    char copy2[10];
    char copy3[10];
    memset(copy3,0,sizeof(copy3));
    memset(copy2,0,sizeof(copy2));
    
    char * result = stringCopy(copy, "SoftUni", 7);
    printf("%s\n", copy);
    //keep in mind that this like the default implementation of strncpy will not automatically add a null terminator if the size copied
    // is less than the original word, printing a non null terminated pointer may result in incorrect behavior
    // the null terminator of the original word will be copied if it's within the given size though
    stringCopy(copy2, "SoftUni", 3);
    printf("%s\n", copy2);
    
    // no bytes are overwritten so no null terminator is added, it is essentially printing garbage memory
    // in the standard implementation it's up to the user to make sure the destination contains no garbage data
    stringCopy(copy3, "C is cool", 0);
    printf("%s\n",copy3);
    
    //returning a char* from the function without using a buffer will return a pointer to garbage memory
    // one way to correct it is to malloc the memory before we return a pointer to it,
    // however then we would have to free it
    return (EXIT_SUCCESS);
}
Example #2
0
void inputTestCases()
{
	int i;
	struct testcases test[12] = {
				{"1010","0101","1111"},
				{"0000","0000","0000"},
				{"1111 1111","i111 1111","error"},
				{"0 0 0 0 0 0 0 0 0","0 0 1 1","0 0 0 0 0 0 0 1 1"},
				{"11 00","00 11","11 11"},
				{"","   111   ","111"},
				{"1111 1111","","11 1111 11"},
				{"11 11","1+ 11","error"},
				{"1 0 101","1 01","1 1 010"},
				{"1","1","1 0"},
				{" 0 "," 1 "," 1 "},
				{"","",""}
			};
	char *finalresult,*myinput1,*myinput2,*myoutput;
	for(i=0;i<12;i++)
	{
		myinput1 = (char *)malloc(inputlen(test[i].input1)*sizeof(char));
		myinput2 = (char *)malloc(inputlen(test[i].input2)*sizeof(char));
		myoutput = (char *)malloc(inputlen(test[i].output)*sizeof(char));
		stringCopy(myinput1,test[i].input1);
		stringCopy(myinput2,test[i].input2);
		stringCopy(myoutput,test[i].output);
		trimString(myoutput);
		finalresult = getResult(myinput1,myinput2);
		if(isEqual(finalresult,myoutput))
			printf("pass\n");
		else
			printf("fail\n");
	}
}
Example #3
0
extern void setDefaultTagFileName (void)
{
	if (Option.tagFileName != NULL)
		;  /* accept given name */
	else if (Option.etags)
		Option.tagFileName = stringCopy (ETAGS_FILE);
	else
		Option.tagFileName = stringCopy (CTAGS_FILE);
}
Example #4
0
tABC_TxDetails *
Metadata::toDetails() const
{
    tABC_TxDetails *out = structAlloc<tABC_TxDetails>();
    out->szName = stringCopy(name);
    out->szCategory = stringCopy(category);
    out->szNotes = stringCopy(notes);
    out->bizId = bizId;
    out->amountCurrency  = amountCurrency;
    out->amountSatoshi = 0;
    out->amountFeesAirbitzSatoshi = 0;
    out->amountFeesMinersSatoshi = 0;
    return out;
}
Example #5
0
Config2Cpp::Config2Cpp(const char * progName)
{
	m_progName            = stringCopy(progName);
	m_cfgFileName         = 0;
	m_schemaOverrideCfg   = 0;
	m_schemaOverrideScope = stringCopy("");
	m_className           = 0;
	m_cppExt              = 0;
	m_hExt                = 0;
	m_wantSingleton       = false;
	m_wantSchema          = true;
	m_namespaceArraySize  = 0;
	m_namespaceArray      = 0;
}
Example #6
0
//Gets the last token of a list
char *getLastToken (struct token *list) {
    struct token *current = list;
    while (current -> next) {
        current = current -> next;
    }
    return stringCopy(current -> text);
}
Example #7
0
int main(int argc, char **argv)
{
	char **newArray;
	int argLength;
	int i;
	int j;

	argLength = argc - 1;

	i = 1;
	while (i < argLength)
	{
		newArray[i - 1] = stringCopy(argv[i]);
		i++;
	}
	
	i = 0; 
	j = 0;
	while (newArray[i] != '\0')
	{
		while(newArray[i][j] != '\0')
		{
			ft_putchar(newArray[i][j]);
			j++;
		}
		i++;
	}

	return (0);
}
void test_updateTheString_should_update_the_string_object_if_the_identifier_is_being_in_front_of_the_expression()
{
	
	String *testTokenizer =malloc(sizeof(String));
	testTokenizer->rawString = "num1+12";
	testTokenizer->startIndex = 0;
	testTokenizer->length = 7;
	String *newTokenizer;
	Token *testToken;
	Operator *opeToken;
	Number *numToken;
	Identifier *testIdentifier= malloc (sizeof(Identifier));
	testIdentifier->name = malloc (5);
	stringCopy("num1",testIdentifier->name,0,5);
	testIdentifier->type=IDENTIFIER;
	DefineElement element;
	element.ID = "num1";
	element.actualID = "4";
	
	getElement_ExpectAndReturn(DefineList, testIdentifier->name,&element);
	//Now start put the identifier and tokenizer into the function.
	newTokenizer = getFromListAndUpdate(testTokenizer,testIdentifier->name);
	TEST_ASSERT_EQUAL(4,newTokenizer->length);
	TEST_ASSERT_EQUAL(0,newTokenizer->startIndex);
	//check the string inside the String.
	TEST_ASSERT_EQUAL('4',newTokenizer->rawString[0]);
	TEST_ASSERT_EQUAL('+',newTokenizer->rawString[1]);
	TEST_ASSERT_EQUAL('1',newTokenizer->rawString[2]);
	TEST_ASSERT_EQUAL('2',newTokenizer->rawString[3]);
	TEST_ASSERT_EQUAL_STRING("4+12",newTokenizer->rawString);
	
	//Since the string been recreate try to get token from it until the last of the string.
	testToken = getToken(newTokenizer); //Should be 4.
	TEST_ASSERT_EQUAL(NUMBER,*testToken);
	numToken = (Number*)testToken;
	TEST_ASSERT_EQUAL(NUMBER,numToken->type);
	TEST_ASSERT_EQUAL(4,numToken->value);
	free(numToken);
	
	testToken = getToken(newTokenizer); //Should be +.
	TEST_ASSERT_EQUAL(OPERATOR,*testToken);
	opeToken = (Operator*)testToken;
	TEST_ASSERT_EQUAL(OPERATOR,opeToken->type);
	TEST_ASSERT_EQUAL(ADD,opeToken->id);
	free(opeToken);
	
	testToken = getToken(newTokenizer); //Should be 12.
	TEST_ASSERT_EQUAL(NUMBER,*testToken);
	numToken = (Number*)testToken;
	TEST_ASSERT_EQUAL(NUMBER,numToken->type);
	TEST_ASSERT_EQUAL(12,numToken->value);
	free(numToken);
		
	testToken = getToken(newTokenizer); //Should be NULL.
	TEST_ASSERT_NULL(testToken);
	free(newTokenizer);
	free(testIdentifier->name);
	free(testIdentifier);
	free(testTokenizer);
}
Example #9
0
char *
stringAppend(char * dest, const char * src, size_t size)
{
    size_t start = strlen(dest);
    size_t sizeLeft = size - start;
    return stringCopy(dest + start, src, sizeLeft);
}
int main(void)
{
	str_t str1,str2;

	str1=stringCrea(20,"hello ");
	str2=stringCrea(20,"world");
	stringPrint(str1);
	putchar('\n');
	printf("stringLeng:%d\n",stringLeng(str1));

	switch(stringComp(str1,str2)){
		case 0:puts("str1 = str2");break;
		case 1:puts("str1 > str2");break;
		case -1:puts("str1 < str2");break;
	}

	stringConcat(str1,str2);
	stringPrint(str1);
	putchar('\n');

	stringCopy(str1,str2);
	stringPrint(str1);
	putchar('\n');

	return(0);
}
Example #11
0
void setIdentifiantFichier(Identifiant i, const char * fichier)
{
    if (fichier != NULL)
    {
        i->fichier = stringCopy(fichier);
    }
}
void test_updateTheString_should_return_NULL_when_the_identifier_is_not_defined()
{
	
	String testTokenizer;
	testTokenizer.rawString = "12+num1";
	testTokenizer.startIndex = 0;
	testTokenizer.length = 7;
	String *newTokenizer;
	free(getToken(&testTokenizer));
	free(getToken(&testTokenizer));
	Identifier testIdentifier;
	testIdentifier.name = malloc (5);
	stringCopy("num1",testIdentifier.name,0,5);
	testIdentifier.type=IDENTIFIER;
	Error exception;
	getElement_ExpectAndReturn(DefineList, testIdentifier.name,NULL);
	//Now start put the identifier and tokenizer into the function.
	Try
	{
		newTokenizer = getFromListAndUpdate(&testTokenizer,testIdentifier.name);
	}
	Catch(exception)
	{
		TEST_ASSERT_EQUAL(UNDEFINED_IDENTIFIER,exception);
		TEST_ASSERT_EQUAL_STRING("Undefined Identifier! ",errorMessage.message);
		
	}
	free(testIdentifier.name);
}
Example #13
0
void setDocumentationRetour(Documentation d, const char * retour)
{
    if (d->retour != NULL)
    {
        free(d->retour);
    }
    d->retour = stringCopy(retour);
}
Example #14
0
void setDocumentationBrief(Documentation d,const char * brief)
{
    if (d->brief != NULL)
    {
        free(d->brief);
    }
    d->brief = stringCopy(brief);
}
END_TEST

START_TEST(stringCopyTest)
{
#line 21
	char* source;
	char* dest;
	source = "test";
	dest = stringCopy(source);

	fail_unless(strcmp(dest, source) == 0, "strcmp failed between dest and src");

	free(dest);
	dest = stringCopy("test");
	fail_unless(strcmp(dest, source) == 0, "strcmp failed between dest and src");

	free(dest);
	dest = stringCopy("");
	fail_unless(strcmp(dest, "") == 0, "strcmp failed between dest and an empty string");

}
Example #16
0
status_t
BHashMapCatalog::SetString(const char *string, const char *translated,
	const char *context, const char *comment)
{
	BString stringCopy(string);
	BString translatedCopy(translated);
	parseQuotedChars(stringCopy);
	parseQuotedChars(translatedCopy);
	CatKey key(stringCopy.String(), context, comment);
	return fCatMap.Put(key, translatedCopy.String());
		// overwrite existing element
}
Example #17
0
Identifiant creerIdentifiant(const char * nom)
{
    Identifiant i = (Identifiant)malloc(sizeof(struct Identifiant_t));
    i->nom = stringCopy(nom);
    if (i->nom == NULL)
    {
        
    }
    i->doc = NULL;
    i->fichier =NULL;
    return i;
}
Example #18
0
int main(){

    char str1[100],str2[100];

    printf("Enter any string:\n ") ;
    scanf("%s",str1);

    stringCopy(str1,str2);

    printf("After copying: %s \n",str2);
 
    return 0;
}
static void collectPpmData()
{
   // ber integer
   _streams[0].streamValue.choice.integer = ((rand() % 80) - 64) * 32; // from -64 to +15 in db/32

   // octets containing big endian int16
   *(short *)&_streams[1].streamValue.choice.octets.pOctets[0] = htons(((rand() % 256) - 128) * 32); // from -128 to +127 in db/32

   // octets containing little endian int32
   *(berint *)&_streams[1].streamValue.choice.octets.pOctets[4] = ((rand() % 256) - 255) * 32; // from -255 to 0 in db/32

   stringCopy(_streams[2].streamValue.choice.pString, STREAMS_MAX_STRING_LENGTH, "abc");
   _itoa_s(rand() % 100, &_streams[2].streamValue.choice.pString[3], STREAMS_MAX_STRING_LENGTH - 3, 10);
}
Example #20
0
/**
 * Gets the bit coin public address for a specified request
 *
 * @param szRequestID       ID of request
 * @param pszAddress        Location to store allocated address string (caller must free)
 * @param pError            A pointer to the location to store the error if there is one
 */
tABC_CC ABC_TxGetRequestAddress(Wallet &self,
                                const char *szRequestID,
                                char **pszAddress,
                                tABC_Error *pError)
{
    tABC_CC cc = ABC_CC_Ok;

    Address address;
    ABC_CHECK_NEW(self.addresses.get(address, szRequestID));
    *pszAddress = stringCopy(address.address);

exit:
    return cc;
}
Example #21
0
//Returns the text for the token at possition pos
char *getTokenForPos (struct token *list, int pos) {
    int count = 0;
    struct token *current = list;
    while (count != pos) {
        if (current -> next) {
            current = current -> next;
        }
        else {
            return NULL;
        }
        count ++;
    }
    return stringCopy(current -> text);
}
Example #22
0
void parse_membres(char *chaine,cmd *c){
	unsigned int i=0;
	char * cTmp=NULL, * cTok=NULL;

// 	stringCopy(c->cmd_initial, chaine);
	c->cmd_initial = chaine;
	c->cmd_membres = (char **) malloc(sizeof(char *)*1);
	if(c->cmd_membres==NULL){
		perror("allocation raté // parse_membres");
		exit(EXIT_FAILURE);
	}

	stringCopy(&cTok, c->cmd_initial);

	cTmp = strtok(cTok, "|");
	while( cTmp != NULL){
		// réallocation du tableau
		c->cmd_membres = (char **) realloc(c->cmd_membres, sizeof(char *)*(i+1));
		if(c->cmd_membres==NULL){
			perror("réallocation raté // parse_membres");
			exit(EXIT_FAILURE);
		}

		c->cmd_membres[i]=NULL;
		// affectation
		stringCopy(&(c->cmd_membres[i]), cTmp);

		//extraction du membres suivants
		cTmp = strtok(NULL, "|");

		i++;

	}
	c->nb_membres = i;
	free(cTok);
	free(cTmp);
}
Example #23
0
/** @brief Send a debug message
 *
 * Sends a null terminated debug message out on the broadcast address of all available interfaces.
 *
 * @author Fred Cooke
 *
 * @warning ONLY use this function from within the communication handler.
 *
 * @see sendDebugIfClear()
 * @see sendDebugBusyWait()
 *
 * @note This function exists as a convenience to developers, do not publish code that calls this function.
 *
 * @todo TODO clean up the mess of commented out crap in here!
 *
 * @param message is a pointer to the null terminated debug message string.
 */
void sendDebugInternal(unsigned char* message){

//	set buffer in use, consider blocking interrupts to do this cleanly

//	if(TRUE){
//		Counters.serialDebugUnsentCounter++;
//		return;
//	}
	// wrong :
	/* No need for atomic block here as one of two conditions will always be */
	/* true when calling this. Either we have been flagged to receive and    */
	/* decode a packet, or we are in an ISR. In either case it is safe to    */
	/* check the flags and initiate the sequence if they are clear.          */
	//if(RXTXSerialStateFlags & TX_IN_PROGRESS){
		// wrong :
		/* It's OK to return without resetting as it will be done by */
		/* either of those processes if they are underway. The other */
		/* processes are not overridden because they have priority.  */
		//TXBufferInUseFlags = 0;
		//return;
//	}else{ /* Turn off reception */
		/* It's OK to turn this off if nothing was currently being received */
	//	SCI0CR2 &= SCICR2_RX_ISR_DISABLE;
	//	SCI0CR2 &= SCICR2_RX_DISABLE;

		/* Build up the packet */
		/* Set the pointer to the start and init the length */
		TXBufferCurrentPositionHandler = (unsigned char*)&TXBuffer;

		/* Load a protocol with length header into the TX buffer ready for masking */
		*TXBufferCurrentPositionHandler = 0x11;
		TXBufferCurrentPositionHandler++;

		/* Set the payload ID */
		*((unsigned short*)TXBufferCurrentPositionHandler) = asyncDebugInfoPacket;
		TXBufferCurrentPositionHandler += 2;

		/* Store the length location */
		unsigned short* TXLength = (unsigned short*)TXBufferCurrentPositionHandler;
		TXBufferCurrentPositionHandler += 2;

		/* Copy the string into place and record the length copied */
		unsigned short messageLength = stringCopy(TXBufferCurrentPositionHandler, message);
		*TXLength = messageLength;
		TXBufferCurrentPositionHandler += messageLength;

		finaliseAndSend(0);
	//}
}
Example #24
0
void parse_distant(cmd *c){
	unsigned int i = 0;
	char * str, * cTok, * cTmp;
	if(c->distant==NULL){
		c->distant = (char ***) malloc(sizeof(char **) * c->nb_membres);
		if(c->distant==NULL){
			perror("allocation raté // parse_distant");
			exit(EXIT_FAILURE);
		}

		for(i = 0; i<c->nb_membres; i++){
// 			c->distant[i] = NULL;
			c->distant[i] = (char **) malloc(sizeof(char *) * 2);
			if(c->distant[i]==NULL){
				perror("allocation raté // parse_distant");
				exit(EXIT_FAILURE);
			}

			str = strstr(c->cmd_membres[i], "s:");

			if(str!= NULL){

				stringCopy(&cTok, c->cmd_membres[i]);
				cTmp = strtok(cTok, ":");
				cTmp = strtok(NULL, ":");
				stringCopy(&(c->distant[i][0]), cTmp);
				cTmp = strtok(NULL, " ");
				stringCopy(&(c->distant[i][1]), cTmp);
				free(cTok);
			}else{
				c->distant[i][0] = NULL;
				c->distant[i][1] = NULL;
			}
		}
	}
}
int main()
{
	const int S_LENGTH = 30;
	char dest[S_LENGTH], source[S_LENGTH];

	std::cout << "Enter a string with no more than " <<
		S_LENGTH - 1 << " charactesrs : " << std::endl;
	std::cin.getline(source, S_LENGTH);

	stringCopy(dest, source);

	std::cout << "The string you entered is:" << std::endl << dest << std::endl;

    return 0;
}
Example #26
0
int getProductCardType(U8_t id, char* type, int bufferLength)
{
   int returnValue=false;
	MYKI_CD_Product_t product;
	if (getProduct(id, product) == false)
	{
		CsDebug(CD_DEBUG, (CD_DEBUG, "MYKI_CD:getProductCardType: getProduct failed, returning fail"));
	}
	else
	{
		stringCopy(type, product.type, bufferLength);
		returnValue = true;
	}

    return returnValue;
}
static gint xdmcp_add_text(proto_tree *tree, const char *text,
		     tvbuff_t *tvb, gint offset)
{
  const guint8 *p;
  char *str;
  guint len;

  len = tvb_get_ntohs(tvb, offset);
  p = tvb_get_ptr(tvb, offset+2, len);
  str = g_malloc(len+1);
  stringCopy(str, (gchar*)p, len);
  proto_tree_add_text(tree, tvb, offset, len+2, "%s: %s", text, str);
  g_free(str);

  return len+2;
}
Example #28
0
//Creates a string out of all the texts in a token list
//Excluding the first token
char *convertAllButFirst (struct token *list) {
    struct token *current = list;
    char *outputString = malloc(1);
    outputString[0] = '\0';
    while (current -> next) {
        if (outputString[0]) {
            char *lineSpace = malloc(2);
            lineSpace[0] = ' ';
            lineSpace[1] = '\0';
            outputString = combine(outputString, lineSpace);
        }
        char *tokenText = stringCopy(current -> next -> text);
        outputString = combine(outputString, tokenText);
        current = current -> next;
    }
    return outputString;
}
NS_IMETHODIMP
nsIOService::EscapeString(const nsACString& aString,
                          uint32_t aEscapeType,
                          nsACString& aResult)
{
  NS_ENSURE_ARG_MAX(aEscapeType, 4);

  nsAutoCString stringCopy(aString);
  nsCString result;

  if (!NS_Escape(stringCopy, result, (nsEscapeMask) aEscapeType))
    return NS_ERROR_OUT_OF_MEMORY;

  aResult.Assign(result);

  return NS_OK;
}
void test_updateTheString_should_update_the_string_object_as_defined_by_user()
{
	String *testTokenizer =malloc(sizeof(String));
	testTokenizer->rawString = "12+num1";
	testTokenizer->startIndex = 0;
	testTokenizer->length = 7;
	String *newTokenizer;
	Token *testToken;
	Number *numToken;
	free(getToken(testTokenizer));
	free(getToken(testTokenizer));
	Identifier *testIdentifier= malloc (sizeof(Identifier));
	testIdentifier->name = malloc (5);
	stringCopy("num1",testIdentifier->name,0,5);
	testIdentifier->type=IDENTIFIER;
	DefineElement element;
	element.ID = "num1";
	element.actualID = "4";
	
	getElement_ExpectAndReturn(DefineList, testIdentifier->name,&element);
	//Now start put the identifier and tokenizer into the function.
	newTokenizer = getFromListAndUpdate(testTokenizer,testIdentifier->name);
	TEST_ASSERT_EQUAL(1,newTokenizer->length);
	TEST_ASSERT_EQUAL(3,newTokenizer->startIndex);
	//check the string inside the String.
	TEST_ASSERT_EQUAL('1',newTokenizer->rawString[0]);
	TEST_ASSERT_EQUAL('2',newTokenizer->rawString[1]);
	TEST_ASSERT_EQUAL('+',newTokenizer->rawString[2]);
	TEST_ASSERT_EQUAL('4',newTokenizer->rawString[3]);
	TEST_ASSERT_EQUAL_STRING("12+4",newTokenizer->rawString);
	
	//Since the string been recreate try to get token from it until the last of the string.
	testToken = getToken(newTokenizer); //Should be 4.
	TEST_ASSERT_EQUAL(NUMBER,*testToken);
	numToken = (Number*)testToken;
	TEST_ASSERT_EQUAL(NUMBER,numToken->type);
	TEST_ASSERT_EQUAL(4,numToken->value);
	free(numToken);
		
	testToken = getToken(newTokenizer); //Should be NULL.
	TEST_ASSERT_NULL(testToken);
	free(newTokenizer);
	free(testIdentifier->name);
	free(testIdentifier);
	free(testTokenizer);
}