Esempio n. 1
0
File: strlib.c Progetto: cs50/spl
static void testStringCompare(void) {
   test(stringCompare("cat", "cat"), 0);
   test(stringCompare("cat", "dog"), -1);
   test(stringCompare("dog", "cat"), +1);
   test(stringCompare("", "xxx"), -1);
   test(stringCompare("xxx", ""), +1);
}
Esempio n. 2
0
    bool Term::equals(const Term* o) const {
    //Func - Compares two terms, returning true if they have the same
    //       field and text. 
    //Pre  - o is NULL or o points to a Term
    //Post - if pre(o) is NULL then false is returned, otherwise the result
	//       of the comparison has been returned which can be true or false
	        
        //Check if o points to a term
		if (o == NULL){
            return false;
            }
		//compare field with field of o and text with text of o and return the result of the comparisons
		return stringCompare(field,o->field) == stringCompare(text,o->text) == 0;
	}
Esempio n. 3
0
int main()
{
	//Get user's input.
	printf("Please input the first string. No more than 20 characters.\n");
	char input1[21];
	gets_s(input1, 20);
	printf("Please input the second string. No more than 20 characters.\n");
	char input2[21];
	gets_s(input2, 20);
	//Foreach the string. 
	int i;
	int compareReturn = 0;
	int breakCount = 0;
	for (i = 0; i < 21; i++)
	{
		compareReturn = stringCompare(input1[i], input2[i]);
		//Judge the return of the function. When it is 1, make breakCount varible plus 1. 
		if (compareReturn == 1)
		{
			breakCount++;
		}
	}
	//Use breakCount varible to judge these two strings are totally same or not.
	if (breakCount == 0)
	{
		printf("These two strings are same.\n");
	}
	else printf("These two strings are different.\n");
	return 0;
}
Esempio n. 4
0
bool DMString::operator ==(DMString& dm_string) {
	if (this->max_length != dm_string.max_length) {
		return false;
	}

	bool isSame = stringCompare(this->char_string, dm_string.char_string, this->max_length);
	return isSame;
}
Esempio n. 5
0
void MouseListener::handleEvent(const MinVR::EventRef& event,
		double synchronizedTime) {

	if (startsWith(event->getName(), "mouse_", 6))
	{
		if (event->getName() == "mouse_scroll")
		{
			handleClick(MouseButton::SCROLL, event->get2DData().y > 0, event->get2DData());
			return;
		}

		MinVR::WindowRef window = event->getWindow();
		glm::dvec2 res(window->getWidth(), window->getHeight());
		glm::dvec2 pos = event->get2DData() / res;

		if (event->getName() == "mouse_pointer")
		{
			handleMove(pos);
		}
		else
		{
			MouseButton button;
			if (stringCompare(event->getName(), "left", 10, 4))
			{
				button = LEFT;
			}
			else if (stringCompare(event->getName(), "middle", 10, 6))
			{
				button = MIDDLE;
			}
			else if (stringCompare(event->getName(), "right", 10, 5))
			{
				button = RIGHT;
			}

			if (stringCompare(event->getName(), "up", event->getName().size()-2, 2))
			{
				handleClick(button, false, pos);
			}
			else
			{
				handleClick(button, true, pos);
			}
		}
	}
}
Esempio n. 6
0
#include "CLucene/StdHeader.h"
#include "Document.h"
#include "Field.h"
#include "CLucene/util/StringBuffer.h"

using namespace std;
using namespace lucene::util;
namespace lucene{ namespace document{ 

    DocumentFieldList::DocumentFieldList(Field* f, DocumentFieldList* n) {
    //Func - Constructor
	//Pre  - f != NULL
	//       n may be NULL
	//Post - Instance has been created

	    CND_PRECONDITION(f != NULL, "f is NULL")

		field = f;
		next  = n;
	}
	DocumentFieldList::~DocumentFieldList(){
    //Func - Destructor
	//Pre  - true
	//Post - Instance has been destroyed

        _DELETE(next);
        _DELETE(field);
	}

	
	DocumentFieldEnumeration::DocumentFieldEnumeration(const DocumentFieldList* fl){
    //Func - Constructor
	//Pre  - fl may be NULL
	//Post - Instance has been created

		fields = fl;
	}

