trabajo practico nº 3 1q2010 -...

Alg. y Prog. I (75.02) - Trabajo Práctico Nº3 - 1º Cuat. 2010 _______________________________________________________________________________________________

1

TRABAJO PRACTICO Nº 3 – Documentador de Código Fuente (DOC II) 1) Objetivo del T.P.: El objetivo de este TP consiste en confeccionar un aplicativo escrito en lenguaje ANSI-C que permita interpretar los comentarios realizados en un código escrito en lenguaje C, y presentarlos convenientemente, de acuerdo a un formato determinado. De esta forma se podrá extraer en forma automática del código fuente C los comentarios de cada función y generar al instante la documentación relacionada al software que se está construyendo. 2) Alcance del T.P.:

Mediante el presente TP se busca que el Estudiante adquiera y aplique conocimientos sobre los siguientes temas: • Argumentos en Línea de Ordenes (CLA). • Makefile y proyectos modularizados. • Tipo de Dato Abstracto (TDA). • Estructura básica de un documento XML. • Estructura básica de un documento HTML. • Memoria dinámica. • Puntero a función. 3) Desarrollo del T.P.:

El aplicativo a desarrollar debe leer cada una de las líneas de un código fuente en lenguaje C, de modo de extraer aquellas que contengan comentarios de documentación (en adelante “DOCs”), para luego presentarlos a modo de resumen y en un formato determinado sobre un archivo de texto, descartando todas aquellas líneas que no sean de tipo DOC y que se encontraban contenidas en el archivo fuente original como parte de un comentario standard.

El formato del documento de salida a generar debe ser texto plano, HTML y XML. El programa ejecutable, denominado “doc7502.exe” (WinXX) ó “doc7502” (Unix), debe ser invocado de la

siguiente forma:

doc7502 <archivo fuente> <archivo salida> <formato>

(ver descripción de argumentos a continuación.) Los comandos en línea de órdenes que han de ser soportados por el aplicativo son:

Formato del reporte: Los comandos en línea de órdenes que han de ser soportados por el aplicativo pedido son: Comando Descripción Valor Tipo Obs. -fmt Formato del reporte a generar. plain String Generar archivo de reporte en formato texto

(ad-hoc). xml String Generar archivo de reporte en formato

XML. html String Generar archivo de reporte en formato

HTML (optativo). NOTA: La posición de los argumentos es fija en el orden indicado previamente, o variable (a elección).


2

Los comentarios DOC para el presente TP pueden ser clasificados en tres tipos: Title, Function y Footer(*), de acuerdo a lo que se desee documentar.

a) Title: Es un bloque único de comentarios que identifica a todo el archivo, en su conjunto, y debe ser mostrado al comienzo del documento resultante.

b) Function: Es un bloque de comentarios que identifica a una función y debe ser mostrado dentro del cuerpo del documento a generar, para cada función detectada dentro del código fuente C original. Si en él existen “n” funciones, se debe generar un conjunto de “n” DOCS, uno por cada función.

c) Footer(*): Es un bloque único de comentarios que debe ser colocado al final del documento, a modo de pie de página. (*) Optativo El procesamiento de los comentarios DOC debe realizarse de acuerdo a las siguientes: REGLAS DE PROCESAMIENTO: i) Cada comentario DOC comienza con la cadena de caracteres “/**”, y finaliza con la cadena de caracteres “*/”. Notar que como los comentarios en lenguaje C comienzan con “/*” y terminan con “*/”, los comentarios DOC son un subconjunto destacado dentro de los comentarios tradicionales C, y por lo tanto no serán interpretados por un compilador (son transparentes a él), a la vez que le dan una gran potencia de procesamiento. Si bien se dará casos detallados más adelante, un comentario típico DOC tendrá la siguiente estructura:

/** Esto es un comentario DOC */

ii) La secuencia /** no tiene por qué estar ubicada al comienzo de una línea (puede haber espacios a la izquierda). De manera similar, una secuencia */ no tiene por qué estar ubicada al comienzo de la línea de texto (por practicidad basta verificar si una línea contiene los símbolos /** y */ para apertura y cierre de un comentario DOC, respectivamente). iii) No se permite tener anidamientos de comentarios DOC, por lo que el siguiente contenido será erróneo:

/** Esto es el primer comentario /** y este es el segundo comentario */ */

