Example #1
0
void ParsedObject::Combine(LispInt aNrArgsToCombine)
{
    LispPtr subList(LispSubList::New(iResult));

    DBG_(subList->SetFileAndLine(
                                 iParser.iInput.Status().FileName(),
                                 iParser.iInput.Status().LineNumber()););
Example #2
0
//funcion subList()
void subConjunto(ArrayList* self)
{
	int to, from;
	char resp;
	
	ArrayList* subLista;
	
	do
	{
		resp = 'n';
		
		from = pedirNumero("Ingrese la posicion desde donde desea empezar a copiar: ");
		
		to = pedirNumero("Ingrese la posicion hasta donde desea terminar de copiar: ");
	
		from--;
		to--;
		
		if(from > to)
			resp = preguntarSiSeguir("\nLas posiciones ingresadas son incorrectas\nDesea volver a intentarlo?s/n: ");
	
		else if(!longitudLista(self, from)||!longitudLista(self, to))
			resp = preguntarSiSeguir("\nLas posiciones ingresadas son incorrectas\nDesea volver a intentarlo?s/n: ");
		else
		{
			
			subLista = subList(self, from, to);
				
			printf("\nCONTENIDO DE LA SUBLISTA\n");
			
			mostrar(subLista);
			

		}		
		resp = tolower(resp);

	}while(resp != 'n');

	free(subLista);
	
}
Example #3
0
void ParsedObject::Combine(LispInt aNrArgsToCombine)
{
    LispPtr subList(LispSubList::New(iResult));

    // TODO: woof -- such ugliness!

    LispIterator iter(iResult);
    for (LispInt i = 0; i < aNrArgsToCombine; i++, ++iter)
        if (!iter.getObj())
            Fail();

    if (!iter.getObj())
        Fail();

    subList->Nixed() = *++iter;
    *iter = nullptr;

    InternalReverseList((*subList->SubList())->Nixed(), // TODO: woof
                        (*subList->SubList())->Nixed());
    iResult = subList;
}
/****
 *
 * Test driver for exercising the functions of GeneralList.
 *
 */
int main() {

    char* intArray[] = {"1","2","3"};	// Intializing array
    GeneralList* listOfStrings; 	// Test list holding strings
    GeneralList* listOfIntegers;	// Test list holding Integers

    /*
     * Allocate.
     */
    listOfStrings = newGeneralList();
    listOfIntegers = newGeneralListArray((char**) intArray,
	sizeof(intArray) / sizeof(char*));

    /*
     * Call the constructive methods.
     */
    putLast(putLast(putLast(listOfStrings, "x"), "y"), "z");
    putFirst(putFirst(putFirst(listOfStrings, "c"), "b"), "a");
    put(put(listOfStrings, "m", 3), "n", 4);
    set(listOfStrings, "N", 4);
    put(listOfIntegers, "4", 3);

    /*
     * Print out the results of the constructive methods.
     */
    printf("\nConstruction results:\n");
    printf("%s\n", toString(listOfStrings));
    printf("%s\n", toString(listOfIntegers));


    /*
     * Call the non-destructive access methods, printing out results
     * incrementally.
     */
    printf(
      "\nFirst, last, and middle elements of string list are: %s, %s, %s\n",
	getFirst(listOfStrings),
	getLast(listOfStrings),
	get(listOfStrings, 3)
    );


    /*
     * Call the destructive access methods, printing out results incrementally.
     */
    printf(
      "\nRemoved first, last, and middle elements of string list are: %s, %s, %s\n",
	removeFirst(listOfStrings),
	removeLast(listOfStrings),
	removeIth(listOfStrings, 2)
    );
    printf("String list after removals is: %s\n",
	toString(listOfStrings));
    printf(
      "\nMore removed -- first, last, and middle elements of string list are: %s, %s, %s\n",
	removeIth(listOfStrings, 0),
	removeIth(listOfStrings, 3),
	removeIth(listOfStrings, 1)
    );
    printf("String list after more removals is: %s\n",
	toString(listOfStrings));


    /*
     * Put back some elements for utility method testing.
     */
    put(put(put(listOfStrings, "b", 0), "N", 2), "y", 4);
    printf("String list after put backs: %s\n",
	toString(listOfStrings));

    /*
     * Call the utility methods.
     */
    printf(
	"\nResults of elementOf(\"b\"), elementOf(\"X\"), findIndex(\"N\"), findIndex(\"X\"):\n"
    );
	printf("%s, %s, %d, %d\n",
	    elementOf(listOfStrings, "b") ? "true" : "false",
	    elementOf(listOfStrings, "X") ? "true" : "false",
	    findIndex(listOfStrings, "N"),
	    findIndex(listOfStrings, "X")
	);
    printf("\nResults of sorting: %s\n", toString(sort(listOfStrings)));


    /*
     * Call the utility methods.
     */
    printf(
	"\nResults of subList(2,3), length, isEmpty, equals, and toString:\n"
    );
	printf("%s, %d, %s, %s, %s\n",
	    toString(subList(listOfStrings, 2, 3)),
	    length(listOfStrings),
	    isEmpty(listOfStrings) ? "true" : "false",
	    equals(listOfStrings, listOfIntegers) ? "true" : "false",
	    toString(listOfStrings)
	);

    /*
     * Do another sort.
     */
    putLast(putLast(putLast(putLast(listOfStrings, "4"), "3"), "2"), "1");
    printf("\nBefore 2nd sort: %s\n", toString(listOfStrings));
    printf("Results of 2nd sort: %s\n", toString(sort(listOfStrings)));
    printf("\n");
    
    return 0;
}