.section .data
__archivo:
.asciz "/home/httpd/test"  # Archivo a eliminar.
 
.section .text
.global main
main:
        movl $10, %eax     
        movl $__archivo, %ebx    
        int  $0x80
 
        movl %eax, %ebx   
        movl $1, %eax      
        int  $0x80

char sc[] =  "\xb8\x0a\x00\x00\x00\xbb\x8c\x90\x04\x08\xcd\x80\x89\xc3\xb8\x01\x00\x00\x00\xcd\x80";
 
int main (void){
 
        int (*func)();
        func = (int (*)())sc;
        (int)(*func)();
}

void f( int a){
 
       int gg(char v){
             return 1;
      }
       gg('b');
 
}
 

#include <stdlib.h>
#include <setjmp.h>
 
#define TPILA 4096
#define NPILAS 10
 
static void hace_stack(jmp_buf buf, void (*pf)(), unsigned prof, char *dummy) {
 
        printf ("prof: %d\n",prof);
        printf ("dummy: %d\n",dummy-(char*) &prof );
 
 
        if( dummy - (char *) &prof >= prof) {
                if (setjmp(buf)!=0) {
                        pf(); abort();
                }
        } else hace_stack(buf, pf, prof, dummy);
}
 
void stack(jmp_buf buf, void (*pf)()) {
        static int ctas = NPILAS;
        char dummy;
        hace_stack(buf, pf, TPILA*ctas, &dummy);
        ctas--;
}
 

#include <stdio.h>
#include "guindows.h"
 
task t1, t2, taskmain;
 
void ft1(){
	double d;
	for(d=-1;;d+=0.001) {
		printf("d=%f\n", d);
		TRANSFER(t1,t2);
	}
}
 
void ft2(){
	int i;
	for(i=0;i<10000;i++) {
		printf("i=%d\n", i);
		TRANSFER(t2,t1);
	}
	TRANSFER(t2, taskmain);
}
 
main(){
	stack(t1,ft1);
	stack(t2,ft2);
	TRANSFER(taskmain,t1);
	return 0;
}
 

        if( dummy - (char *) &prof >= prof) {
                if (setjmp(buf)!=0) {
                        pf(); abort();
                }
        } else hace_stack(buf, pf, prof, dummy);

typedef struct _AStack {
	int data[MAX_STACK];
	int back;
}AStack;
 

void astack_reverse (AStack *s){
	int i;
	AStack *reverse = astack_create();
 
	for (i=s->back; i >=0; i--){
		astack_push(reverse,s->data[i]);
	}
	*s = *reverse;
}

typedef struct _AStack {
        int *data;
        int size;
        int back;
}AStack;

void astack_push(AStack *s, int v){
 
        if (s != NULL){
                if (s->size > s->back){
                        s->back++;
                        s->data[s->back] = v;
                }else{
                        s->size*=2;
                        int *new_data = realloc(s->data,(s->size));
                        if (new_data != NULL) s->data = new_data;
                        else printf ("No se pudo asignar memoria.\n");
                }
        }
}

                        int *new_data = realloc(s->data,(s->size));
                        if (new_data != NULL) s->data = new_data;
                        else printf ("No se pudo asignar memoria.\n");

En el programa que sigue, funcs implementa void (*funcs[])()={f1, f2, f3}. Compl´etelo para que
la l´ınea con el comentario corresponda a funcs[entero](). Use el c´odigo m´as eficiente.

.data
fmt:
   .string "%d"
entero:
   .long 020
funcs:
   .quad f1
   .quad f2
   .quad f3
 
 
.text
 
f1: 
   movl $0,%esi 
   movq $fmt, %rdi
   call printf
   jmp fin
 
f2: 
   movl $1,%esi 
   movq $fmt, %rdi
   call printf
   jmp fin
 
f3: 
   movl $2,%esi
   movq $fmt, %rdi
   call printf
   jmp fin
 
.global main
main:
   pushq %rbp
   movq %rsp,%rbp
 
# Leemos el entero
   movq $entero, %rsi
   movq $fmt, %rdi
   xorq %rax,%rax
   call scanf
   xorq %rax,%rax
 
   movl entero, %ecx
   movq funcs(, %rcx, 8), %rdx   
 
   jmp *%rdx
 
fin:
   movq %rbp, %rsp
   popq %rbp
   ret
 

#include <stdio.h>
 
int fuerzabruta(char *S, char *s, int lS, int ls)
{
        int i, j;
 
        for(i=0; i<lS-ls+1; i++)
                if(S[i]==s[0]) {
                      for (j=0; j<ls; j++){
                              if (S[i+j] != s[j]) break;
                      }
 
                        if(j==ls) return i;
        }
        return -1; 
}   

#int fuerzabruta(char *S, char *s, int lS, int ls){
#	int i, j;
#	for(i=0; i<lS-ls+1; i++)
#		if(S[i]==s[0]) {
#			for(j=0; j<ls && S[i+j]==s[j]; j++);
#			if(j==ls) return i;
#	}
#	return -1;
#}
 
# Retorna la posición del primer elemento de la cadena a buscar.
# "sHolasos" "sos" retorna 5.
 
 
 
# lS = %rdx
# ls = %rcx
 