iv) Si en una línea se abre un DOC dos o más veces, sólo se considerará la primer apertura. Ejemplo: /** /** /** comentario */ v) Si en una línea se cierra un DOC dos o más veces, sólo se considerará el primer cierre. Ejemplo: /** comentario */ */ */ vi) No se conoce de antemano la longitud de una línea de texto (por lo tanto hay que usar memoria dinámica para leer una línea del archivo fuente C). vii) No se conoce de antemano la cantidad de líneas de texto que conforman un DOC. viii) La primera línea de un DOC siempre contiene únicamente el tag de apertura de comentario (/**), y ninguna otra información adicional que deba ser considerada, si es que ésta está contenida en la misma línea del tag. ix) La última línea de un DOC siempre contiene únicamente el tag de cierre de comentario (*/), y ninguna otra información que deba ser considerada, si ésta está contenida en la misma línea del tag. x) Cada DOC contiene, después del tag de apertura, una secuencia de parámetros que permite identificar determinadas partes de los comentarios. Estos parámetros estarán bien formados y comienza con el símbolo @.


3

xi) El significado de cada parámetro puede ser consultado en el Diccionario que figura más adelante. xii) A continuación del tag de apertura de un DOC, en la segunda línea se encuentra un parámetro que identifica a cada uno de los tres tipos de comentarios que pueden presentarse. A saber:

/** @title ... */

Esto identifica a un comentario DOC que describe a un título. Por otra parte, el DOC

/** @function ... */

identifica a un comentario referido a una función. El DOC (optativo):

/** @footer ... */

identifica a un comentario DOC que será colocado en el documento final como pie de página. xiii) Toda información contenida en la misma línea de @title, @function o @footer, después de estos símbolos, será descartada. Ejemplo:

/** @function Esto ha de ser descartado ... */

xiv) El procesamiento de los DOCs es case-sensitive, por lo que @footer es distinto de @FOOTER y de @Footer (sólo es válido el primer caso). xv) Toda información concerniente a un parámetro estará contenida en la misma línea, sin importar su longitud. Ejemplo: /** @function @name main @return int @param void @description esta función es la principal del programa. */ xvi) No habrá renglones en blancos dentro de un DOC. xvii) Dentro de una línea de parámetros DOC, no está permitido el uso de las cadenas /** y */. xviii) A los efectos de este TP, todos los comentarios DOC monolínea serán ignorados por la aplicación.

4

xix) Este aplicativo sólo procesa comentarios, por lo que no se analiza la integridad ni el contenido del código fuente C original. Esto permite usar esta herramienta para documentar código escrito en otros lenguajes de programación (JavaScript, JScript, Stored Procedures, etc.) con sólo respetar la sintaxis de los comentarios. xx) Cada comentario DOC de tipo Title puede contener los siguientes elementos: @title @description xxi) Cada comentario DOC de tipo Function puede contener los siguientes elementos: @function @name @description @return @param [uno o varios ] xxii) Cada comentario DOC de tipo Footer puede contener los siguientes elementos: @footer @author xxiii) El orden de aparición de los parámetros de un DOC es: @title - @function - @footer. xxiv) Nunca un parámetro puede formar parte de un comentario monolínea. Ejemplo:

/** @title */

no está permitido. xxv) No se conoce de antemano la cantidad de parámetros (argumentos formales) que una función C puede contener, pero a los fines de este TP puede considerarse por simplicidad que esta cifra nunca superará los 50. xxvi) Todos los parámetros @param estarán uno a continuación del otro. Ejemplo: para la función de biblioteca strcpy(), el programador que desee documentar su código deberá escribir:

/** @function @name strcpy @param t: char * @param s: char * @return char * */

xxvii) Los parámetros (argumentos formales) de una función serán indicados con la siguiente sintaxis:

@param <nombre> : <tipo>

siendo el carácter delimitador “:”. El nombre del parámetro está dado por el <nombre>, y su tipo por <tipo>, sin importar lo complejo

que éste sea. Ejemplo: @param cliente : const struct tcliente *

xxviii) Si una función no recibe parámetros, debe indicarse con el parámetro void.

