Programación en Lenguaje C avanzado. Universidad de Colima

Transcripción

1 Programación en Lenguaje C avanzado Universidad de Colima Colima, Col. Copyright 2001 por Rodolfo Gallardo-Rosales rodolfo@gallardo.cc

2 Programación en Lenguaje C avanzado Estado del presente documento Se edita el presente documento como un complemento a un tutorial de Turbo C. En este, se podrá encontrar técnicas, métodos y conocimientos sobre programación en Turbo C que no son muy comunes y que vendrán a completar el estudio de lenguaje de programación para aquél que ya se ha introducido al C. Tabla de contenidos 1. Ordenación y búsqueda 1.1. Ordenación por el método de la burbuja 1.2. Ordenación por selección 1.3. Ordenación por inserción 1.4. Ordenación Shell 1.5. La ordenación rápida 1.6. Ordenaciones genéricas frente a ordenaciones específicas 2. Colas, pilas, listas enlazadas y árboles binarios 2.1. Colas 2.2. Cola circular 2.3. Pilas 2.4. Listas simplemente enlazadas 2.5. Listas doblemente enlazadas 2.6. Arboles binarios 3. C y el 8086[8] 3.1. Bases 3.2. El ensamblador de Microsoft 3.3. Interfaz con rutinas en lenguaje ensamblador 3.4. Creación de una función en lenguaje ensamblador 4. Parámetros del sistema de disco 5. Hora y fecha 6. Gráficos 7. Librería de programas 8. Bibliografía