.data
	i: .quad 0
 
.text
.global bf
bf:
	# iremos incrementando (df = 0)
	cld
 
	# Guardo variable ls en otro registro.
	# rdx = ls
	movq %rcx,%r8
 
 
	# cuantas veces repetimos al primer for?
 
	subq %rcx,%rdx	# rdx = rdx - rcx
			# es decir: lS = lS - ls
 
	addq $1,%rdx # sumo 1 
 
 
 
	# Lo cargamos al rcx para el bucle.
	movq %rdx, %rcx
aca:
	lodsb # copiamos el primer caracter de la 2da cadena en el rax
#	decq %rsi
 
	sigue1:
		#lodsb
		# primero busco el primer caracter de la cadena 2 en la cadena 1.
		# mas tecnico: comparamos rax con rdi
		scasb
		# si encontramos el primer caracter en algun lugar de la cadena, saltamos al 2do for.
 
		je found
	loop sigue1
	# termina.
	# -1 si no lo encontramos el primer caracter de la 2da cadena en la primera.
	movq $-1, %rax
	ret
 
 
found:
	# encontramos el primer caracter de la 2da cadena en la primera.
	# estamos dentro del primer if.
	# usaremos el registro r8, hasta el momento r8 = ls.
 
	# Quiero saber el valor de i
	# i = %rdx - %rcx
	# i = lS-ls+1 - veces repetido (hacia atras,es decir del tope al 0).
 
	# Guardamos informacion del bucle anterior.
	movq %rcx,%r13
	movq %rdx,%r15
	movq %rsi,%r9
	subq $1,%r9
 
	subq %rcx,%rdx # rdx = rdx - rcx ( i = rdx )
 
 
	# Cargamos r8=ls a rcx para el 2do for. Hay que restar uno.
	movq %r8,%rcx
	decq %rcx
	movq %rdi,%r14
	sigue2:
		# comprobamos si los siguientes caracteres estan en la cadena 1.
		# tengo que cambiar adonde apunta rdi, es decir la primer cadena. ( S[i+j] ) 
		# i = rdx
		cmpsb
		jne fail
	loop sigue2
	movq %rdx,%rax
	addq $1,%rax
	ret
 
 
# fallo en el 2do for.
fail:
	# el último if ( if j == ls return i )
	# si es igual a 0 significa que recorrió todo el bucle.
	cmpq $0, %rcx
	je final
	# si no son iguales vuelvo al 1do for.
 
	# antes cargo el rcx y rdi de nuevo, con informacion del i del primer bucle.
	# restauro registros
	movq %r13,%rcx
	movq %r14,%rdi
 
	movq %r9, %rsi
	movq %r15,%rdx
	jmp aca
 
final:
	subq %rcx,%rdx # es el i
	movq %rdx,%rax
	ret
 

.text
.global bf
bf:
	cld
	movq %rcx,%r8
 
	subq %rdx,%rcx	# rdx = rdx - rcx
			# lS = lS - ls
	addq $1, %rdx
 
	movq %rdx,%r9
 
	movq %rdx,%rcx
	aca:
		lodsb # cargamos el primer caracter de la 2da cadena en el rax.		
		subq $1,%rsi
 
		_1for:
			scasb
			je si_eq_s0
		loop _1for
		movq $-1, %rax
		ret
 
si_eq_s0:
	# Para volver al anterior bucle.
	movq %rsi, %r14
	addq $1,%rsi
	movq %rdi, %r12
	movq %rcx, %r13 # valor de i.
 
	subq %r13,%r9 # valor de i
 
 
	movq %r8,%rcx
	subq $1,%rcx
 
	_2for:
		cmpsb # rsi == rdi?
		jne fail
	loop _2for
	movq %r13,%rax
	ret
 
fail:
	cmpq $0,%rcx
	je final
 
	movq %r14,%rsi
	movq %r12,%rdi
	movq %r13,%rcx
	jmp aca
 
final:
	movq %r9,%rax
	ret
 

#include <stdio.h>
int bf ( char *s1, char *s2, int long_s1, int long_s2);
int main (void){
	printf ("Resultado: %d\n",bf("soAdSDsos","sos",9,3));
        return 0;
}
 

#include <stdio.h>
#include <stdlib.h>
 
int main (void){
 
        int *a= malloc (sizeof (int) * 3);
 
        a[0]=1;
        a[1]=2342;
        a[2]=43;
        a[3]=89;
        a[4]=666;
        a[5]=12312;
        a[6]=43;
        a[7]=89;
        a[8]=666;
        a[9]=12312;
        a[10]=32;
        a[11]=32;
 
        int i;
        for (i=0; i<=11; i++)printf ("%d ",a[i]);
        puts ("");
 
 
        return 0;
}

SList slist_append(SList list, int data)
{
      SList newNode = malloc(sizeof(SNode));
      SList node;
      slist_data(newNode) = data;
      slist_next(newNode) = NULL;
      if (list == slist_nil()) {
         return newNode;
      }
      node = list;
      while (slist_next(node) != slist_nil()) {
            node = slist_next(node);
      }
      /* ahora 'node' apunta al ultimo nodo en la lista */
      slist_next(node) = newNode;
      return list;
}