Ejemplo: (notar la ausencia del delimitador “:”) /** @function @name main @param void @return void

5

*/ Dicho de otra forma, si se encuentra el delimitador “:” dentro de un @param, la cadena comprendida entre los símbolos @param y “:” representa el nombre del parámetro. Lo que sigue a continuación del delimitador “:” es su tipo. Si no está presente el delimitador “:”, lo que sigue a @param es directamente su tipo (void). xxix) A los efectos de este TP, todos los comentarios DOC que no tengan un tag identificador válido (@title, @function o @footer) serán ignorados por la aplicación. Nota: Por cuestiones de simplicidad se han restringido los comentarios a tres clases (title, function y footer). Si se logra una buena parametrización de código, será mucho más fácil y prolijo extender en un futuro las funcionalidades de este aplicativo. Formatos de Salida: Debe presentarse el encabezado (Header, si está presente), luego el listado de funciones –ordenado alfabéticamente por nombre de la función), y por último el Footer (si está presente). Los formatos de salida contemplados son: a) Ad-hoc: Elegido libremente por el Desarrollador. b) HTML: Elegido libremente por el Desarrollador. En el Anexo se adjunta una propuesta. c) XML: El formato del documento de salida XML a generar es: <?xml version="1.0" ?> <doc> <title> <name>..........</name> <description>..........</description> </title> <function> <name>....</name> <description> .... </description> <return> .... </return> <param name="...."> .... </param> </function> ... <footer> <name>...</name> <author>...</author> </footer> </doc> 3) Restricciones: La realización de este programa está sujeta a las siguientes restricciones:

• Debe recurrirse a la utilización de Funciones mediante una adecuada parametrización. • El diccionario debe ser construido con memoria dinámica. • Debe construirse un Proyecto, utilizando makefile.

• Hay otras cuestiones que no han sido especificadas intencionalmente en este Requerimiento, para darle al Desarrollador la libertad de elegir implementaciones que, según su criterio, resulten más favorables en determinadas situaciones. Por lo tanto, se debe explicitar cada una de las decisiones adoptadas, y el o los fundamentos considerados para las mismas.


6

• Debe recurrirse al uso de punteros a funciones a fin de parametrizar la impresión de los reportes. • Debe recurrirse al uso del TDA Vector para almacenar los elementos de información correspondientes a un tag @function.

4) Entrega del Trabajo Práctico:

a) Deberá presentarse la correspondiente Documentación de desarrollo del TP impresa y encarpetada, siguiendo la numeración siguiente, incluyendo: 1) Carátula del TP. Incluir una dirección de correo electrónico de contacto. 2) Enunciado del TP. 3) Estructura lógica simplificada de los programas desarrollados (diagramas de flujo). 4) Estructura funcional de los programas desarrollados (Árbol de Funciones). 5) Explicación de cada una de las alternativas consideradas y las estrategias adoptadas. 6) Resultados de la ejecución (corridas) de los programas, captura de las pantallas, bajo condiciones normales e inesperadas de entrada. 7) Reseña sobre los problemas encontrados en el desarrollo de los programas y las soluciones implementadas para subsanarlos. 8) Conclusiones.

SI NO SE PRESENTA CADA UNO DE ESTOS ITEMS, SERA RECHAZADO EL TP.

NOTA: El Informe deberá ser redactado en correcto idioma castellano, con tipografía Times New Roman, Arial, o Verdana, de tamaño 11 para los párrafos, y 13 ó 14 para los títulos.

b) Deberán entregarse los fuentes (implementación y encabezados) de los programas desarrollados. NO entregar archivos de códigos objeto y/o ejecutables. c) Deberá entregarse el archivo makefile del proyecto para el compilador C GCC/DJGPP.

d) Deberán entregarse por correo electrónico a la casilla [email protected], todos los archivos fuentes y scripts necesarios para compilar el trabajo práctico, además del Informe en formato electrónico. Dicho correo deberá contener en su cuerpo el nombre, apellido y padrón de los integrantes del grupo. De no hacerse la entrega digital en tiempo y forma, el TP no será corregido. 5) Bibliografía:

Debe incluirse la referencia a toda bibliografía consultada para la realización del presente TP: libros, artículos, URLs, etc., citando: • Denominación completa del material (Título, Autores, Edición, Volumen, etc.). • Código ISBN del libro (opcional: código interbibliotecario). • URL del sitio consultado.


7

Anexo 1: Prototipo HTML: (el listado de funciones debe estar ordenado alfabéticamente por nombre de función) TDA GENERIC ARRAY Biblioteca para manejo de Arrays Genéricos. La totalidad de este código es ANSI-C compliant.

Función Array_T

Array_new ( void ) Constructor de una instancia del TDA Array. Devuelve un puntero a un Array_T si tuvo memoria suficiente como para generarlo, y NULL en caso contrario. El arreglo contendrá inicialmente MEMORY_CHOP elementos.

Función void Array_delete ( array Array_T )

Destructor de una instancia del TDA Array. Libera la memoria ocupada por array. Este destructor no libera la memoria ocupada por cada elementos del contenedor, solo elimina las referencias a ellos. Para liberar los elementos contenidos, propiamente, debe liberárselos individualmente uno por uno, pero no existente funciones de esta biblioteca para ello.