3 1. Ordenación y búsqueda La ordenación es el proceso de disponer un conjunto de información similar, en orden creciente o decreciente, dando una lista ordenada i de n elementos: i1 <= i2 <=... <= in Podemos encontrar dos categorías generales de ordenación: 1) la ordenación de arrays, en memoria y en archivos de discos y 2) la ordenación de archivos secuenciales en disco o en cinta. Sólo nos referiremos a la primera. Hay tres formas de ordenar arrays: Por cambio. Por selección. Por inserción. Realizando una analogía con cartas, ordenarlas por cambio, sería extenderlas boca arriba en una mesa y proceder a cambiar las cartas fuera de orden hasta que la baraja estuviera ordenada. En la ordenación por selección, se extenderían las cartas en la mesa y se seleccionará el valor más bajo, que mantendremos en la mano, y del resto de cartas en la mesa, seleccionaremos la siguiente más baja y la pondremos con la que tenemos en la mano, hasta que todas las cartas sean ordenadas. En la ordenación por inserción se mantienen las cartas en la mano, y tomándolas de una en una se ponen en un montón sobre la mesa, en su orden correspondiente Ordenación por el método de la burbuja La más conocida ordenación es esta, sin embargo es una de las peores forma de ordenación que se han hecho. Este método, utiliza la ordenación por cambio, usando repetidas comparaciones y, si es necesario, cambios adyacentes. Una forma simple es la siguiente: /* ordenación por el método de la burbuja*/ void burbuja(char *elemento, int contador) register int a,b; register char t; for (a=1;a<contador;++a) for (b=contador-1;b>=a;t--b) if (elemento[b-1] > elemento[b] /*intercambio de elementos*/ t=elemento[b-1];

4 elemento[b-1]=elemento[b]; elemento[b]=t; Elemento es un puntero del array de caracteres que se ordenará y contador es el número de elementos del array. Para que sea más visible la forma de ordenación, se sugiere la siguiente Actividad: >> Desarrollar en TC el programa ejemplo No Ordenación por selección Una ordenación por selección selecciona el elemento más bajo y lo cambia con el primer elemento. De los restantes n-1 elementos se cambiará por el segundo el siguiente valor más bajo y así consecutivamente. Una forma simple de la ordenación por selección es la siguiente: /* ordenación por selección*/ void seleccion(char *elemento, int contador) register int a,b,c; char t; for(a=0;a<controlador-1>++a) c=a; t=elemento[a]; for(b=a+1;b<contador;++b) if(elemento[b]<t) c=b; t=elemento[b]; elemento[c]=elemento[a]; elemento[a]=t; 1.3. Ordenación por inserción Este es el último algoritmo simple de ordenación. Esta ordena los dos primeros miembros del array. El algoritmo inserta el tercer miembro en su correspondiente posición de acuerdo a los dos primeros, el cuarto en relación a los tres, etc. Una versión de ordenación por inserción sería la siguiente:

5 /*ordenación por inserción*/ void insertar(char *elemento, int contador) register int a,b; char t; for(a=1;a<contador;++a) t=elemento[a]; b=a-1; while(b>=0&&t<elemento[b]) elemento[b-1]=elemento[b]; b--; elemento[b-1]=t; 1.4. Ordenación Shell Toma su nombre de su inventor, D.L. Shell. Este método en general proviene de la ordenación por inserción y se basa en la disminución de incrementos. Primero se ordenan los elementos separados en tres posiciones, después en dos posiciones y por último los que están juntos. Una forma simple del algoritmo de ordenación shell es el siguiente: /*ordenación de shell*/ void shell(char *elemento, int contador) register int i,j,k,s,w; char x,a[5]; a[0]=9; a[1]=5; a[2]=3; a[3]=2; a[4]=1; for(w=0;w<5;w++) k=a[w]; s=-k; for(i=k;i<contador;++i) x=elemento[i]; j=i-k; if(s==0) s=-k; s++; elemento[s]=x; while(x<elemento[j]&&j>=0&&j<=contador) elemento[j+k]=elemento[j]; j=j-k;

6 elemento[j+k]=x; 1.5. La ordenación rápida La ordenación rápida (quick sort) inventada por Hoare, tiene un rendimiento superior al de los demás métodos y se considera el mejor algoritmo de ordenación disponible en la actualidad. Un ejemplo de ordenación rápida lo da el siguiente fragmento de código, donde se muestra el algoritmo usado. /*función de preparación para ordenación rápida*/ void rapida(char *elemento, int contador) br(elemento,0,contador-1); /*ordenación rápida*/ void br(char *elemento, int izquierda, int derecha) register int i,j; char x,y; i=izquierda; j=derecha; x=elemento[(izquierda+derecha)/2]; do while(elemento[i]<x&&i<derecha) i++; while(x<elemento[j]&&j>izquierda) j--; if(i<=j) y=elemento[i]; elemento[i]=elemento[j]; elemento[j]=y; i++; j--; while (i<=j); if(izquierda<j) br(elemento,izquierda,j); if(i<derecha) br(elemento,i,derecha);

7 Para poder observar en forma clara y objetiva las diferencias de la ordenación, se sugiere la siguiente Actividad: >> Desarrollar en TC el programa ejemplo No Ordenaciones genéricas frente a ordenaciones específicas En la biblioteca de Turbo C existe la ordenación rápida genérica qsort() con el siguiente prototipo: void qsort(void *comienzo, int contador, int tamaño, int *cmpt()); comienzo es un puntero al principio de la lista de artículos que se han de ordenar. Contador especifica el número de elementos de la lista. Tamaño especifica la longitud en bytes de cada elemento de la lista. Cmp es un puntero a una función de comparación que contiene el prototipo int cmp(tipo *a, tipo *b); donde tipo es el tipo de elementos que están siendo ordenados. Con el propósito de comparar una versión especializada de ordenación rápida con la ordenación rápida que se encuentra en la biblioteca de Turbo C, se sugiere la siguiente Actividad: >> Desarrollar en TC el programa ejemplo No Colas, pilas, listas enlazadas y árboles binarios 2.1. Colas Los programas en C están formados por algoritmos y estructuras de datos. Un buen programa será la mezcla de ambos. Un buen programador debe poseer los métodos correctos de almacenamiento y recuperación para cualquier situación. Una cola es una lista lineal de información a la que se accede en el orden "primero que entra es el primero que sale" (llamada también FIFO 'First Input First Output'). Así, el primer elemento que entra en la cola, es el primero que se saca, y así sucesivamente. Para ver cómo funcionan las colas, veamos las funciones almacenar_en_cola(), que sitúe un elemento al final de la cola; y sacar_de_cola(), que quita el primer elemento de la cola. Se limita en forma arbitraria a 100 el número de entradas y se representa por la macro MAX.

8 /*almacenar una cita*/ void almacenar_en_cola(char *cola) if(pos_s==max) printf("la cola está llena\n"); return; p[pos_s]=cola; pos_s++; /*sacar una cita*/ char *sacar_de_cola() if(pos_a==pos_s) printf("no quedan (más) citas. \n"); return NULL; pos_a++; return p[pos_a-1]; Tienen ambas dos variables globales: pos_a que almacena el índice de la siguiente posición libre de almacenamiento y pos_s que almacena el siguiente elemento a sacar. Con el propósito de ver completo un programa simple de planificación de sucesos, se sugiere la siguiente Actividad: >> Desarrollar en TC el programa ejemplo No Cola circular En la parte anterior, podríamos haber pensado que en vez de parar el programa cuando alcance el límite del array utilizado para almacenar la cola, se pudiera volver a los índices pos_a y pos_s, lo que permitiría poner en la cola cualquier número de sucesos. A esta implementación se llama cola circular, y las funciones almacenar_en_cola() y sacar_de_cola() tendrían que sufrir algunos cambios, como se indica enseguida: void almacenar_en_cola(char *cola) if(pos_a+1==pos_s (pos_a+1==max&&!pos_s)) printf("cola llena\n"); return;

9 p[pos_a]=q; pos_a++; if(pos_a==max) pos_a=0; /*vuelta al ciclo*/ char *sacar_de_cola(void) if(pos_s==max) pos_s=0; /*vuelve a empezar*/ if(pos_s==pos_a) printf("no hay sucesos por resolver\n"); return NULL; pos_s++; return p[pos_s-1]; Con el propósito de ver en forma completa un programa que usa una cola circular, se sugiere la siguiente Actividad: >> Desarrollar en TC el programa ejemplo No Pilas Una pila es lo opuesto a una cola porque usa el método de acceso el último que entra es el primero que sale (llamado también LIFO 'Last Input First Output'). Como un ejemplo típico de su uso, Turbo C usa las pilas para poner los argumentos a las funciones. Solamente existen dos operaciones básicas que son push y pop (almacenar y sacar) que es usan en las principales funciones. Se requerirán las funciones poner_en_pila() y sacar_de_pila(), y como ejemplo, usaremos las siguientes: int *p; int *cdp; int *fpd; /*apuntará a una zona libre de memoria*/ /*apunta a la cima de la pila*/ /*apunta al fondo de la pila*/ /*poner un elemento en la pila*/ void poner(int i) if(p>fpd) printf("la pila está llena\n"); return; *p=1;

10 p++; /*tomar un elemento de la cima de la pila*/ quitar(void) p--; if(p<cdp) printf("límite inferior de la pila sobrepasado\n"); return 0; return *p; Para ver cómo se hace una calculadora de cuatro funciones, utilizando pilas, se sugiere la siguiente Actividad: >> Desarrollar en TC el programa ejemplo No Listas simplemente enlazadas Una lista simplemente enlazada requiere que cada elemento de información contenga un enlace al siguiente elemento de la lista. Cada elemento consiste normalmente e un registro que contiene los campos de información y el puntero de enlace. Hay dos caminos para construir una lista simplemente enlazada. El primero simplemente añade cada nuevo elemento al principio o al final de la lista. El otro añade elementos en un sitio específico de la lista (por ejemplo, en orden ascendente). La manera en que la lista esté construida determina la forma de codificar la función de almacenamiento. Para iniciar, se requiere definir una estructura de datos para guardar la información. Como las listas de correos son comunes, se usa una en este ejemplo. La estructura se define aquí: struct direccion char nombre[40]; char calle[40]; char ciudad[20]; char estado[3]; char cp[10]; struct direccion *siguiente; info;

11 La función almacenar_se() construirá una lista simplemente enlazada poniendo cada nuevo elemento al final. Se debe pasar un puntero a una estructura de tipo direccion, que contiene la información de dirección de memoria de la última entrada en la lista. La función es: void almacenar_se(struct direccion *i, struct direccion **ultimo) if(*!ultimo) *ultimo=i; /*primer elemento de la lista*/ else (*ultimo) ->siguiente=i; i->siguiente=null; *ultimo=i; La función almacenar_seo() insertará direcciones en la lista de correos en orden ascendente según el campo nombre. También actualiza automáticamente estos punteros cuando ocurre un cambio. /*almacenar en orden*/ void almacenar_seo(struct direccion *i, /*nuevo elemento para almacenar*/ struct direccion **primero, /*primero de la lista*/ struct direccion **ultimo) /*último de la lista*/ struct direccion *viejo, *p; p=*primero; if(!*ultimo) /*primer elemento de la lista*/ i->siguiente=null; *ultimo=i; *primero=i; return; viejo=null; while(p) if(strcmp(p->, i->nombre)<0) viejo=p; p=p->siguiente; else if(viejo) /*va en posición intermedia*/ viejo->siguiente=1; i->siguiente=p; return; i->siguiente=p; /*este es el nuevo primer elemento*/ *primero=i;

12 return; (*ultimo)->siguiente=i; /*se pone el último*/ i->siguiente=null; *ultimo=i; En una lista enlazada es raro encontrar una función específica, dedicada al proceso de recuperación, que devuelva un elemento tras otro en orden de lista. Es un código tan corto que simplemente se pone en otras rutinas, tales como buscar, borrar o visualizar. Por ejemplo, esta rutina visualiza todos los nombres de la lista de correos: void mostrar(struct direccion *principio) while(principio) printf(principio->nombre); principio=principio->siguiente; Aquí principio es un puntero al primer elemento de la lista. Devolver elementos de la cadena es tan simple como seguir la cadena. Se podría escribir una rutina de búsqueda basada en el campo nombre como sigue: struct direccion *buscar(struct direccion *principio; char *n) while(principio) if(!strcmp(n,principio->nombre)) return principio; principio=principio->prox; return NULL; /*no se encuentra*/ Como buscar() devuelve un puntero al elemento de la lista que es igual al nombre buscado, se debe declarar buscar() para devolver un puntero a un registro de tipo direccion. Si no se encuentra, devuelve nulo. El proceso de borrado de un elemento de una lista simplemente enlazada es directo. Como en la inserción, hay tres casos: borrado del primer elemento, borrado de un elemento del medio o del último elemento. Esta función borra un elemento dado de una lista de estructuras de tipo direccion.

13 void eliminarse ( struct direccion *p, /*elemento anterior*/ struct direccion *i, /*elemento que se va a borrar*/ struct direccion **primero, /*comienzo de la lista*/ struct direccion **ultimo); /*final de la lista*/ if(p) p->siguiente=i->siguiente; else *primero=i->siguiente; if(i==ultimo &p) *ultmo=p; 2.5. Listas doblemente enlazadas Las listas doblemente enlazadas consisten en datos que están ligados con el elemento que le sigue y con el anterior. Una lista con dos enlaces tiene dos grandes ventajas. La primera es que la lista se puede leer en las dos direcciones. Esto no sólo simplifica la ordenación de la lista, sino que también, en el caso de las bases de datos, permite al usuario recorrer la lista en dos direcciones. La segunda consiste en que, debido a que la lista entera se puede leer con el enlace hacia atrás o hacia adelante, si se invalida un enlace, se puede reconstruir utilizando otro. Tres operaciones primarias se pueden realizar con una lista doblemente enlazada: insertar un nuevo elemento primero, insertar en el centro o insertar al final. Usando de nuevo el ejemplo de la lista de correos, se puede modificar la estructura direccion como se muestra enseguida para adaptarla: struct direccion char nombre[40]; char calle[40]; char ciudad[20]; char estado[3]; char cp[10]; struct direccion *siguiente; struct direccion *anterior; info; La función almacenar_de() construye una lista doblemente enlazada, utilizando la estructura direccion como el elemento básico de datos.

14 void almacenar_deo(struct direccion *i; struct direccion **ultimo) if(!*ultimo) *ultimo=i; /*es el primer elemento de la lista*/ else (*ultimo)->siguiente=i; i->siguiente=null; i->anterior=*ultimo; *ultimo=i; En vez de ponerlo siempre al final, se puede tener una función que almacene cada elemento en una posición específica de la lista que se está construyendo. La función almacenar_deo() crea una lista que está ordenada en orden ascendente. El almacenamisnto es asignado dinámicamente usando malloc(). /*crear una lista doblemente enlazada en orden*/ void almacenar_deo ( struct direccion *i, /*elemento nuevo*/ struct direccion **primero, /*primer elemento de la lista*/ struct direccion **ultimo) /*ultimo elemento de la lista*/ struct direccion *old,*p; if(ultima==null) /*primer elemento de la lista*/ i->prox=null; i->prior=null; ultima=i; return i; p=principio; /*comienzo de la lista*/ old=null; while(p) if(strcmp(p->nombre,i->nombre)<0) old=p; p=p->prox; else if(p->prior) p->prior->prox=i; i->prox=p; i->prior=p->prior; p->prior=i; return principio; i->prox=p; /*nuevo primer elemento*/

15 i->prior=null; p->prior=i; return i; old->prox=i; /*pone al final*/ i->prox=null; i->prior=old; ultima=i; return principio; Cuando se elimina un elemento de una lista doblemente enlazada, hay tres casos a considerar: borrar el primer elemento, eliminar uno del medio o el último. La siguiente función borra un elemento del tipo direccion de la lista doblemente enlazada: void eliminar_de ( struct direccion *i, /*elemento que hay que borrar*/ struct direccion **primero, /*primer elemento*/ struct direccion **ultimo) /*ultimo elemento*/ if(i->prior) i->prior->prox=i->prox; else /*nuevo primer elemento*/ principio=i->prox; /*si se borra sólo un elemento de la lista*/ if(principio) principio->prior=null; if(i->prox) i->prox->prior=i->prior; return principio; Para que se pueda observar con mayor detenimiento un programa sencillo de una lista de direcciones postales que utiliza una lista doblemente enlazada, se sugiere la siguiente Actividad: >> Desarrollar en TC el programa ejemplo No Arboles binarios La cuarta estructura de datos es el árbol binario. Cuando éstos están ordenados, se prestan a búsquedas, inserciones y borrados rápidos. Cada elemento del árbol binario consta de la información con un enlace al miembro izquierdo y otro al derecho.

16 La raíz es el primer elemento del árbol. Cada elemento de datos se llama nodo. A cualquier trozo de árbol se llama subárbol. Un nodo que no tiene subárboles conectados a él se llama nodo terminal. Hay tres formas de recorrer el árbol: inorden, preorden y posorden. Con inorden se visita el subárbol izquierdo, la raíz y el subárbol derecho. Con preorden se visita la raíz y después el subárbol izquierdo y el derecho. Con posorden se visita el árbol izquierdo, el derecho y luego la raíz. Aunque un árbol no necesita estar ordenado siempre, la mayoría de las utilerías lo necesitan. Lo que constituye un árbol ordenado depende de cómo se recorrerá. Los ejemplos que usaremos, acceden al árbol en inorden. a siguiente función llamada arbola() construye un árbol binario ordenado. struct arbol *arbola ( struct arbol *raiz, struct arbol *r, char info) if(!r) r=(struct arbol *) malloc(sizeof(struct arbol)); if(!r) printf("memoria agotada\n"); exit(0); r->izquierda=null; r->derecha=null; r->info=info; if(raiz) return r; /*primera entrada*/ else raiz->derecha=r; return r; if(info<r->info) arbola(r,r->izquierda,info); else arbola(r,r->derecha,info); Para recorrer en inorden el árbol construido, usando arbola() e imprimiendo el campo info de cada nodo, se debería usar la función inorden() siguiente:

17 void inorden(struct arbol *raiz) if(!raiz) return; inorden(raiz->izquierda); printf("%c",raiz->info); inorden(raiz->derecha); Para ver la forma en que se imprime un árbol, se sugiere la siguiente Actividad: >> Desarrollar en TC el programa ejemplo No C y el 8086[8] Esta parte no pretende ser un tutorial del lenguaje ensamblador del 8086/8088. Tampoco es necesario que seamos expertos en lenguaje ensamblador, sino solamente entender qué es el lenguaje ensamblador Bases Los procesadores 8088 tienen 20 líneas para significar las direcciones. La forma de simbolizarlos, se llama segmento:desplazamiento. Formación de direcciones. En el formato de segmeneto:desplazamiento, se maneja de la siguiente manera: dirección B84F:0401 registro de segmento B84FH -> B84F0H dirección de desplazamiento 0401H H dirección absoluta B88F1H Una dirección absoluta puede ser expresada de varios modos en el formato segmento:desplazamiento. Por ejemplo: dirección 0050:0150 registro de segmento 0050H -> 00500H dirección de desplazamiento 0150H H dirección absoluta 00650H

18 es equivalente a: dirección 0005:0600 registro de segmento 0005H -> 00050H dirección de desplazamiento 0600H H dirección absoluta 00650H Las banderas Sumario de registros Hay 14 registros en el Estos pueden dividirse en cinco categorías arbitrariamente nombradas: 1. Banderas 2. Propósito general o 'X': AX, BX, CX, DX 3. Apuntador: BP, IP, SP 4. Indice: SI, DI 5. Segmentación: CS, DS, ES, SS Algunos bits del registro bandera de 16 bits (también llamado la palabra de estado del programa o PSW) reporta los resultados de operaciones lógicas o aritméticas. Carry flag (bandera de acarreo). Carry es TRUE después de que el resultado de una operación aritmética es un acarreo del bit de mayor orden. Parity flag (bandera de paridad). Esta bandera es TRUE si la suma de los 8 bits de menor orden en una operación aritmética es impar. Auxiliary carry flag (bandera de acarreo auxiliar). Es didéntica a la bandera de acarreo, excepto que refleja el acarreo del bit 3 en operaciones de 8 bits. Zero flag (bandera de cero). Esta bandera es TRUE siempre que el resultado de una operación aritmética sea cero. Sign flag (bandera de signo). Esta es TRUE si en el resultado de una operación aritmética, el bit de mayor orden es TRUE. Trap flag (bandera de trampa). Cuando es TRUE, esta bandera pone al 8086 en un estado especial de "debugging" que retorna el control del programa a una determinada localidad después de cada instrucción.

19 Interrupt enable/disable flag (bandera de habilitar/deshabilitar interrupción). Cuando esta bandera es TRUE, el 8086 reconoce las interrupciones después de completa la instrucción actual. Direction flag (bandera de dirección). Las instrucciones primitivas de cadena automáticamente incrementan o decrementan sus operandos de apuntador después de cada iteración. Una bandera TRUE incrementa los operandos. Overflow flag (bandera de sobreflujo). Es TRUE si hubo un acarreo dentro o fuera del bit más significativo. Es FALSE si hubo un acarreo dentro y fuera del bit más significativo. Propósito general (o grupo 'X') Estos cuatro registros -AX, BX, CX, DX- son de 16 bits, pero pueden ser direccionados separadamente como dos registros de 8 bits. Por ejemplo, AX pueden ser direccionados como AL (el byte bajo) o AH (el bit alto). AX: (A)ccumulator -acumulador-. Como el registro acumulador primario, el registro es único en cuatro modos: Primero, todas las operaciones de entrada/salida deben pasar a través del AX. Segundo, las instrucciones que involucran AX y datos inmediatos usualmente requeren menos memoria de programa que con otros registros. Tercero, varias de las poderosas instrucciones primitivas de cadena requieren que uno de los operandos esté en AX. Cuarto, AX contiene el operando más bajo en las instrucciones de multiplicar y dividir. BX: (B)ase register -registro base-. BX es el único registro 'X' que puede ser usado para direccionar memoria indirecta. CX: (C)ount -contador-. Algunas instrucciones del 8086 pueden ser iterativas; CX, que contiene el número deseado de repeticiones, es automáticamente decrementado después de cada iteración. DX: (D)ata -datos-. DX contiene la dirección del puerto de E/S en ciertos tipos de instrucciones de entrada/salida. Apuntador SP: (S)tack (P)ointer -apuntador de pila-. Este registro siempre apunta a la localidad de memoria conocida como pila. Las instrucciones de pila PUSH, POP, CALL, RET, mueven datos hacia y desde la memoria de la dirección contenida en SP. BP: (B)ase (P)ointer -apuntador de base-. También llamado el apuntador de marco, se provee para compensar los errores del 8086 en su indexado. IP: (I)nstruction (P)ointer -apuntador de instrucción-. Este registro de 16 bits siempre apunta a la próxima instrucción de programa a ser ejecutada.

20 Indice Este grupo tiene tres usos. Primero, cada uno puede ser empleado como un apuntador de propósito general. Segundo, pueden ser combinados con otros registros y/o valores. Tercero, pueden ser usados como operandos en cualquier instrucción lógica o aritmética. SI: (S)ource (I)ndex -índice fuente-. DI: (D)estination (I)ndex -índice destino-. Segmentación Cuando se accede a una memoria, un registro de segmento provee los 16 bits de mayor orden de la dirección de 20 bits. Esto es esencial para comprender que para cada instrucción y para todo direccionamiento hay un segmento de registro por defecto. CS: (C)ode (S)egment -segmento de código-. CS es el registro de segmento por defecto para todas las instrucciones que afectan la memoria de programa a través del registro IP. Esto significa que CS se agrega al IP para computar la dirección de la siguiente instrucción de programa. Esta instrucción jmp 1010 se entiende para significar jmp CS:1010h DS: (D)ata (S)egment -segmento de datos-. Excepto lo que se anotó, toda referencia a memoria de datos (en oposición al programa o pila) usa DS para formar su dirección. La instrucción mov ax,label Es interpretada como mov ax,ds:label ES: (E)xtra (S)egment -segmento extra-. ES es el registro de segmento por defecto en una instrucción primitiva de cadena. Esto permite a una instrucción acceder a la meoria fuera del apuntador de segmento. La instrucción mov ax,es:1010h se referirá a la memoria en 1010H desde el principio del segmento apuntado (64 k) por ES.

21 SS: (S)tack (S)egment -segmento de pila-. Este es el registro de segmento por defecto para todas las operaciones que involucren a SP o BP. Todas las operaciones de pila -PUSH, POP, CALL, RET- se refieren a datos de 64 k direccionados por SS. La instrucción mov ax,[bp+4] se interpretará como mov ax,ss:[bp+4] Modos de direccionamiento de memoria Hay tres modos principales de formar una dirección en el 8086: 1. Directo inmediato 2. Indirecto inmediato 3. Indirecto de registro Para todas las instrucciones ejemplo de movimiento, el operando de la izquierda es el destino y el operando de la derecha la fuente. Por ejemplo mov ax,bx moverá el valor en BX hacia AX. Similarmente, el operndo de la izquierda en instrucciones lógicas o aritméticas contendrán el resultado de la operación. Por ejemplo en la instrucción add ax,bx Ax y BX serán agregadas y el resultado será dejado en AX. Directo inmediato. Este es el modo más simple de direccionar memoria, meramente especifica la localidad de memoria a ser direccionada. mov al,label moverá el contenido de la dirección de memoria label hacia el registro AL. Indirecto inmediato. El direccionamiento indirecto implica que el operando contiene, no un valor del dato, sino la dirección del valor del dato. Este modo es como el directo inmediato, excepto que la localidad de memoria a ser direccionada se entiende que contiene la dirección del operador final: jmp[wordlabel]. Este modo es muy limitado. Indirecto de registro. En ensamblador, los corchetes alrededor de un operando de registro son el símbolo de que la instrucción es una referencia de memoria. Por ejemplo, mov ax,bx mverá hacia AX el valor en BX, pero mov ax,[bx] moverá hacia AX el valor de la localidad de memoria contenida en BX. Hay dos categorías de direccionamiento indirecto de registro, dependiendo de qué grupo de registros se usa. -> Indirecto indexado. Este modo usa ya sea SI o DI en el grupo indexado para contener la dirección del operando. Por ejemplo, mov ax,[si] mov ax,[di]

22 ambos cargan AX desde una dirección de memoria apuntada por el operando del registro índice. -> Indirecto de base. Como su nombre implica, esta forma de direccionamiento usa ya sea los registros "base", BP o BX. En todos los demás modos de direccionar, es idéntico al indirecto indexado: mov ax,[bx] mov ax,[bp] ;en segmento de datos ;en segmento de pila -> Indirecto de base indexado. Este modo de direccionar forma una dirección agregando el contenido de un registro base y el registro indexado: mov ax,[bx+si] mov ax,[bp+di] ;en segmento de datos ;en segmento de pila -> Desplazamientos. En todos los modos de registro indirecto, puede ser agregada una constante a los operandos. Todas las siguientes son direcciones legales: mov ax,[di+5] mov ax,[bp+5] mov ax,[bx+si+5] ;Indexado con desplazamiento ;Base con desplazamiento ;De base indexado con desplazamiento Las instrucciones condicionales JMP son particularmente ricas, correspondiendo con las instrucciones de C. Basado en la expresión cmp ax,bx: Operador de C Instrucciones condicionales JMP (Sinónimos) ax = = bx je (jz) ax! = bx jne (jnz) ax > bx ja (jnbe) ax < bx jb (jnaee,jc) ax > = bx jae (jnb,jnc) ax < = bx jbe (jna) La lista se muestra con mnemónicos para saltos condicionales sin signo El ensamblador de Microsoft Los módulos a que haremos referencia, usan el Ensamblador de módulos de Microsoft, versión 4.0. El ensamblador contextual El ensamblador de Intel utiliza mnemónicos contextuales: uso de una palabra clave para cada operación, y la misma palabra usada para diversas operaciones.

23 La idea aquí es que el ensamblador se supone como un rompecabezas para los programadores basado en el contexto e el cual el mnemónico aparece. Para entender las implicaciones de un dialecto contextual, consideremos las siguientes instrucciones: mov al,bl ;direccionamiento del registro mov [si],0 ; byte o palabra? mov al,10 ;direccionamiento inmediato de dato mov al,[ds:10] ;variable inmediata de memoria mov al,mem ;mem es una etiqueta para la dirección de 10 son requeridas cinco distintas operaciones, y se usa un solo menmónico (MOV). Especificadores de objeto primario Un objeto en memoria tiene cuatro propiedades primarias: tamaño, contenido, desplazamiento y segmento. Por defecto, el ensamblador asume que una referencia a un objeto es una referencia a su contenido. Otros tipos de referencia deben ser clarificadas al ensamblador a través de directivas de contexto Directivas de tamaño. de tamaño como: El almacenamiento es localizado usando pseudo-operadores vara DB 0 ;"define byte" --8 bits de almacenamiento varb DW 0 ;"define word" --16 bits de almacenamiento varc DD 0 ;"define double word" --32 bits de almacenamiento 3.3. Interfaz con rutinas en lenguaje ensamblador Cuando se escribe una rutina en lenguaje ensamblador, puede haber tres razones para ello: - Para aumentar la velocidad y eficacia de la rutina - Para realizar algunas funciones específicas de la máquina no disponibles en Turbo C - Para usar rutinas proporcionadas por terceros Hay dos formas de combinar rutinas en código ensamblador con Turbo C. La primera es la creación, ensamblado y enlace de rutinas separadas en lenguaje ensamblador con funciones en C. El segundo método usa la extensión estándar de Turbo C, llamada asm, para incluir en línea las instrucciones de código ensamblador directamente en funciones C. Convenio de llamadas Un convenio de llamadas es el método por el que un compilador C pasa información a las funciones y devuelve valores desde las funciones. Las soluciones normales usan los registros internos de la CPU o la pila del sistema para pasar información entre las funciones.

24 Turbo C pasa argumentos a funciones en la pila. Estos se ponen en la pila de derecha a izquierda. Es decir, dada la llamada func(a,b,c); se pone primero c, después b y luego la a. En el momento de entrar en un procedimiento en código ensamblador, se deben guardar en la pila los contenidos del registro BP y el valor actual del puntero de pila (SP) se debe poner en BP. Los únicos registros que se deben preservar son SI y DI, si los usan en rutinas. Antes de volver, la función en lenguaje ensamblador debe restaurar el valor de BP, SI y DI y reponer el puntero de la pila. Si la función en lenguaje ensamblador devuelve un valor, se pone en el registro AX si es un valor de 16 bits Creación de una función en lenguaje ensamblador El camino más simple para aprender a crear funciones es ver cómo Turbo C genera código utilizando la opción del compilador línea de comando -S. Esta opción provoca que salga un listado en lenguaje ensamblador del código que se genera. Comencemos por el siguiente programa: int suma(int a, int b); int resultado; main() resultado=suma(10,20); suma (int a, int b) int t; t=a+b; return t; La variable sum está declarada como global intencionalmente para ver ejemplos de datos locales y globales. Si se llama "test" al programa, entonces la siguiente línea creará "test.asm" c:\tc> tcc -S test

25 El contenido de "test.asm" es éste: name test _text segment byte public 'code' dgroup group _bass,_data assume cs:_text,ds:group,ss:dgroup _text ends _data segment word public 'data' label byte _data ends _bss segment word public 'bss' label byte _bss ends _text segment byte publis 'code' _main proc near ;line 4 mov ax,20 push ax mov ax,10 push ax call near ptr _add pop cx pop cx mov word ptr dgroup:_sum,ax ;line ret _main endp _add proc near push si push bp mov bp,sp ;line 9 ;line 10 ;line 11 ;line 12 mov si,word ptr [bp+6] add si,word ptr [bp+8] ;line 13 mov ;line 14 pop bp pop si ret _add endp

26 _text ends _bss segment word public 'bss' public _sum _sum label word db 2 dup (?) _bss ends _data segment word public 'data' s@ label byte _data ends _text segment byte public 'code' public _add public _main _text ends end Una de las formas más fáciles para escribir nuestras funciones en lenguaje ensamblador, es generar un esqueleto. Por ejemplo, supongamos que sea necesario hacer una rutina para multiplicar dos enteros. Para generar un esqueleto, hay que crear un archivo que contenga la siguiente función: mul (int a, int b) Después, compilarlo con la opción -S para que se produzca un archivo en lenguaje ensamblador. El archivo sería: name mul _text segment byte public 'code' dgroup group _bss,_data assume cs:_text,ds:group,ss:dgroup _text ends _data segment word public 'data' _d@ label byte _data ends _bss segment word public 'bss' _b@ label type _bss ends _text segment byte public 'code' _mul proc near push bp mov pop bp ret _mul endp _text ends

27 _data segment word public 'data' _s' label _data ends _text segment byte public 'code' public _mul _text ends end En este esqueleto, el compilador ha hecho todo el trabajo de definir los segmentos adecuados y establecer la pila y los registros. Lo que se tiene que hacer es entrar en los detalles. Para ver la función mul() acabada, se sugiere la siguiente Actividad: >> Desarrollar en TC el programa ejemplo No. 9 Una vez ensamblado, el código en ensamblador se puede enlazar a cualquier programa, por ejemplo: #include <stdio.h> main() printf("%d", mul(2,5)); 4. Parámetros del sistema de disco Hay cinco caraterísticas importantes acerca de un disco: 1. Las características físicas del disco: el medio (floppy, fijo, etc.), el número de lados y el número de sectores por pista. 2. El número de sectores encontrados en un bloque de localidad de memoria. Un bloque de localidad de memoria es una cantidad mínima de espacio de disco que puede ser localizada. Dependiendo de las características físicas del disco, un archivo de 1 byte puede ocupar tanto como 512 bytes de espacio. 3. El número de bytes contenidos por el sector físico. 4. El número total de celdas en un disco. 5. El número de celdas "libres" o sin usar. El tamaño total del disco puede ser calculado por: total de bytes = (bytes/sector) * (sectores/celda) * (total de celdas) La diferencia fundamental de las funciones DOS y las que se han mencionado anteriormente, yace en el número de argumentos a ser regresados por la función. getmod y

28 setmod solamente retornan un valor. En contraste, la función dskparms que será escrita regresa cuatro valores. Pero C solamente acepta un valor de retorno. Una solución al conflicto mencionado es escribir por separado cinco funciones, cada una de la cual devolverá su propio valor. Las cinco llamadas, contendrán entonces la información completa del disco. Declaración de la estructura dskdata Ya hemos listado la información que se requiere obtener del DOS, asumiremos que la declaración de esta estructura, reside en la cabecera STRUCT.H; la estructura será la siguiente: struct dskdata ; UCHAR unsigned unsigned unsigned unsigned mdsb; freeclust; totclust; bytes_sect; sect_clust; Una rutina en lenguaje ensamblador puede tomar precisamente el tamaño adecuado si conoce el desplazamiento de cada miembro desde el comienzo de la estructura. Nosotros podemos escribirlo en el archivo de cabecera EQUATES.H MDB EQU 0 ;1 byte (UCHAR) FREECLUST EQU 1 ;2 bytes (unsigned) TOTALCLUST EQU 3 ;2 bytes (unsigned) BYTES_CLUST EQU 5 ;2 bytes (unsigned) SECT_CLUST EQU 7 ;2 bytes (unsigned) Podemos hacer el código más general si definimos los desplazamientos de pila con comandos EQU; estas definiciones no sólo agregan portabilidad al codigo, sino que hacen el significado más claro. Por ejemplo, en lugar de mov ax[bp+4], escribiremos mov ax[bp+arg0]. Estas definiciones, se deberán agregar al archivo de cabecera PROGSEG.H: ARG0 EQU 4 ARG1 EQU 6 ARG2 EQU 8 ARG3 EQU 10 ARG4 EQU 12 ARG5 EQU 14 ARG6 EQU 16 ;desplazamiento del primer argumento de la pila ;...segundo... ;...etc. La rutina en lenguaje ensamblador para encontrar los parámetros de disco será:

29 DSK_PARAMS_DOS EQU 1CH ;parámetros generales del medio SPACE_LEFT_DOS EQU 36H ;espacio en el disco restante INCLUDE EQUATES.H INCLUDE PROGSEG.H EXTRN ucase: NEAR ;busca en otro módulo el ucase PUBLIC dskparms dskparms PROC NEAR 0 push bp 1 mov bp,sp 2 push si 3 mov dx,[bp+arg1] ;saca de la pila de DX la letra de la lectora 4 push dx ;lo pone en la pila donde ucase lo espera 5 call ucase ;lo hace mayúscula en la pila 6 pop dx ;lo devuelve de la pila hacia DX 7 sub dx,"@" ;obtiene el caracter del ASCII a la pila 8 mov [bp+arg1],dx ;pone el drive en la pila para uso posterior 9 mov ah,dsk_params_dos ;número de función DOS 10 push ds ;retorna el valor DOS y cambia registro ds 11 int 21h ;llama al MS-DOS 12 cmp al,0ffh ;ff=mal número de drive 13 mov al,byte PTR [bx] ;obtiene el descriptor_byte en caso de no error 14 pop ds ;obtiene de nuevo antiguo segmento de dato 15 jne drvok ;pila=bien, segmento=bien, regresa o.k. 16 mov ax,bad_drive ;regresa código de error de DOS 17 jmp dpexit drvok: 18 mov si,[bp+arg0] ;pone apuntador de estructura fuera de pila 19 mov [si+mdb],al ;pone MDB en al, pone el byte en la estructura ; ahora obtiene el resto de los parámetros 20 mov dx,[bp+arg1] ;pone la letra de drive fuera de pila 21 mov ah,space_left_dos ;prepara para próxima llamada DOS 22 int 21h ;llama al MS-DOS ; 23 mov [si+freeclust],bx ;instala valores en la estructura 24 mov [si+totalclust],dx 25 mov [si+bytes_clust],cx 26 mov [si+sect_clust],ax 27 mov ax,0 ;regresa código de éxito dpexit: 28 pop si 29 pop bp 30 ret

30 ; dskparms ENDP PUBLIC ucase ucase PROC NEAR ; 31 push bp 32 mov bp,sp 33 cmp BYTE PTR [bp+arg0],'a' ;revisa límite inferior 34 jc ucexit ;sale si es menor que 'a' low_ok: 35 cmp BYTE PTR [bp+arg0],'z' ;revisa límite superior 36 ja ucexit ;sale si superior a 'z' hi_ok: 37 sub BYTE PTR [bp+arg0],20h ;lo hace mayúscula ucexit: 38 pop bp 39 ret ; ucase ENDP INCLUDE ENDPSEG.H END Para ver un programa en TC que despliegue las características totales del disco, se sugiere la siguiente Actividad: >> Desarrollar en TC el programa ejemplo No Hora y fecha Existen cuatro formas de expresar la hora y la fecha en el MS-DOS: El directorio de disco: Contiene una entrada para cada archivo del disco. Cada entrada contiene la fecha y hora en que el archivo fue creado o modificado (actualizado). La hora y fecha son almacenadas como palabras empacadas de bits. Funciones de archivo del DOS: Leer o poner la hora y fecha en una entrada de archivo en un directorio. Llamadas a funciones del DOS de conservación de hora: Leer o poner el día y la hora de un calendario y reloj del sistema. El BIOS de la ROM: contiene las rutinas que dan servicio al interruptor del temporizador (número 8).

31 La hora y fecha en una entrada de directorio no está disponible para ser leída o escrita directamente. Sin embargo, el DOS lo permite mediante la función 57H que tiene el siguiente contenido: Registros en la entrada AH 57H AL 0 si se obtiene, 1 si se pone DX Fecha CX Hora BX Manejador de archivo Registros en la salida AX DX CX Código de error si existe la bandera de acarreo Fecha Hora Una rutina para manejar fecha y hora de un archivo es la función getstamp, que provee una interface común sobre las funciones que la modifican, por ejemplo, al cerrar un archivo, la hora y fecha que se ponen son las actuales, y no las originales, por lo que las rutinas siguientes, permitirán realizar esta función. La función getstamp obtiene la fecha y hora originales del archivo: FILE_STAMP_DOS EQU 57H TIME EQU 1 FETCH EQU 0 ;FD_ADJUST EQU?? ;----- poner en EQUATES.H INCLUDE EQUATES.H INCLUDE PROGSEG.H PUBLIC getstamp getstamp PROC NEAR ; push bp mov bp,sp ;; ;; Ajustar BX de acuerdo a cómo tu compilador convierte los manej. de archivo ;; mov bx,0 ;Manejadores de archivo menores que 100 mov b1,[bp+arg0] ;Saca un byte único fuera de la pila add bx,fd_adjust ;Agrega diferencia entre FD y FH ;;

32 ;;... Descriptores de archivo ;; mov ah,file_stamp_dos ;Función DOS 57H mov al,fetch ;Modo de obtención int 21h ;Llamada al MS-DOS not ax ;Hace el código de retorno negativo jc gfsexit mov ax,cx ;Mueve el tiempo hacia AX cmp BYTE PTR[bp+ARG1],TIME ;Revisa el modo de TIME en pila jz gfsexit ;si funciona, salir, si no... mov ax,dx ;... por defecto, regresa DATE and ah,7fh ;limita fecha máxima al 2043 gfsexit: pop bp ret gestamp ENDP INCLUDE ENDPSEG.H END La función putstamp pone al archivo hora y fecha, y es la siguiente: FILE_STAMP_DOS SET EQU 57H EQU1 INCLUDE PROGSEG.H PUBLIC putstamp putstamp PROC NEAR ; push bp mov bp,sp ;; ;; ajusta BX de acuerdo a los convertidores de archivo del compilador ;; mov bx,0 ;manejadores menor que 100 mov b1,[bp+arg0] ;saca un byte único de la pila add bx,fd_adjust ;agrega la diferencia entre FD y FH ;; ;;... descriptores de archivos ;; mov dx,[bp+arg1] ;obtiene fecha-a-poner de la pila mov cx,[bp+arg2] ;obtiene hora-a-poner de la pila mov ah,file_stamp_dos ;función 57H del DOS mov al,set ;modo poner int 21h ;llama al DOS jc sfdexit ;sale con código de error en AX mov ax,0 ;si no, regresa nulo

33 sfdexit: pop bp ret putstamp INCLUDE END ENDP ENDPSEG.H Un programa completo que cambia la hora y fecha de un archivo, se encontrará realizando la siguiente Actividad: 6. Gráficos >> Desarrollar en TC el programa ejemplo No. 11 Antes de usar cualquiera de las funciones gráficas de TC es preciso poner un adaptador de video en uno de los modos gráficos, usando la función initgraph(), que tiene el prototipo void far initgraph(int far *controlador, int far *modo, char far *camino); Carga un controlador de gráficos en memoria que corresponde al número indicado por controlador. El parámetro modo indica un número entero que especifica el modo de video usado por las funciones gráficas. Por último, se puede especificar un camino al controlador. Los controladores de gráficos se encuentran contenidos en archivos.bgi. Los valores de controlador válidos son: Macro Equivalente DETECT 0 CGA 1 MCGA 2 EGA 3 EGA64 4 EGAMONO 5 IBM HERCMONO 7 ATT400 8 VGA 9 PC Cuando se utiliza DETECT, initgraph() detecta automáticamente el tipo de hardware de video presente en el sistema y establece controlador y modo en sus valores correctos. La estructura viewporttype se define en graphics.h como sigue:

34 struct viewporttype int left, top, right, bottom; int clipflag; Los campos left, top, right y bottom contienen las coordenadas de los extremos superior izquierdo e inferior derecho de la ventana de gráficos. Las funciones fundamentales para el trazado de gráficos son las que dibujan un punto, una línea y un círculo. En TC, estas funciones son llamadas putpixel(), line() y circle(), respectivamente. Sus prototipos son: void far putpixel(int x, int y, int color); void far line(int iniciox, int inicioy, int finx, int finy); void far circle(int x, int y, radio); Se puede establecer el color del dibujo aplicable usando setcolor() cuyo prototipo es: void far setcolor(int color); Se puede rellenar cualquier figura cerrada usando la función floodfill(). Su prototipo es: void far floodfill(int x, int y, int color_borde); Los modelos de relleno son los siguientes: Macros Valor Significado EMPTY_FILL 0 Relleno con color de fondo SOLID_FILL 1 Relleno con color sólido LINE_FILL 2 Relleno con líneas LTSLASH_FILL 3 Relleno con el símbolo" ", poco denso SLASH_FILL 4 Relleno con el símbolo " " BKSLASH_FILL 5 Relleno con el símbolo "/" LTBKSLASH_FILL 6 Relleno con el símbolo "/", poco denso XHATCH_FILL 8 Relleno con rayado INTERLEAVE 9 Relleno con superposición WIDEDOT_FILL 10 Relleno con puntos ampliamente espaciados CLOSEDOT_FILL 11 Relleno con puntos muy poco espaciados USER_FILL 12 Relleno con modelos personalizados Para ver un programa completo de construcción de gráficos de tarta a partir de datos introducidos por el usuario, se sugiere la siguiente

35 Actividad: >> Desarrollar en TC el programa ejemplo No. 12 Otra función de TC crea barras que pueden ser utilizadas para desarrollar gráficos de barras. Esta función es llamada bar() y su prototipo es: void far bar(int izquierda, int arriba, int derecha, int abajo); La función bar() dibuja una barra rectangular que tiene su extremo superior izquierdo definido por izquierda, arriba y su extremo inferior derecho por derecha, abajo. Puede verse un programa que solicite al usuario el número de entradas, introducir la información y calcular el factor de normalización. Por último, visualizar una representación en gráfico de barras de los datos usando barras verticales. El factor de normalización hace dos tareas: 1. Comprueba que la barra más grande cabe en la pantalla. 2. Asegura que se use la altura de toda la pantalla. Para ver el citado programa, se sugiere la siguiente Actividad: >> Desarrollar en Tc el programa ejemplo No. 13 Se pueden también crear gráficos de barras tridimensionales usando bar3d() que tiene el prototipo: void far bar3d(int izquierda, int cima, int derecha, int abajo, int prof, int indicadorsup); Uso de getimage() y putimage() La función getimage() se usa para copiar una región de gráficos en una memoria intermedia (buffer). La función putimage() pone el contenido de una memoria intermedia en la pantalla. Tiene los prototipos void far getimage(int izquierda, int cima, int derecha, int abajo, void far *buf); void far putimage(int izquierda, int cima, void far *buf, int op); La función getimage() copia el contenido de una porción rectangular de la pantalla, definida por sus coordenadas superior izquierda e inferior derecha, en la memoria intermedia

36 apuntada por buf. Use putimage() para visualizar una memoria intermedia de datos gráficos almacenados previamente con getimage(). El valor de op determina exactamente cómo se escribe la imagen en la pantalla. Sus valores válidos enumerados (encontrados en graphics.h) son: Nombre Valor Significado COPY_PUT 0 Sobreescribir el destino XOR_PUT 1 OR-exclusivo con destino OR_PUT 2 OR-inclusivo con destino AND_PUT 3 AND con destino NOT_PUT 4 Invertir la imagen fuente El tamaño de la memoria intermedia, para una región de terminada,en bytes se proporciona por la función imagesize(). Se debe usar esta función en vez de intentar calcular manualmente el espacio necesario, ya que imagesize() proporciona el valor correcto con la independencia del modo de video que esté en uso. Su prototipo es: unsigned far imagesize(int izqueirda, int cima, int derecha, int abajo); Para ver un programa que demuestra las funciones getimage(), imagesize() y putimage(), que llena de blanco toda la pantalla, crea un rectángulo, lo rellena, dibuja dos líneas diagonales; después copia el rectángulo usando, primero COPY_PUT y después XOR_PUT se sugiere la siguiente Actividad: >> Desarrollar en TC el programa ejemplo No. 14 Salida de texto en modo gráfico Aunque las funciones estándar de texto de TC como printf() pueden usarse en la mayoría de los modos gráficos, no son la alternativa más flexible. Para aprovechar al máximo el entorno gráfico de TC será necesario usar las funciones de salida de texto en modo gráfico descritas en esta sección. La función que saca el texto a la ventana gráfica es outtext(), y su prototipo es: void far outtext(char *cad); Esta función saca la cadena apuntada por cad a la posición aplicable. (En el modo gráfico no hay cursor visible, pero la posición aplicable en la pantalla se mantiene como si hubiera un cursor invisible). Para cambiar el estilo, tamaño o dirección de la salida de texto obtenida con outtext(), se usa settextstyle() cuyo prototipo es:

37 void far settextstyle(int tipo, int direccion, int tamañocar); El parámetro tipo determina el tipo de juego de caracteres usados. Por omisión, es un tipo de mapas de 8x8 bits. Se puede dar a tipo uno de los siguientes valores: Tipo(font) Valor Significado DEFAULT_FONT 0 Tipo de 8x8 de mapas de bits TRIPLEX_FONT 1 Tipo triplex strocked SMALL_FONT 2 Tipo strocked pequeño SANS_SERIF_FONT 3 Tipo strocked sin serif GOTHIC_FONT 4 Tipo gótico strocked La dirección en que se visualiza el texto, izquierda a derecha o de abajo hacia arriba, se determina por el valor de dirección, que puede ser, o bien HORIZ_DIR (o cero) o VERT_DIR (o uno). El parámetro tamañocar es un multiplicador que aumenta el tamaño del caracter. Puede tener un valor de 0 a 10. Para ver un programa que muestre el uso de la función settextstyle() y muestre cada juego de caracteres en varios tamaños. se sugiere la siguiente Actividad: >> Desarrollar en TC el programa ejemplo No. 15 Cuando se cambia el tamaño del tipo (font) de mapas de 8x8 bits, sus dimensiones son multiplicadas por el valor de tamañocar. Es decir, si tamañocar es 2, los caracteres asignados a los bits serán dibujados en un cuadro de 16x16 pixels. Sin embargo, al teclearlos, será espaciado proporcionalmente. Para determinar la altura y anchura de los caracteres se usan las funciones textheight() y textwidth() respectivamente. Sus prototipos son: int far textheight(char far *cad); int far textwidth(char far *cad); Estas funciones proporcionan la altura y anchura, en pixels, de las cadenas indicadas por cad. Otro detalle importante acerca de outtext() es que no procesa caracteres de nueva línea. No hay modo de hacer un retorno de carro o un salto de línea. Para poner un texto en una posición específica de la ventana, se usa la función outtextxy(), cuyo prototipo es: void far outtextxy(int x, int y, char *cad);