Código fuente de consulta de admisión universitaria
# incluir & ltstdlib.h & gt
# incluir & ltstring.h & gt
#definir verdadero 1
#Define false 0
#Define entero booleano
#Define MAXSIZE 5000
#define COUNT 20 //El número máximo que puede ser contado Número de archivos.
#Define LEN 20 //La longitud máxima del nombre del archivo
# include & ltstdio.h & gt
# include & ltstdlib.h & gt
p># include & ltconio.h & gt
voidcheckfile(char *nombre de archivo, int I);
void analy(char nombre de archivo[COUNT][ LEN], int n);
BOOLGetIn(int * n);
//Estructura de atributos de función
typedefstruct {
Carácter file name[20 ];//El nombre de cada función
int length; //La longitud de cada función
int pos//La posición de cada función
} Diversión;
//Declaración de la estructura estadística
typedefstruct {
int comment; //Número de comentarios puros
int comment; //Número de comentarios mixtos
int en blanco//Número de líneas en blanco
fun fun[MAXSIZE] //Propiedades de la función
int others//Función El número de códigos distintos del código del medio.
int funcount//El número de funciones
} Análisis
//Operación básica de cadena ADT
//Detectar si es Cadena vacía.
BOOLStrEmpty(carácter)
{
if(s[0]=='\0 ')
Devuelve VERDADERO
Return FALSE
}
//Comprueba si hay una subcadena con valor S2 en S1, si es así, devuelve la posición de la primera subcadena, si no, devuelve -1;
intFind(char *s1, char *s2)
{
int i = 0, j = 0;
if(strlen(s 1)& lt;strlen(s2))
return-1;
mientras (s1[i]!='\0')
{
if(s1[i] == s2[j])
{
i++;
j++;
if(s2[j]=='\0 ')
Devolver I-j;
Continuar;
}
i++;
j = 0;
}
retorno-1;
//Lee una línea de caracteres del archivo.
voidHaveLine(FILE *fp, char *s)
{
Y (!feof(fp))
{
* s = fgetc(FP);
If (*s=='\n'){ //Al final de una línea, significa que la línea ha sido ocupada.
* s = ' \ 0
Retorno;
}
s++;
}
* s = ' \ 0
}
//Ignora espacios y tabulaciones al principio de una línea de caracteres y devuelve un puntero de cadena truncado.
char*IgnoreB(char *s)
{
mientras (*s== ' ' || *s== ' ')
s++;
Return s;
}
//Determina si una línea de caracteres es un comentario.
intIsCom(char *s)
{
int posc, pos1, pos2
s = IgnorarB(s);
p>
posc = Find(s, "//");
If(posc == 0)//Esta línea solo tiene comentarios, sin código;
Devuelve 1;
if(posc == -1)
Devuelve 0;
pos1 = Buscar(s, "\");
pos2 =find(&s[pos1+1]," \"";
if(posc>pos1&&posc<pos2)
Devuelve 0 ;
return 2;
}
//Determinar si una línea de caracteres está vacía
Valor booleano en blanco (carácter)
p>{
s = IgnorarB(s);
if(*s== '\0 ')
Devuelve VERDADERO
Devuelve FALSO
}
intIsFunB(char *s)
{
int i, j, pos, pos 2;
//Hay un punto y coma, si while for no es el comienzo de la función
If (find(s),;)) != -1 ||Buscar (s, "si")! = -1 || Buscar(s, "para")! = -1 || Buscar(s, "mientras")!
//El que no tiene paréntesis no es el comienzo de la función
if((pos = Find(s, "()")== - 1)
Return. FALSO
s = IgnorarB(s);
i = Buscar(s, " ");
j = Buscar(s, " ");
If (i!=-1 & amp; & ampj!= -1)
i = i & gtj?j:i
else if ( i == -1)
I = j
si no(1 = =-1 & amp; & ampj == - 1)
Regresar FALSE
Si (posición i & gt)
Devuelve FALSE
s = & amps[I];
s = IgnorarB( s);
pos2 = Buscar(s, "(");
if(* s = = ' \ 0 ' | | * s = = '(' | | pos 2 & gt; posición)
Devolver FALSO
Devolver VERDADERO
}
voidprintR (int aver, int comc, int espacios en blanco)
{
//Resultados del análisis de salida basados en estándares de juicio a nivel de código.
int I;
char Grade[4][15] = {"A: Excelente", "B: Bueno", "C: Promedio", "D: Deficiente" }; //Definir cuatro segmentos de nivel.
//Determinar el nivel del código
if(aver & lt; = 15. &aver & gt=10)
I = 0;
else if((promedio & lt;= 20 & amp& ampaver & gt= 16)| | promedio & lt;= 9 & amp& ampaver & gt= 8)
I = 1;
else if((promedio & lt;= 7 & amp& ampaver & gt= 5)| | promedio & lt;= 24 & amp& ampaver & gt=21)
I = 2 ;
else if((aver & lt;5)| |(aver & gt;24))
I = 3;
printf(" Nivel %sEstilo de código de rutina\n ", nivel [I]);
//Determinar el nivel del comentario
if(comc & lt;= 25 & amp& ampcomc & gt = 15)
I = 0;
si no((comc & lt;=14. & ampcomc & gt= 10)| | comc & lt;= 30 & amp& ampcomc & gt=26)
I = 1;
si no((comc & lt;= 9 & amp& ampcomc & gt= 5)| | comc & lt;= 35 & amp& ampcomc>=31)
I = 2;
si no((comc & lt;5)| |(comc & gt;35))
I = 3;
printf("Calificar %s estilo de comentario de rutina\n ", Calificar[I]);
//Determinar el nivel de líneas en blanco
if(espacios en blanco & lt= 25 & amp& ampblanks & gt=15)
I = 0;
else if((espacios en blanco & lt;=14.&blanks& gt = 10) ||espacios en blanco & lt= 30 & amp& ampespacios en blanco & gt=26)
I = 1;
else if((espacios en blanco & lt;= 9 & amp& ampespacios en blanco & gt= 5) ||espacios en blanco& lt= 35 & amp& ampespacios en blanco & gt=31)
I = 2;
else if((espacios en blanco & lt;5)| (espacios en blanco & gt; 35))
I = 3;
printf(" Calificación % s estilo de espacio en blanco \ n ", Calificación[I]);
}
//Imprimir resultados de salida
Impresión no válida (análisis)
{
int sum = 0, funcode = 0;
int i,comc,blanks,aver,code
for(I = 0;I<安->funcountI++)//Encuentra el número total de códigos para la función.
funcode+= An-& gt;divertido[yo].
Longitud;
//Encuentra el número total de todos los códigos
sum+= An-& gt;En blanco;
sum+= An-& gt;Comentarios;
suma+= An-& gt；Comentarios;
suma+= An-& gt;Otros;
suma+= funcode;
If (sum == 0)//Evita que la suma de los divisores sea 0.
sum = 1;
if(An-& gt;Funcount == 0)//Evita que el divisor m sea 0.
aver = 0;
Otro
aver = funcode/An-& gt; ;Comentarios+An-& gt;Comentarios)* 100/suma;
espacios en blanco =((An-& gt;espacios en blanco)* 100)/suma;
código = 100- comc-blanks; //((funcode+An-& gt; Otros) * 100)/sum;
Printf("Los resultados del análisis del código fuente del programa son los siguientes\ n \ n "); /p>
Printf("Línea de código: %d\n ",suma-Un-> espacio en blanco-Un-> comentario-Un->comentario);
Printf(" Número de línea de comentario: %d\n ", An-& gt; comentario+An-& gt; comentario);
Printf("Número de líneas en blanco: %d\n ", An-& gt ; en blanco );
Printf("Comentario de código línea en blanco\n ");
printf(" * * * * * * * * * * * * * * * * * \ n ");
printf(" * * * * * * * * * * * * * * * * * \ n ");
printf(" %d% % % d%% %d%%\n ", code, comc, espacios en blanco);
printf("Este programa incluye %d funciones\n ", An-& gt; funcount);
printf("La longitud promedio del segmento de función es %d\n ",aver);
printf("\n");
//Juez basado en el nivel de código Resultados del análisis de salida estándar.
printR(aver, comc, espacios en blanco);
}
voidcheckfile(char *nombre de archivo, int i)
{
ARCHIVO * fp
mientras((fp = fopen(nombre de archivo, " r)) = = NULL)
{
Printf(" Lo sentimos. El archivo no existe %s\n ", nombre del archivo);
printf("\nVuelva a ingresar el archivo fuente %d:", I+1);
scanf ("%s ", nombre de archivo);
}
}
BOOLGetIn(int *n)//Los datos ingresados en la especificación solo pueden ser números .
{
char c;
* n = 0;
fflush(stdin);
c = getchar(); //Cuando ingresas una cadena de datos y presionas la tecla Intro, getchar() elimina el primer carácter de la cola de caché.
And (c!= '\n'){
if(c == ' 0 ' & & ampn == 0)
Printf (" Error de entrada. Vuelva a ingresar...\ n ");
if(c & gt; = ' 0 ' & amp& ampc & lt= '9')
* n =(* n)* 1c-48;
De lo contrario{
Printf("¡Error de entrada! Vuelva a ingresar...\ n ");
fflush(stdin); //Borrar (actualizar) el contenido en caché para evitar que getchar() acceda a él la próxima vez.
Devuelve FALSO
}
c = getchar();
}
Devuelve VERDADERO
}
análisis de vacío(nombre de archivo char[recuento][longitud], int n)
{
ARCHIVO * fp//Analizar archivo fuente Puntero
FILE * fpp//Puntero del archivo de registro
Análisis; //Estructura de estadísticas del programa
char s[200] //Archivo de almacenamiento para cada línea; .
BOOL start = 0, start = 0; //Establece el indicador de inicio de la función
int i, j = -1, pos = 0; function
p>
//c detecta la coincidencia de llaves en la función, comtype es el tipo de comentario.
int c=0, comtype
un espacio en blanco = 0;
un comentario = 0
un comentario. 0;
un . otros = 0;
un . funcount = 0;
Si ((fpp = fopen ("log.txt "," w "))= = null)//Crear un archivo de registro.
printf("No se puede abrir el archivo % s\n");
for(I = 0;i<n;I++)//Atravesar todos los archivos.
{
if((fp =fopen(nombre de archivo[i], " r)) = = NULL)
{
printf("No se puede abrir el archivo %s\n ", nombre de archivo [I]); //Nombre del archivo de salida [i]
getchar();
Salir (0) ;
}
pos = 0; //La ubicación de la función de inicialización en el nuevo archivo
Y (!feof(fp))
p>{
Havlin(fp, s); //Lee una línea de datos del archivo
pos++; .
p>//El número de códigos en el archivo de estadísticas de clasificación
comtype = IsCom(s);
if (comtype ==1)
{
un comentario++;
Continuar
}
if (comtype == 2)
un . comentarios++;
if (IsFunB(s))
{
fprintf(fpp, " %s\n ", s); // Extrae cada
j++; //j es el número de funciones - 1;
c = 0;
begin = TRUE
strcpy(An.fun[j].Filename, filename[I]); // ¿En qué archivo está grabada la función?
Diversión; diversión. pos = pos
Diversión; longitud = 1;
}
else if(IsBlank(s))
un espacio en blanco++;
else if(begin) {
Diversión; diversión. Longitud++;
If (find(s, " { "!=-1) //Compruebe si se ha ingresado el cuerpo de la función.
{
c++ ;
start = TRUE
}
if (find (s, "}")! = -1) // Comprueba si la función finaliza. >
c-;
if(c = = 0 & & inicio)
{
comenzar = FALSO
iniciar = FALSO
}
}
Otros
un otros++;
}
<. p>fclose(FP); //Cerrar el archivo de análisis}
fclose(fpp); //Cerrar el archivo de registro
an . j+1; //Guardar el número de funciones
Imprimir (&); //Imprimir los resultados del análisis
}
voidmain()
{
int n, I;
char c;
nombre de archivo char [recuento] [longitud]
Printf("\tSoftware de análisis de código fuente del programa Shenhang Electronic Information Engineering Research Institute-Wang Pan\n");
printf ("\t-\n");
mientras(1){
n = 0
Printf ("\t\t * * *; * * * *Análisis del programa* * * * * * * * \ n ");
Printf("Ingrese el número de archivos fuente que se analizarán:");
Y (! GetIn(&n)| | n <= 0){
Printf("Ingrese el número de archivos fuente que se analizarán:");
}
for(I = 0;i<n;i++)
{
printf("\nIngrese %d archivo fuente:", I+1);
scanf("%s ", nombre de archivo[I]);
checkfile(nombre de archivo[i], I);
fflush(stdin) ;
}
analy(nombre de archivo, n);
Printf ("\ t * * * * * *¿Quieres continuar? Usa esto software? y/N * * * * * * * * * * * \ N ");
c = getchar();
if(c == ' Y' | | c == 'y ')
Continuar;
Pausa;
}
}