Función int Array_getLength ( array Array_T )

Función para obtener el número de elementos presentes en el array. Devuelve la cantidad de elementos, o -1 si el argumento real fue NULL.

Función void* Array_getData ( Array_T array , int index )

Obtiene una referencia al elemento ubicado en la posición "index" del array. Devuelve NULL si el argumento real fue NULL.

Función int Array_getIndexFrom ( Array_T array , string str )

Obtiene la posición del elemento del arreglo que coincide con la referencia str. Devuelve el valor entero de la posición si el elemento fue encontrado, y UNKNOWN en caso contrario. Si el argumento real fue NULL, se retorna UNKNOWN. Esta función solo es aplicable si el arreglo contiene referencias a strings.

Función Array_T

Array_add ( Array_T array , void* new_element ) Añade un elemento al final del array. Si no tiene espacio suficiente, se agranda el arreglo automáticamente. Retorna un array Array_T. No hay que liberar el array antiguo. Posteriormente se debe liberar la memoria asignada por esta función. Si no hay memoria suficiente se retorna NULL.

Función


8

void* Array_replace ( Array_T array , void* new_element ) Reemplaza el elemento contenido en la posición "index" del array, por el indicado a través de la referencia "new_element". Retorna una referencia al elemento reemplazado, para su eventual eliminación. Si el parámetro index contiene un valor fuera de rango, se retorna NULL.

Función Array_T

Array_insert ( Array_T array , int index , void* new_element ) Inserta un elemento referenciado por new_element en la posición index del array. El contenido del arreglo se reacomoda en forma automática. Se retorna el nuevo arreglo en caso satisfactorio y NULL en caso contrario. Si no hay memoria suficiente se retorna NULL, lo mismo sucede si index contiene un valor fuera de rango. No se debe liberar la memoria del arreglo antiguo. Si fuera necesario hacer crecer el arreglo, producto de la inserción, el tamaño del arreglo crecerá en MEMORY_CHOP elementos.

Función void* Array_remove ( Array_T array , int index )

Elimina la referencia ubicada en la posición dada por index. No se elimina el elemento apuntado por la referencia, sino la referencia en sí. Se devuelve la referencia al elemento eliminado del arreglo para su eventual destrucción. Luego de la extracción del elemento, el contenido del arreglo se acomoda automáticamente. Esta función NO libera memoria. Si la posición index está fuera de rango, no se realiza operació alguna.

Función int CompareIntegers ( void* pdato1 , void* pdato2 )

Compara dos números enteros accedidos mediante las referencias pdato1 y pdato2, y retorna la diferencia entre ambos. Precondición: las referencias no pueden ser NULL.

Función int CompareDoubles ( void* pdato1 , void* pdato2 )

Compara dos números double accedidos mediante las referencias pdato1 y pdato2, y retorna la diferencia entre ambos. Precondición: las referencias no pueden ser NULL.

Función int CompareChars ( void* pdato1 , void* pdato2 )

Compara dos caracteres accedidos mediante las referencias pdato1 y pdato2, y retorna la diferencia entre ambos. Precondición: las referencias no pueden ser NULL.

Función int CompareStrings ( void* pdato1 , void* pdato2 )

Compara dostrings accedidos mediante las referencias pdato1 y pdato2, y retorna la diferencia lexicográfica entre ambos. Precondición: las referencias no pueden ser NULL.


9

Función void Array_sort ( Array_T array , int (*)(void*,void*) funcion_comparacion )

Ordena el arreglo en orden ascendente, de acuerdo a la función de comparación pasada como parámetro.

Función string*

Array_toStringArray ( Array_T array ) Genera un arreglo de cadenas a partir del contenido del array genérico. Luego deberá liberarse la memoria solicitada por esta función. Si no hay memoria suficiente o si el arreglo genérico es NULL, se retorna NULL, y la referencia a un arreglo de cadenas en caso contrario.

Función int* Array_toIntegerArray ( Array_T array )

Genera un arreglo de enteros a partir del contenido del array genérico. Luego deberá liberarse la memoria solicitada por esta función. Si no hay memoria suficiente o si el arreglo genérico es NULL, se retorna NULL, y la referencia a un arreglo de cadenas en caso contrario.

Función double*

Array_toDoubleArray ( Array_T array ) Genera un arreglo de doubles a partir del contenido del array genérico. Luego deberá liberarse la memoria solicitada por esta función. Si no hay memoria suficiente o si el arreglo genérico es NULL, se retorna NULL, y la referencia a un arreglo de cadenas en caso contrario.