	DocumentFieldEnumeration::~DocumentFieldEnumeration(){
    //Func - Destructor
	//Pre  - true
	//Post - Instance has been destroyed
	}

	bool DocumentFieldEnumeration::hasMoreElements() const {
		return fields == NULL ? false : true;
	}

	Field* DocumentFieldEnumeration::nextElement() {
    //Func - Return the next element in the enumeration
	//Pre  - true
	//Post - The next element is returned or NULL


		Field* result = NULL;
		//Check if fields is still valid
        if (fields){
			result = fields->field;
		    fields = fields->next;
		    }
		return result;
	}

    Document::Document(){
    //Func - Constructor
	//Pre  - true
	//Post - Instance has been created

		fieldList = NULL; 
	}

	Document::~Document(){
    //Func - Destructor
	//Pre  - true
	//Post - Instance has been destroyed
	
		_DELETE(fieldList);
	}

	// Adds a field to a document.  Several fields may be added with
    // the same name.  In this case, if the fields are indexed, their text is
	// treated as though appended for the purposes of search. */
	void Document::add(Field& field) {
		fieldList = new DocumentFieldList(&field, fieldList);
	}

	// Returns a field with the given name if any exist in this document, or
	//	null.  If multiple fields may exist with this name, this method returns the
	//	last added such added. */
	 bool Document::getField(const char_t* name, Field*& retField) {
		for (DocumentFieldList* list = fieldList; list != NULL; list = list->next)
			if ( stringCompare(list->field->Name(), name) == 0 ){
				retField = list->field;
				return true;
			}
		
		return false;
	}
Esempio n. 7
0
bool DMString::operator==(const char * char_string) {
	int targetLength = getLength((char *) char_string);
	if (this->max_length != targetLength) {
		return false;
	}

	bool isSame = stringCompare(this->char_string, (char *) char_string, this->max_length);
	return isSame;
}
Esempio n. 8
0
int (*getfn(const char *word))() {
  struct table_entry* p;
  for (p = cmds; p->cmd; ++p) {
    if (!stringCompare(word, p->cmdname)) {
      return p->cmd;
    }
  }
  wprintf(&shell_wnd, "Command not found\n");
  return nothingcommand;
}
Esempio n. 9
0
void testStringCompare()
{
	if(stringCompare("cat","cat") == 0)
	{
		wprintf(&shell_wnd, "strings same pass\n");
	}
	else
	{
		wprintf(&shell_wnd, "strings same fail\n");
	}
	if(stringCompare("cate","cat") == -1)
	{
		wprintf(&shell_wnd, "strings diff pass\n");
	}
	else
	{
		wprintf(&shell_wnd, "strings diff fail\n");
	}	
}
Esempio n. 10
0
int isEqual(char **original,char **expected,int range)
{
    int i;
    for(i=0; i<range; i++)
    {
        if(!stringCompare(original[i],expected[i]))
            return 0;
    }
    return 1;
}
Esempio n. 11
0
int main(){
char c1[20],c2[20];

gets(c1);
gets(c2);
if(stringCompare(c1,c2)==1){
  printf("Strings Match\n");
}
else{
  printf("Strings DO NOT Match\n");
}

}
Esempio n. 12
0
	/** Prints a user-readable version of this query. */
	const char_t* TermQuery::toString(const char_t* field) {
		lucene::util::StringBuffer buffer;
		if ( stringCompare(term->Field(),field)!= 0 ) {
			buffer.append(term->Field());
			buffer.append(_T(":"));
		}
		buffer.append(term->Text());
		if (boost != 1.0f) {
			buffer.append(_T("^"));
			buffer.append( boost,10 );
		}
		return buffer.ToString();
	}
Esempio n. 13
0
static bool
_predicate (void)
{
	bool fnval;
	Torture in, out;

	in.int8 = 0;
	in.uint8 = 1;
	in.int16 = 2;
	in.uint16 = 3;
	in.int32 = 4;
	in.uint32 = 5;
	in.int64 = 6;
	in.uint64 = 7;
//	in.float32 = 3.14;
//	in.float64 = 3.1415;
//	in.bool = false;
	in.int8Ptr = &in.int8; // Not technically legal to point into struct.
	in.tuple = stringAllocateInitialize("Hello, world!");
	strcpy ((char *) in.array, helloWorld);

	uint8_t buf[sizeof (Torture) + refSize(in.tuple)];
	EtnBufferEncoder *e = etnBufferEncoderNew(buf, sizeof(buf));
	EtnLength etnEncodedSize;
	etnEncode((EtnEncoder *) e, EtnToValue(&TortureType, &in), &etnEncodedSize);

	EtnBufferDecoder *d = etnBufferDecoderNew(buf, etnEncodedSize);
	etnDecode((EtnDecoder *) d, EtnToValue(&TortureType, &out));

	fnval = in.int8     == out.int8
	     && in.uint8    == out.uint8
	     && in.uint16   == out.uint16
	     && in.uint16   == out.uint16
	     && in.uint32   == out.uint32
	     && in.uint32   == out.uint32
	     && in.uint64   == out.uint64
	     && in.uint64   == out.uint64
//	     && in.float32  == out.float32
//	     && in.float64  == out.float64
//	     && in.bool     == out.bool
	     && *in.int8Ptr == *out.int8Ptr
	     && ! stringCompare (in.tuple, out.tuple)
	     && ! strcmp ((char *) out.array, helloWorld);

	free (e);
	etnBufferDecoderFree (d);
	stringUnhook (&in.tuple);
	stringUnhook (&out.tuple);

	return fnval;
}
Esempio n. 14
0
void stringSort(char str[][50]){
	int start = 0, end = 9, i = 0;
	char temp[50] = {'\0'};
	for(start = 0; start < end; end--){
		for(i = 0; i < end; i++){
			if(stringCompare(str[i], str[i+1]) == 1){
				strcpy(temp, str[i]);
				strcpy(str[i], str[i+1]);
				strcpy(str[i+1], temp);
			}
		}

	}
}
struct transaction * sortedArraysCommonElements(struct transaction *A, int ALen, struct transaction *B, int BLen) {
	if (A == NULL || B == NULL)
		return NULL;
	struct transaction* result = NULL;
	int i;
	int count = 0;
	for (i = 0; i < ALen; i++)
	{
		int j;
		for (j = 0; j < BLen; j++)
		{
			if (stringCompare(A[i].date, B[i].date))
			{
				count++;
				struct transaction *temp = result;
				result = (struct transaction*)malloc(count*sizeof(struct transaction));
				int z, k;
				//increasing the array size dynamically
				for (z = 0; z < count - 1; z++)
				{
					result[z].amount = temp[z].amount;
					k = -1;
					do{
						k++;
						result[z].date[k] = temp[z].date[k];
					} while (result[z].date[k] != '\0');
					k = -1;
					do{
						k++;
						result[z].description[k] = temp[z].description[k];
					} while (result[z].date[k] != '\0');
				}
				//copying the new transaction
				result[count - 1].amount = A[i].amount;
				k = -1;
				do{
					k++;
					result[count - 1].date[k] = A[i].date[k];
				} while (result[count - 1].date[k] != '\0');
				k = -1;
				do{
					k++;
					result[count - 1].description[k] = A[i].description[k];
				} while (result[count - 1].date[k] != '\0');
				break;
			}
		}
	}
	return result;
}
Esempio n. 16
0
static bool
_predicate (void)
{
	bool fnval;
	Strings in1, out1;
	StructContainingTuple in2, out2;

	in1.field1 = stringAllocateInitialize("Hello, world!");
	in1.field2 = stringAllocateInitialize("Goodbye, cruel world!");

	in2.strings = stringAllocateEmpty(sizeof (Strings));
	stringConcat (in2.strings, &in1, sizeof (Strings));

	uint8_t buf[1024];
	EtnBufferEncoder *e = etnBufferEncoderNew(buf, sizeof(buf));
	EtnLength etnEncodedSize;
	etnEncode((EtnEncoder *) e, EtnToValue(&StructContainingTupleType, &in2), &etnEncodedSize);

	EtnBufferDecoder *d = etnBufferDecoderNew(buf, etnEncodedSize);
	etnDecode((EtnDecoder *) d, EtnToValue(&StructContainingTupleType, &out2));

	out1 = *(Strings *) out2.strings->ptr;

	fnval = ! stringCompare (in1.field1, out1.field1)
	     && ! stringCompare (in1.field2, out1.field2);
	
	free (e);
	etnBufferDecoderFree (d);
	stringUnhook (&in1.field1);
	stringUnhook (&in1.field2);
	stringUnhook (&in2.strings);
	stringUnhook (&out1.field1);
	stringUnhook (&out1.field2);
	stringUnhook (&out2.strings);

	return fnval;
}
Esempio n. 17
0
int main()
{
  char str1[100],str2[100];
  int compare;
  printf("Enter first string: ");
  scanf("%s",str1);
  printf("Enter second string: ");
  scanf("%s",str2);
  compare = stringCompare(str1,str2);
  if(compare == 1)
    printf("Both strings are equal.");
  else
    printf("Both strings are not equal");
    return 0;
}
Esempio n. 18
0
NFAPI SCCString gh_getZipPackURL(SCCString url)
{
    // https://github.com/qokelate/CCGame
    // https://github.com/qokelate/CCGame.git
    // https://codeload.github.com/liftoff/GateOne/zip/master

    if (false == stringHasSubString(url, ".github.com/")
            && false == stringHasSubString(url, "://github.com/")) return nullptr;

    if (stringHasSuffix(url, "/zip/master"))
    {
        auto ptr = copyAsSCString(url);

        MLog("url: ", ptr);

        return ptr;
    }

    auto len = SCStringLen(url);

    auto ptr = (SCString)SCAlloc(len + 100);
    strcpy(ptr, "https://codeload.github.com");

    regexMatchFirst((void *)url, len, "://[^/]+/", nullptr, [&](SCRegexErrorInfo *errorInfo, size_t index, byte *buffer, size_t dataSize, void *param) {
        if (errorInfo)
        {
            MLog("error: ", errorInfo->errorMessage);
            return false;
        }

        auto pp = (SCCString)buffer + dataSize - 1;
        strcat(ptr, pp);

        return true;
    });

    len = SCStringLen(ptr);
    {
        auto pp = ptr + len - 4;
        if (stringCompare(pp, ".git")) *pp = 0;
    }

    strcat(ptr, "/zip/master");

    MLog("url: ", ptr);

    return ptr;
}
int countGreaterNumbers(struct transaction *Arr, int len, char *date) {
	int i = 0, c = -1;
	if (date != NULL && len > 0 && Arr != NULL){
		for (i = 0; i < len; i++)
		{
			if (stringCompare(Arr[i].date, date))
				c = i;
		}
		if (c != -1)
			return len - c - 1;
		else
			return 0;

	}
	else
		return -1;
}
Esempio n. 20
0
// -----------------------------------
// Main function
// Arguments:	argc = number of arguments suppled by user
//				argv = array of argument values
//
//
int main( int argc, char** argv ) {
	int done;
	char input[255];
	command_t temp_command;
	char tempPath[255];

	//if statements for signal handling
	if (signal(SIGCHLD, sig_child_handler) == SIG_ERR) {
		perror("Unable to create new SIGCHLD signal handler!");
		exit(-1);
	}
	// //if statements for ctrl-c handling
	// if (signal(SIGINT, sig_int_handler) == SIG_ERR) {
	// 	perror("Unable to create new SIGCHLD signal handler!");
	// 	exit(-1);
	// }

	done = FALSE;
	while (!done) {
		printf("$");
		fflush(stdout);
		gets(input);
		parse(input, &temp_command);
		if (stringCompare(temp_command.name,"exit")==1)
		{
			done = TRUE;
		}
		else if (is_builtin(&temp_command))
		{
			do_builtin(&temp_command);
		}
		else if (find_fullpath(tempPath, &temp_command))
		{
			execute(&temp_command);
		}
		else {
			printf("Command not found.\n");
		}
		cleanup(&temp_command);
	}

	// printf( "CSCI 340 Homework Assignment 2 - Have Fun!\n" );

	return 0;

} // end main function
Esempio n. 21
0
byte parseCommand(
  char       *message,
  byte        length,
  byte       *position,
  command_t **command) {

  byte errorCode = 5;

  for (byte commandType = 0;  commandType < commandCount;  commandType ++) {
    *command = & commands[commandType];

    if (stringCompare((*command)->name, & message[*position])) {
      skipToken(message, length, position);
      errorCode = 0;
      break;
    }
  }

  return(errorCode);
}
Esempio n. 22
0
int main() {
    // Declare 2dimensions arrays and initialing...
    char input[2][21] = {};
    int returnValue;
    // Get the two strings and estimate each length...
    printf("Please input the first string:");
    gets(input[0]);
    printf("Please input the second string:");
    gets(input[1]);
    
	//Give strings to the compare function...
    returnValue = stringCompare(input);

	//Print...
    if (returnValue < 0)
        printf("%s is smaller than %s.\n",input[0],input[1]);
    else if (returnValue == 0)
        printf("%s is equal to %s.\n",input[0],input[1]);
    else
        printf("%s is larger than %s.\n",input[0],input[1]);
    
}
Esempio n. 23
0
/**
 * Loads in the .WAL Image under the directory "Q2/textures/"
 * If the image already exists in the data array, then keep a pointer
 *  to the already-loaded .WAL Image.
 * If the image does not already exist, load it in and store its name
 *  in alphabetically-ordered array of texture names.
 */
void TextureLoader::loadNew( char *name, LPDIRECT3DDEVICE9 device ) {

    // Go through each image, testing to see if the image was already loaded
    for ( unsigned int imageNum = 0; imageNum < loadedImages.size(); ++imageNum ) {

        // Compare the WALImages' names. If they are the same,
        if ( stringCompare( name, loadedImages[ imageNum ]->getName() ) == 0 ) {
            // make a pointer to it in textures
            textures.push_back( loadedImages[ imageNum ] );
            return;
        }
    }

    // If the image was not loaded previously, then load it in.

    // Load in the WAL image directly
    WALImage *temp = new WALImage();
    temp->load( name, palette, 319, device );

    loadedImages.push_back( temp );
    textures.push_back( temp );
};
Esempio n. 24
0
static bool
_predicate (void)
{
	Buffer buffer, out;

	buffer.buf = stringAllocateInitialize("0123456789");
	buffer.current = &((uint8_t *) buffer.buf->ptr)[5];

	uint8_t buf[1024];
	EtnBufferEncoder *e = etnBufferEncoderNew(buf, sizeof(buf));
	EtnLength etnEncodedSize;
	etnEncode((EtnEncoder *) e, EtnToValue(&BufferType, &buffer), &etnEncodedSize);

	EtnBufferDecoder *d = etnBufferDecoderNew(buf, etnEncodedSize);
	etnDecode((EtnDecoder *) d, EtnToValue(&BufferType, &out));

	free (e);
	etnBufferDecoderFree (d);

	return ! stringCompare (buffer.buf, out.buf)
	    &&  out.current == &((uint8_t *) buffer.buf->ptr)[5]
	    && *out.current == '5';
}
Esempio n. 25
0
///  string-ci>?
euxlValue euxlstringCaInGt()
{
    return (stringCompare('>', euxmTrue));
}
Esempio n. 26
0
///  string-ci=?
euxlValue euxlstringCaInEql()
{
    return (stringCompare('=', euxmTrue));
}
Esempio n. 27
0
///  string-ci<=?
euxlValue euxlstringCaInLtEq()
{
    return (stringCompare('L', euxmTrue));
}
Esempio n. 28
0
///  string>?
euxlValue euxlStringGt()
{
    return (stringCompare('>', euxmFalse));
}
Esempio n. 29
0
///  string=?
euxlValue euxlStringEql()
{
    return (stringCompare('=', euxmFalse));
}
Esempio n. 30
0
///  string<=?
euxlValue euxlStringLtEq()
{
    return (stringCompare('L', euxmFalse));
}