Urgente: ¡¡¡Código fuente en C que determina los principios de compilación para tipos sintácticos !!!!!!
#incluye lt; string.hgt;
#incluye lt; * Definición de variable global*/
char inputString[10] /**//* Se utiliza para almacenar cadenas de entrada del usuario de hasta 20 caracteres*/
char stack[10] ; /**//* La estructura de la pila utilizada para el análisis de sintaxis*/
int base=0 /**//* La parte inferior del puntero de la pila*/
int; top =1; /**//* Puntero superior de la pila*/
char VT[4]={'a', 'd', 'b', 'e'}; // * Se usa para guardar 5 terminadores*/
char chanShengShi[10]; /**//* Se usa para guardar la ecuación generadora en la tabla de análisis de predicción M[A, a]*/
int firstCharIntex=0; /**//* Si a coincide con la fórmula generada, firstCharIntex aumenta en 1 cada vez */
////// firstCharIntex se usa para guardar al usuario. caracteres de entrada Subíndice del primer elemento de la cadena*/
/////////////////////// Declaración de función personalizada*//// // //p>
char pop(); /**//* Explota el elemento superior de la pila*/
int push(char); /* Empujar a la pila Agregar elementos, si tiene éxito, devolver 1, si la pila está llena, devolver 0 */
int search(char temp); conjunto de caracteres no terminal VT.Tem La variable temp existe y devuelve 1 si existe o 0 si la pila está llena.
temp, devuelve 1 si existe, 0 si no existe
int M(char A, char a); /**//* Si hay una tabla de análisis de predicción M[A, a] Generador,
Asigne el generador a la matriz de caracteres chanShengShi[10] y devuelva 1,
Si el generador no está definido en M[A, a], devuelva 0
Si no hay ningún generador definido en M[A, a], devuelve 0
Si no hay ningún generador definido en M[A, a], devuelve 0
int contador =1; /**//* Esta variable registra el número de pasos del análisis de sintaxis*/
init() /**//* Inicializa la matriz*/
printf(" wen fa:\n"); /**//* Sintaxis de salida como símbolo*/
printf("S -gt.aH \n");
printf(" H -gt; aMd | d \n");
printf("M -gt; Ab | \n"); gt; aM | e \n");
printf("\ninput string ,'#' es un signo de fin!!!(aaabd#) \n"); /**//* Mensaje el usuario debe ingresar los datos a probar String*/
scanf("s", inputString
push('#'); ('S');
p>
printf("\nContador----- Pila---------------Cadena de entrada \n") ;/**//* Declaración de solicitud de resultado de salida*/
while(1) /**///* El bucle while se utiliza para analizar la sintaxis del bloque de declaración de la función principal*/
{
printf(" ");
printf(" d", contador); /**//* Genera el número de pasos de análisis*/
printf(" "); /**//* Declaración de control de formato de salida*/
printStack() /**//* Muestra todos los elementos en la pila actual*/
X=pop(); /**//* Extraiga el elemento superior de la pila y asígnelo a la variable X*/
printinputString() /**//*; Genera la cadena de entrada del usuario actual*/
if( search(X )==0 )/**//* Encuentra el valor de la variable p> if(X == '#') /** //* La pila ha sido extraída, el análisis de sintaxis es correcto y se devuelve 1*/
{
printf("success \n " /**//); * Se ha completado el análisis gramatical, la cadena de entrada se ajusta a la definición gramatical*/
Devuelve 1;
}
else
else
p>
{
a = inputString[firstCharIntex];
if( M(X, a)==1) /** // Verifica la tabla de análisis de predicción M [Si existe una expresión de producción en A, a], si existe devuelve 1, si no existe devuelve 0**
{
para(
i =0; ilt; 10; i ) /**//* '$' es el terminador de la producción y el bucle for encuentra el subíndice del último elemento de la producción */
{
if( chanShengShi[i]=='$' ) break
}
i-- /**//* Porque '$' no se genera La fórmula es solo una fórmula de producción.
' no es una producción, es solo la marca final de una producción, por lo que resto su propio 1 */
while(igt;=0)
{
push( chanShengShi[i] );/**// Inserta la fórmula generada actualmente en la pila en orden inverso*/
i--; > }
else
{
printf(" error(1) !!!!\n"); /**//* Si análisis predictivo Si no hay una fórmula de generación en la tabla M [A, a], se generará un error de sintaxis */
Devuelve 0
}
}
}
}
else /**//* significa que X es el terminador*/
{
if( X= = inputString[firstCharIntex] ) /**//* If El primer elemento se eliminará y el siguiente elemento se convertirá en el nuevo elemento de título*/
}
else
{
printf(" error(2) !!!!\n");
Devuelve 0; }
}
}
contador
}
}
}
}
void init ()
{
int i
for(i=0; ilt; 10; i )
{
inputString[i]=NULL; /**//* Inicializa la matriz inputString[10] */
stack[i]=NULL /**//* Inicializar la pila stack[10 ] */
chanShengShi[i] = NULL /**//* Inicializar la matriz chanShengShi[10]*/
}
}
int M(char A, char a) /**//* La definición de sintaxis varía según la situación real y la la sintaxis es la sintaxis del ejemplo del libro de texto*/
{ /**//* Esta función simula el análisis predictivo de la matriz bidimensional en la tabla*/
if( A=='S'amp; a=='a' ) { strcpy(amp;chanShengShi[0], " aH$"); H'amp; a=='a' ) { strcpy(amp; chanShengShi[0], "aH$") ; ='a' ) { strcpy( chanShengShi[0], "aMd$"); retorno 1 }
if( A=='H'amp;amp; a=='d' ) { strcpy(amp;chanShengShi[0], "d$"); devolver 1; }
if( A=='M' devolver 1; }
if( A==
'M'amp;amp; a=='b' ) { strcpy(amp;chanShengShi[0], "$"); retorno }
if( A=='M'amp; amp; a=='e' ) { strcpy(amp; chanShengShi[0], "Ab$" return }
if( A=='A'amp; a; =='a' ) { strcpy(amp; chanShengShi[0], "aM$"); devuelve 1;
if( A=='A'amp; a=='A ' amp; a=='e' ) { strcpy(amp; chanShengShi[0], "aM$"); return }
if( A=='A' amp; amp; a; =='e' ) { strcpy(amp;chanShengShi[0], "e$"); devuelve 1;
else devuelve 0 /**/// Si el generador no está definido, luego devuelve 0**
}
char pop() /**/// Extrae el elemento superior de la pila y usa topChar para devolver **
{
char topChar
topChar=stack[--top]
return topChar;
int push (char ch)
{
if( topgt; 9 )
{
printf(" error: desbordamiento de pila"); /**// Desbordamiento de espacio de pila**
Devuelve 0;
}
else
{
stack[top]=ch; /**//* Asignar valor al espacio superior de la pila***
top
return 1;
}
}
int búsqueda(temperatura de carácter)
{
int i, bandera=0 ; /**/ /*flag variable Se utiliza como indicador, si se encuentra temp, el valor es 1; de lo contrario, el valor es 0**
for(i=0;ilt;4;i)
{
if( temp==VT[i] ) /**///*temp existe en el conjunto de terminadores**/
{
bandera=1;
romper
}
}
si(bandera==1) devuelve 1; /**//// flag= =1 significa que se ha encontrado el mismo elemento que temp*/
De lo contrario, se devuelve 0;
}
void printStack () /**//* Contenido de la pila de salida*/
{
int temp;
for(temp=1;templt; arriba;temp)
{
printf("c", pila[temp]
}
}
void printinputString() /**// * Salida de cadena de entrada del usuario*/
{<
/p>
int temp=firstCharIntex;
printf(" "); /**//* Esta oración controla el formato de salida*/
do {
printf("c", inputString[temp]);
temp
} while(inputString[temp-1]!= '#'); p >
printf(" \n");
}