Función char* Array_toCharArray ( Array_T array )

Genera un arreglo de caracteres a partir del contenido del array genérico. Luego deberá liberarse la memoria solicitada por esta función. Si no hay memoria suficiente o si el arreglo genérico es NULL, se retorna NULL, y la referencia a un arreglo de cadenas en caso contrario.

Función void Array_showStringArray ( string[] array , int length )

Muestra un arreglo de cadenas, de longitud length

Función void Array_showCharArray ( char[] array , int length )

Muestra un arreglo de caracteres, de longitud length

Función void Array_showIntegerArray ( int[] array , int length )

Muestra un arreglo de enteros, de longitud length

Función


10

void Array_showDoubleArray ( double[] array , int length ) Muestra un arreglo de doubles, de longitud length

©Juan Pérez

11

Anexo 2: Prototipo HTML – Código Fuente <html> <head> <title>Documentación de archivo: generic_array.c</title> <style type="text/css"> .deprecated { font-family: courier; font-size: 13px; font-weight: bold; color: ff0000 } .version { font-size: 13px; color: c0c0c0 } .fecha { font-size: 13px; color: c0c0c0 } .ver { font-size: 13px; color: c0c0c0 } .autor { font-size: 13px; color: a0a0a0 } .copyright { font-size: 13px; color: a0a0a0 } .token { font-size: 15px; font-weight: bold; color: 6633ff } .definicion { font-size: 15px; font-weight: bold; color: cc3333 } .macro { font-size: 15px; font-weight: bold; color: cc3333 } .global { font-size: 15px; font-weight: bold; color: cc3333 } .tipo { font-size: 13px; color: 338833 } .parametro { font-size: 13px; font-weight: bold; color: 6633ff } .funcion { font-size: 13px; font-weight: bold; color: cc3333 } .expansion { font-size: 12px; font-weight: bold; color: 993333 } .comentario { font-family: courier; font-size: 10px; color: 000000 } .titulodefinicion { font-size: 15px; background-color: CCCCFF } .titulofuncion { font-size: 15px; background-color: CCCCFF } .header { font-size: 18px; font-weight: bold; color: 000000 } .footer { font-size: 18px; font-weight: bold; color: 000000 } .title { font-size: 25px; font-weight: bold; color: 000000 } .warning { font-size: 25px; font-weight: normal; color: FF0000 } </style>  TDA GENERIC ARRAY Descripción de la API implementada Biblioteca para manejo de Arrays Genéricos. La totalidad de este código es ANSI-C compliant.   <TABLE BORDER=1 CELLPADDING=3 CELLSPACING=0 WIDTH=100%> <TR class="titulofuncion"> <TD COLSPAN=2> Función </td> </tr> <tr bgcolor=ffffff> <TD ALIGN=left VALIGN=top WIDTH=8%> <code>Array_T</code> </td> <td align=left> <code> Array_new</code> ( <code>void</code> ) Constructor de una instancia del TDA Array. Devuelve un puntero a un Array_T si tuvo memoria suficiente como para generarlo, y NULL en caso contrario. El arreglo contendrá inicialmente MEMORY_CHOP elementos. </td> </tr> </table>

12

<TABLE BORDER=1 CELLPADDING=3 CELLSPACING=0 WIDTH=100%> <TR class="titulofuncion"> <TD COLSPAN=2> Función </td> </tr> <tr bgcolor=ffffff> <TD ALIGN=left VALIGN=top WIDTH=8%> <code>void</code> </td> <td align=left> <code> Array_delete</code> ( <code>array</code> <code>Array_T</code> ) Destructor de una instancia del TDA Array. Libera la memoria ocupada por array. Este destructor no libera la memoria ocupada por cada elementos del contenedor, solo elimina las referencias a ellos. Para liberar los elementos contenidos, propiamente, debe liberárselos individualmente uno por uno, pero no existente funciones de esta biblioteca para ello. </td> </tr> </table> <TABLE BORDER=1 CELLPADDING=3 CELLSPACING=0 WIDTH=100%> <TR class="titulofuncion"> <TD COLSPAN=2> Función </td> </tr> <tr bgcolor=ffffff> <TD ALIGN=left VALIGN=top WIDTH=8%> <code>int</code> </td> <td align=left> <code> Array_getLength</code> ( <code>array</code> <code>Array_T</code> ) Función para obtener el número de elementos presentes en el array. Devuelve la cantidad de elementos, o -1 si el argumento real fue NULL. </td> </tr> </table> <TABLE BORDER=1 CELLPADDING=3 CELLSPACING=0 WIDTH=100%> <TR class="titulofuncion"> <TD COLSPAN=2> Función </td> </tr> <tr bgcolor=ffffff>

13

<TD ALIGN=left VALIGN=top WIDTH=8%> <code>void*</code> </td> <td align=left> <code> Array_getData</code> ( <code>Array_T</code> <code>array</code> , <code>int</code> <code>index</code> ) Obtiene una referencia al elemento ubicado en la posición "index" del array. Devuelve NULL si el argumento real fue NULL. </td> </tr> </table> <TABLE BORDER=1 CELLPADDING=3 CELLSPACING=0 WIDTH=100%> <TR class="titulofuncion"> <TD COLSPAN=2> Función </td> </tr> <tr bgcolor=ffffff> <TD ALIGN=left VALIGN=top WIDTH=8%> <code>int</code> </td> <td align=left> <code> Array_getIndexFrom</code> ( <code>Array_T</code> <code>array</code> , <code>string</code> <code>str</code> ) Obtiene la posición del elemento del arreglo que coincide con la referencia str. Devuelve el valor entero de la posición si el elemento fue encontrado, y UNKNOWN en caso contrario. Si el argumento real fue NULL, se retorna UNKNOWN. Esta función solo es aplicable si el arreglo contiene referencias a strings. </td> </tr> </table> <TABLE BORDER=1 CELLPADDING=3 CELLSPACING=0 WIDTH=100%> <TR class="titulofuncion"> <TD COLSPAN=2> Función </td> </tr> <tr bgcolor=ffffff> <TD ALIGN=left VALIGN=top WIDTH=8%> <code>Array_T</code> </td> <td align=left>

14

<code> Array_add</code> ( <code>Array_T</code> <code>array</code> , <code>void*</code> <code>new_element</code> ) Añade un elemento al final del array. Si no tiene espacio suficiente, se agranda el arreglo automáticamente. Retorna un array Array_T. No hay que liberar el array antiguo. Posteriormente se debe liberar la memoria asignada por esta función. Si no hay memoria suficiente se retorna NULL. </td> </tr> </table> <TABLE BORDER=1 CELLPADDING=3 CELLSPACING=0 WIDTH=100%> <TR class="titulofuncion"> <TD COLSPAN=2> Función </td> </tr> <tr bgcolor=ffffff> <TD ALIGN=left VALIGN=top WIDTH=8%> <code>void*</code> </td> <td align=left> <code> Array_replace</code> ( <code>Array_T</code> <code>array</code> , <code>void*</code> <code>new_element</code> ) Reemplaza el elemento contenido en la posición "index" del array, por el indicado a través de la referencia "new_element". Retorna una referencia al elemento reemplazado, para su eventual eliminación. Si el parámetro index contiene un valor fuera de rango, se retorna NULL. </td> </tr> </table> <TABLE BORDER=1 CELLPADDING=3 CELLSPACING=0 WIDTH=100%> <TR class="titulofuncion"> <TD COLSPAN=2> Función </td> </tr> <tr bgcolor=ffffff> <TD ALIGN=left VALIGN=top WIDTH=8%> <code>Array_T</code> </td> <td align=left>

15

<code> Array_insert</code> ( <code>Array_T</code> <code>array</code> , <code>int</code> <code>index</code> , <code>void*</code> <code>new_element</code> ) Inserta un elemento referenciado por new_element en la posición index del array. El contenido del arreglo se reacomoda en forma automática. Se retorna el nuevo arreglo en caso satisfactorio y NULL en caso contrario. Si no hay memoria suficiente se retorna NULL, lo mismo sucede si index contiene un valor fuera de rango. No se debe liberar la memoria del arreglo antiguo. Si fuera necesario hacer crecer el arreglo, producto de la inserción, el tamaño del arreglo crecerá en MEMORY_CHOP elementos. </td> </tr> </table> <TABLE BORDER=1 CELLPADDING=3 CELLSPACING=0 WIDTH=100%> <TR class="titulofuncion"> <TD COLSPAN=2> Función </td> </tr> <tr bgcolor=ffffff> <TD ALIGN=left VALIGN=top WIDTH=8%> <code>void*</code> </td> <td align=left> <code> Array_remove</code> ( <code>Array_T</code> <code>array</code> , <code>int</code> <code>index</code> ) Elimina la referencia ubicada en la posición dada por index. No se elimina el elemento apuntado por la referencia, sino la referencia en sí. Se devuelve la referencia al elemento eliminado del arreglo para su eventual destrucción. Luego de la extracción del elemento, el contenido del arreglo se acomoda automáticamente. Esta función NO libera memoria. Si la posición index está fuera de rango, no se realiza operació alguna. </td> </tr> </table> <TABLE BORDER=1 CELLPADDING=3 CELLSPACING=0 WIDTH=100%>

16

<TR class="titulofuncion"> <TD COLSPAN=2> Función </td> </tr> <tr bgcolor=ffffff> <TD ALIGN=left VALIGN=top WIDTH=8%> <code>int</code> </td> <td align=left> <code> CompareIntegers</code> ( <code>void*</code> <code>pdato1</code> , <code>void*</code> <code>pdato2</code> ) Compara dos números enteros accedidos mediante las referencias pdato1 y pdato2, y retorna la diferencia entre ambos. Precondición: las referencias no pueden ser NULL. </td> </tr> </table> <TABLE BORDER=1 CELLPADDING=3 CELLSPACING=0 WIDTH=100%> <TR class="titulofuncion"> <TD COLSPAN=2> Función </td> </tr> <tr bgcolor=ffffff> <TD ALIGN=left VALIGN=top WIDTH=8%> <code>int</code> </td> <td align=left> <code> CompareDoubles</code> ( <code>void*</code> <code>pdato1</code> , <code>void*</code> <code>pdato2</code> ) Compara dos números double accedidos mediante las referencias pdato1 y pdato2, y retorna la diferencia entre ambos. Precondición: las referencias no pueden ser NULL. </td> </tr> </table> <TABLE BORDER=1 CELLPADDING=3 CELLSPACING=0 WIDTH=100%> <TR class="titulofuncion"> <TD COLSPAN=2> Función </td> </tr> <tr bgcolor=ffffff>

17

<TD ALIGN=left VALIGN=top WIDTH=8%> <code>int</code> </td> <td align=left> <code> CompareChars</code> ( <code>void*</code> <code>pdato1</code> , <code>void*</code> <code>pdato2</code> ) Compara dos caracteres accedidos mediante las referencias pdato1 y pdato2, y retorna la diferencia entre ambos. Precondición: las referencias no pueden ser NULL. </td> </tr> </table> <TABLE BORDER=1 CELLPADDING=3 CELLSPACING=0 WIDTH=100%> <TR class="titulofuncion"> <TD COLSPAN=2> Función </td> </tr> <tr bgcolor=ffffff> <TD ALIGN=left VALIGN=top WIDTH=8%> <code>int</code> </td> <td align=left> <code> CompareStrings</code> ( <code>void*</code> <code>pdato1</code> , <code>void*</code> <code>pdato2</code> ) Compara dostrings accedidos mediante las referencias pdato1 y pdato2, y retorna la diferencia lexicográfica entre ambos. Precondición: las referencias no pueden ser NULL. </td> </tr> </table> <TABLE BORDER=1 CELLPADDING=3 CELLSPACING=0 WIDTH=100%> <TR class="titulofuncion"> <TD COLSPAN=2> Función </td> </tr> <tr bgcolor=ffffff> <TD ALIGN=left VALIGN=top WIDTH=8%> <code>void</code> </td> <td align=left> <code> Array_sort</code> (

18

<code>Array_T</code> <code>array</code> , <code>int (*)(void*,void*)</code> <code>funcion_comparacion</code> ) Ordena el arreglo en orden ascendente, de acuerdo a la función de comparación pasada como parámetro. </td> </tr> </table> <TABLE BORDER=1 CELLPADDING=3 CELLSPACING=0 WIDTH=100%> <TR class="titulofuncion"> <TD COLSPAN=2> Función </td> </tr> <tr bgcolor=ffffff> <TD ALIGN=left VALIGN=top WIDTH=8%> <code>string*</code> </td> <td align=left> <code> Array_toStringArray</code> ( <code>Array_T</code> <code>array</code> ) Genera un arreglo de cadenas a partir del contenido del array genérico. Luego deberá liberarse la memoria solicitada por esta función. Si no hay memoria suficiente o si el arreglo genérico es NULL, se retorna NULL, y la referencia a un arreglo de cadenas en caso contrario. </td> </tr> </table> <TABLE BORDER=1 CELLPADDING=3 CELLSPACING=0 WIDTH=100%> <TR class="titulofuncion"> <TD COLSPAN=2> Función </td> </tr> <tr bgcolor=ffffff> <TD ALIGN=left VALIGN=top WIDTH=8%> <code>int*</code> </td> <td align=left> <code> Array_toIntegerArray</code> ( <code>Array_T</code> <code>array</code> ) Genera un arreglo de enteros a partir del contenido del array genérico. Luego deberá liberarse la memoria solicitada por esta función.

19

 Si no hay memoria suficiente o si el arreglo genérico es NULL, se retorna NULL, y la referencia a un arreglo de cadenas en caso contrario. </td> </tr> </table> <TABLE BORDER=1 CELLPADDING=3 CELLSPACING=0 WIDTH=100%> <TR class="titulofuncion"> <TD COLSPAN=2> Función </td> </tr> <tr bgcolor=ffffff> <TD ALIGN=left VALIGN=top WIDTH=8%> <code>double*</code> </td> <td align=left> <code> Array_toDoubleArray</code> ( <code>Array_T</code> <code>array</code> ) Genera un arreglo de doubles a partir del contenido del array genérico. Luego deberá liberarse la memoria solicitada por esta función. Si no hay memoria suficiente o si el arreglo genérico es NULL, se retorna NULL, y la referencia a un arreglo de cadenas en caso contrario. </td> </tr> </table> <TABLE BORDER=1 CELLPADDING=3 CELLSPACING=0 WIDTH=100%> <TR class="titulofuncion"> <TD COLSPAN=2> Función </td> </tr> <tr bgcolor=ffffff> <TD ALIGN=left VALIGN=top WIDTH=8%> <code>char*</code> </td> <td align=left> <code> Array_toCharArray</code> ( <code>Array_T</code> <code>array</code> ) Genera un arreglo de caracteres a partir del contenido del array genérico. Luego deberá liberarse la memoria solicitada por esta función. Si no hay memoria suficiente o si el arreglo genérico es NULL, se retorna NULL, y la referencia a un arreglo de cadenas en caso contrario. </td> </tr> </table>

20

 <TABLE BORDER=1 CELLPADDING=3 CELLSPACING=0 WIDTH=100%> <TR class="titulofuncion"> <TD COLSPAN=2> Función </td> </tr> <tr bgcolor=ffffff> <TD ALIGN=left VALIGN=top WIDTH=8%> <code>void</code> </td> <td align=left> <code> Array_showStringArray</code> ( <code>string[]</code> <code>array</code> , <code>int</code> <code>length</code> ) Muestra un arreglo de cadenas, de longitud length </td> </tr> </table> <TABLE BORDER=1 CELLPADDING=3 CELLSPACING=0 WIDTH=100%> <TR class="titulofuncion"> <TD COLSPAN=2> Función </td> </tr> <tr bgcolor=ffffff> <TD ALIGN=left VALIGN=top WIDTH=8%> <code>void</code> </td> <td align=left> <code> Array_showCharArray</code> ( <code>char[]</code> <code>array</code> , <code>int</code> <code>length</code> ) Muestra un arreglo de caracteres, de longitud length </td> </tr> </table> <TABLE BORDER=1 CELLPADDING=3 CELLSPACING=0 WIDTH=100%> <TR class="titulofuncion"> <TD COLSPAN=2> Función </td> </tr>

21

<tr bgcolor=ffffff> <TD ALIGN=left VALIGN=top WIDTH=8%> <code>void</code> </td> <td align=left> <code> Array_showIntegerArray</code> ( <code>int[]</code> <code>array</code> , <code>int</code> <code>length</code> ) Muestra un arreglo de enteros, de longitud length </td> </tr> </table> <TABLE BORDER=1 CELLPADDING=3 CELLSPACING=0 WIDTH=100%> <TR class="titulofuncion"> <TD COLSPAN=2> Función </td> </tr> <tr bgcolor=ffffff> <TD ALIGN=left VALIGN=top WIDTH=8%> <code>void</code> </td> <td align=left> <code> Array_showDoubleArray</code> ( <code>double[]</code> <code>array</code> , <code>int</code> <code>length</code> ) Muestra un arreglo de doubles, de longitud length </td> </tr> </table>  ©Juan Perez JP Versión 1.0.0  </body> </html> NOTA: Independientemente de cómo fueron aquí escritos los valores de los atributos en los tag HTML, la forma correcta es

22

siempre entre comillas dobles:

<a href=”http://www.hp.com” target=”_blank”>Un link</a> NOTA: En esta propuesta se muestra otros elementos DOC (como por ejemplo @fecha), los cuales no pertenecen a lo pedido en el presente TP; éstos se muestran son sólo a título ilustrativo.

trabajo practico nº 3 1q2010 -...

Documents