UNIVERSIDAD NACIONAL MAYOR DE SAN MARCOS

“DECANA DE AMÉRICA”

FACULTAD DE INGENIERÍA DE SISTEMAS E

INFORMACIÓN
ESCUELA ACADEMICA DE INGENIERIA DE SISTEMAS

“LEXICO DE NUESTRO PROGRAMA - TAIMCode”

PROFESOR: RUIZ DE LA CRUZ MELO, CARLOS AUGUSTO

CURSO: LENGUAJES Y COMPILADORES

SECCIÓN: G.2

INTEGRANTES:

Alcántara Ramos, Frank David - 18200132

Inga Prado, Angelo Jesus - 18200157

Montañez Reynoso, Edith Nancy - 18200165

Tonconi Laura, Daniel William - 18200238

LIMA – PERÚ

2020 - “Año de la universalización de la salud”

I. EJEMPLO DE ANALIZADOR LEXICO

1. Léxico del lenguaje

Definición del léxico y los tokens asociados a cada uno de los componentes léxicos.

Palabras Reservadas:

Lexema Token
INICIO 100
FIN 101
nre 102
nent 103
car 104
ccar 105
bol 106
cte 107
out 108
in 109
si 110
sino 111
mientras 112
hacer 113
para 114
retornar 115
Publico 116
Privado 117
Protegido 118
Clase 119
main 120
obj 121
estx 122
true 123
false 124
Operadores:

Lexema Token
mol 125
and 126
or 127
public 128
> 200
< 201
! 202
!! 203
>= 204
<= 205
<> 206
-! 207
+ 208
- 209
* 210
/ 211
++ 212
-- 213
“ 214
‘ 215
{ 216
} 217
( 218
) 219
; 220
[ 221
] 222
, 223
<- 224
+> 225
. 226

Otras unidades léxicas:

Variable 510
Unidad Léxica Token Comentario 520
Identificadores 500
Literales numéricas 600 Reales 610
Literales de carácter 700 Enteros 620
Literales de cadena 800

2. Especificación formal del léxico

a)  Autómata

Autómata para el analizador léxico

 L/D

L 1 Identificador
. D Real
Entero D
3 4
D 2 D
,
ab
,
Comilla 6 7 Caracter
5
, simple
,
10 Punto ab
Cadena
. 8 9
11 Coma
, ab
\ Punto y coma
12
=
Mayor igual
14
> 13 Mayor
=
16 Menor igual
<
15 Menor
!
! Igual 18 Asignación
17

Multiplicación
* 19

División
/ 20 - 22 Disminución
Resta
- !
21 23 Negación
Suma +
+
24 25 Incremento
Comilla doble
”
0 “ 26 27 Comentario
ab

( 28 Paréntesis abierto

)
29 Paréntesis cerrado

{
30 Llave abierta

}
31 Llave cerrada

[
32 Corchete abierto

]
33 Corchete cerrado

and
34 Conjunción

or
35 Disyunción
b) Expresiones regulares

Identificador :   L (L/D)* (L representa a las letras => [a, b, …, z, A, B, …, Z] )

Entero           :  DD+ (D representa a los dígitos => [0, 1, 2, …, 9] )
Real : DD+.D+
Caracter : ‘ab’ (ab representa a un caracter de otro tipo)
Cadena : ‘ab+’
Comentario : “ab*”
Operadores :
 mayor      : > 
 mayor igual     :  >=
menor :<
menor igual : <=
comilla simple : ‘
comilla doble : “
coma :,
punto :.
igual :!
punto y coma : \
asignación : !!
llave abierta :{
llave cerrada :}
suma :+
resta :-
multiplicación : *
divisor :/
paréntesis abierto: (
paréntesis cerrado: )
corchete abierto: [
corchete cerrado:]
negación : -!
conjunción: and
disyunción: or
disminución : --
incremento : ++
c) Gramática Regular

q0Lq1 q1Lq1/Dq1+ q0L(L/D)*/

q0Dq2 q2Dq2 + .q3 + q0D(D*(.DD*)) /
q0’q5 q3Dq4 q0’(OC OC(OC)*)/
q0.q10 q4Dq4+ q0”(OC)*/
q0,q11 q5abq6+ ’q7+ q1(L/D)*/
q0\q12 q6’q7+ abq8 q2D*(.DD*) /
q0>q13 q7 q3DD*
q0<q15 q8abq8+ ’q9 q4D*/
q0!q17 q9 q5OC OC(OC)*/
q0*q19 q10 q6OC(OC)*
q0/q20 q11 q7
q0-q21 q12 q8(OC)*
q0+q24 q13=q14+ q9
q0”q26 q14 q10
q0(q28 q15=q16+ q11
q0)q29 q16 q12
q0{q30 q17!q18+ q13
q0}q31 q18 q14
q0[q32 q19 q15
q0]q33 q20 q16
q0and34 q21-q22+ !q23+ q17
q0orq35 q22 q18
q23 q19
q24+q25+ q20
q25 q21
q26ab26+ ”q27 + q22
q27 q23
q28 q24
q29 q25
q30 q26(ab)*/
q31 q27
q32 q28
q33 q29
q34 q30
q35 q31
q32
q33
q34
q35
3. Interface del analizador léxico

4.

Código del programa

4.1 Componentes a utilizar

COMPONENTE CONFIGURACIÓN UTILIDAD

jLabel1 Escribir en la propiedad text: Mensaje

TABLA QUE RECONOCE TODO
jLabel2 Escribir en la propiedad text: Mensaje
TABLA DE SÍMBOLOS
jButton1 ANALIZAR LEXICAMENTE Para comenzar el análisis
léxico
jTextArea1 Para ingreso de los
componentes léxicos a
analizar en varias líneas
jTextField2 Para indicar si hubo errores

jTable1 Modificar en la propiedad model las Para mostrar todo el

columnas, filas y nombre de los campos reconocimiento de los
componentes léxicos
jTable2 Modificar en la propiedad model las Muestra solo el contenido de
columnas, filas y nombre de los campos la tabla de símbolos

Terminando de abrir un proyecto en Netbeans el código muestra la siguiente información:

package LexicoTAIMCode;

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

/**
*
* @authores
* /*
* Creado el 17/11/2020
Alcántara Ramos, Frank David
Inga Prado, Angelo Jesus
Montañez Reynoso, Edith Nancy
Tonconi Laura, Daniel William
*/
public class Lexico extends [Link] {

A) ATRIBUTOS A CONSIDERAR EN LA CLASE

//PALABRAS RESERVADAS DE NUESTRO LENGUAJE
String PALABRA[] = {"INICIO","FIN","nre","nent","car","ccar","bol","cte","out",
"in","si","sino","mientras",
"hacer","para","retornar","Publico","Privado","Protegido","Clase","main",
"obj","estx","true","false","mol","and","or"};

int ind;
String car;
String buffer;
String lineaerror = "";
List<String[]> ARRAYTOKENS = new ArrayList<String[]>();
List<String> identificadores = new ArrayList<String>();

B) FUNCIÓN QUE RETORNA 500 SI ES UN IDENTIFICADOR O EL VALOR DE UNA

PALABRA RESERVADA QUE VA DESDE 100 HASTA 124; 125, 126 Y 127 SON
TOKENS DE UNOS OPERADORES QUE DADO SU FORMA SE LE CONSIDERA EN
EL VECTOR DE PALABRAS

int BUSCAR(String x) {
for (int k = 0; k < 28; k++) {
if ([Link](PALABRA[k])) {
return 100 + k;
}
}
return 500;
}
 C) MÉTODO QUE MUESTRA TODOS LOS DATOS RETORNADOS EN LA TABLA 1
void MOSTRARTABLATODO(int r) {
String a,b,c;
for (int i = 0; i < r; i++) {
a=(String) [Link](i, 0);
b=(String) [Link](i, 1);
c=(String) [Link](i, 2);
[Link](new String[]{a,b,c});
}
}
D) MÉTODO QUE MUESTRA TODOS LOS DATOS EN LA TABLA DE SÍMBOLOS
(TABLA 2)
void MOSTRARTABLASIMBOLOS(){
removerDuplicados(identificadores);
for (int i = 0; i < [Link](); i++) {
[Link]("500", i, 0);
[Link]("Identificador", i, 1);
[Link]([Link](i), i, 2);
}
}

E) MÉTODO QUE NO PERMITE QUE EN LA TABLA DE SÍMBOLOS SE REPITAN LOS

IDENTIFICADORES.
void removerDuplicados(List l) {
Object last = null;
[Link](l);
Iterator i = [Link]();
while ([Link]()) {
Object o = [Link]();
if ([Link](last)) {
[Link]();
} else {
last = o;
}
}
}

F) FUNCIÓN QUE IMPLEMENTA EL ANALIZADOR LÉXICO

int SCANER() {
buffer = "";
Character c;
int i = 0, e = 0;
char a;
for (;;) {
a = [Link](ind);//muestra el indice
if (a == '#' && i == 0) {
return 0;
} else if (a == '#') {
switch (e) {
//RETORNAR LOS TOKENS DE LOS CASOS TERMINALES
case 1:
return BUSCAR(buffer); // identificador o palabra reservada
case 2:
return 620; //entero
case 3:
buffer = [Link](0, [Link]() - 1);
ind++;
return 620;
case 4:
return 610; //real
case 5:
return 215; //comilla simple
case 6:
buffer = [Link](0, 1);
ind = 1;
return 215;
case 7:
return 700;//caracter
case 8:
buffer = [Link](0, 1);
ind = 1;
return 215;
case 9:
return 800;//cadena
case 10:
return 211; //division
case 11:
return 223; //coma
case 12:
return 202; //igual
case 13:
return 203; //asignacion
case 14:
return 200;//mayor
case 15:
return 204; //mayor igual
case 16:
return 220; // \ limitador
case 17:
return 201;//menor
case 18:
return 205; //menor igual
case 19:
return 206;//diferente
case 20:
return 224;// <-
case 21:
 return 216;//llave abierto
case 22:
return 217;//llave cerrado
case 23:
return 221;// corch abierto[
case 24:
return 222;//corch cerrado
case 25:
return 210;// multiplicacion
case 26:
return 218; // paren abierto
case 27:
return 219; // paren cerrado
case 28:
buffer = [Link](0, 1);
ind = 1;
return 214;//comilla doble
case 29:
return 520;//comentario
case 30:
return 208;//suma
case 31:
return 212;//incremento
case 32:
return 225;//+>
case 33:
return 209;//resta
case 34:
return 207;//negacion
case 35:
return 213;//disminucion
case 36:
return 226;//punto
}
} else {

//TODOS LOS ESTADOS POSIBLES

buffer = [Link]();//NO considera los espacios en blanco del principio y fin
switch (e) {
case 0:
buffer = buffer + a;
if ([Link](a)) {
e = 1;
i++;
} else if ([Link](a)) {
e = 2;
i++;
} else if ([Link](a) == false) {
switch (a) {
case '\'':
e=5;
i++;
break;
case '/':
e=10;
i++;
break;
case ',':
e=11;
i++;
break;
case '!':
e=12;
i++;
break;
case '>':
e=14;
i++;
break;
case '\\':
e=16;
i++;
break;
case '<':
e=17;
i++;
break;
case '{':
e=21;
i++;
break;
case '}':
e=22;
i++;
break;
case '[':
e=23;
i++;
break;
case ']':
e=24;
i++;
break;
case '*':
e=25;
i++;
break;
case '(':
 e=26;
i++;
break;
case ')':
e=27;
i++;
break;
case '\"':
e=28;
i++;
break;
case '+':
e=30;
i++;
break;
case '-':
e=33;
i++;
break;
case '.':
e=36;
i++;
break;
default:
lineaerror = [Link](a);
return 911;
}
} else {
e = 0;
}
break;
case 1:
if (([Link](a)) || ([Link](a))) {
buffer = buffer + a;
e = 1;
} else {
return BUSCAR(buffer);
} // identificador o reservada
i++;
break;
case 2:
if ([Link](a)) {
buffer = buffer + a;
e = 2;
} else {
if (a == '.') {
buffer = buffer + a;
e = 3;
} else {
 return 620;
}
} //entero
i++;
break;
case 3:
if ([Link](a)) {
buffer = buffer + a;
e = 4;
} else {
buffer = [Link](0, [Link]() - 1);
ind++;
return 620;
}
i++;
break;
case 4:
if ([Link](a)) {
buffer = buffer + a;
e = 4;
} else {
return 610;
} //real
i++;
break;
case 5:
if (a == '\'') {
buffer = buffer + a;
e = 7;
} else {
buffer = buffer + a;
e = 6;/*return 264;*/
}
i++;
break;
case 6:
if (a == '\'') {
buffer = buffer + a;
e = 7;
} else {
buffer = buffer + a;
e = 8;
}
i++;
break;
case 7:
return 700;//caracter
case 8:
if (a == '\'') {
 buffer = buffer + a;
e = 9;
} else {
buffer = buffer + a;
e = 8;
}
i++;
break;
case 9:
return 800;//cadena
case 10:
return 211;//division
case 11:
return 223;//coma
case 12:
if (a =='!'){
buffer = buffer + a;
e=13;
}else{
return 202; // !
}
i++;
break;
case 13:
return 203; // !!
case 14: // >
if (a == '='){
buffer = buffer + a;
e = 15;
}else{
return 200; //>
}
i++;
break;
case 15:
return 204; // >=
case 16:
return 220; // \
case 17:// <
if (a == '='){
buffer = buffer + a;
e = 18;
}else{
if(a == '>'){
buffer = buffer + a;
e = 19;
}else{
if(a == '-'){
buffer = buffer + a;
 e = 20;
}else{
return 201;
}
}
}
i++;
break;
case 18:
return 205;//<=
case 19:
return 206;//<>
case 20:
return 224;//<-
case 21:
return 216; // {
case 22:
return 217;// }
case 23:
return 221;// [
case 24:
return 222;// ]
case 25:
return 210; // *
case 26:
return 218; // (
case 27:
return 219; // )
case 28:
if (a == '\"') {
buffer = buffer + a;
e = 29;
} else {
buffer = buffer + a;
e = 28;/*return 263;*/
}
i++;
break;
case 29:
return 520;
case 30://+
if (a == '+'){
buffer = buffer + a;
e=31;
}else{
if(a == '>'){
buffer = buffer + a;
e=32;
}else{
 return 208; // +
}
}
i++;
break;
case 31:
return 212; //++
case 32:
return 225; //+>
case 33: // -
if (a == '!'){
buffer = buffer + a;
e = 34;
}else{
if(a == '-'){
buffer = buffer + a;
e = 35;
}else{
return 209; // -
}
}
i++;
break;
case 34:
return 207; //-!
case 35:
return 213;// --
case 36:
return 226;// .

} // fin del switch

ind++;

} // fin del if
} // fin del for
} // fin de la funcion scanner

/**
* Creates new form NewJFrame
*/
public Lexico() {
ind = 0;
initComponents();
[Link](null);
}

void AsignacionTOKENS(String palabra) {

int r = 0, i = 0;
 int t;
boolean salir = true;
car = palabra + '#';
//ESTABLECER LOS VALORES EN PANTALLA
do {
t = SCANER();
switch (t) {
case 0:
[Link]("Termino el programa ");
salir = false;
break;
case 100:
[Link]("100", r, 0); // valor, fila, columna
[Link]("[Link]", r, 1);
[Link](buffer, r, 2);
r++;
break;
case 101:
[Link]("101", r, 0);
[Link]("[Link]", r, 1);
[Link](buffer, r, 2);
r++;
break;
case 102:
[Link]("102", r, 0);
[Link]("[Link]", r, 1);
[Link](buffer, r, 2);
r++;
break;
case 103:
[Link]("103", r, 0);
[Link]("[Link]", r, 1);
[Link](buffer, r, 2);
r++;
break;
case 104:
[Link]("104", r, 0);
[Link]("[Link]", r, 1);
[Link](buffer, r, 2);
r++;
break;
case 105:
[Link]("105", r, 0);
[Link]("[Link]", r, 1);
[Link](buffer, r, 2);
r++;
break;
case 106:
[Link]("106", r, 0);
 [Link]("[Link]", r, 1);
[Link](buffer, r, 2);
r++;
break;
case 107:
[Link]("107", r, 0);
[Link]("[Link]", r, 1);
[Link](buffer, r, 2);
r++;
break;
case 108:
[Link]("108", r, 0);
[Link]("[Link]", r, 1);
[Link](buffer, r, 2);
r++;
break;
case 109:
[Link]("109", r, 0);
[Link]("[Link]", r, 1);
[Link](buffer, r, 2);
r++;
break;
case 110:
[Link]("110", r, 0);
[Link]("[Link]", r, 1);
[Link](buffer, r, 2);
r++;
break;
case 111:
[Link]("111", r, 0);
[Link]("[Link]", r, 1);
[Link](buffer, r, 2);
r++;
break;
case 112:
[Link]("112", r, 0);
[Link]("[Link]", r, 1);
[Link](buffer, r, 2);
r++;
break;
case 113:
[Link]("113", r, 0);
[Link]("[Link]", r, 1);
[Link](buffer, r, 2);
r++;
break;
case 114:
[Link]("114", r, 0);
[Link]("[Link]", r, 1);
 [Link](buffer, r, 2);
r++;
break;
case 115:
[Link]("115", r, 0);
[Link]("[Link]", r, 1);
[Link](buffer, r, 2);
r++;
break;
case 116:
[Link]("116", r, 0);
[Link]("[Link]", r, 1);
[Link](buffer, r, 2);
r++;
break;
case 117:
[Link]("117", r, 0);
[Link]("[Link]", r, 1);
[Link](buffer, r, 2);
r++;
break;
case 118:
[Link]("118", r, 0);
[Link]("[Link]", r, 1);
[Link](buffer, r, 2);
r++;
break;
case 119:
[Link]("119", r, 0);
[Link]("[Link]", r, 1);
[Link](buffer, r, 2);
r++;
break;
case 120:
[Link]("120", r, 0);
[Link]("[Link]", r, 1);
[Link](buffer, r, 2);
r++;
break;
case 121:
[Link]("121", r, 0);
[Link]("[Link]", r, 1);
[Link](buffer, r, 2);
r++;
break;
case 122:
[Link]("122", r, 0);
[Link]("[Link]", r, 1);
[Link](buffer, r, 2);
 r++;
break;

case 123:
[Link]("123", r, 0);
[Link]("[Link]", r, 1);
[Link](buffer, r, 2);
r++;
break;
case 124:
[Link]("124", r, 0);
[Link]("[Link]", r, 1);
[Link](buffer, r, 2);
r++;
break;

case 125:
[Link]("125", r, 0);
[Link]("Ope. Aritmetico", r, 1);
[Link](buffer, r, 2);
r++;
break;
case 126:
[Link]("126", r, 0);
[Link]("Ope. Logico", r, 1);
[Link](buffer, r, 2);
r++;
break;
case 127:
[Link]("127", r, 0);
[Link]("Ope. Logico", r, 1);
[Link](buffer, r, 2);
r++;
break;
case 200:
[Link]("200", r, 0);
[Link]("Ope. Relacional", r, 1);
[Link](buffer, r, 2);
r++;//>
break;
case 201:
[Link]("201", r, 0);
[Link]("Ope. Relacional", r, 1);
[Link](buffer, r, 2);
r++;//<
break;
case 202:
[Link]("202", r, 0);
[Link]("Ope. Relacional", r, 1);
 [Link](buffer, r, 2);
r++;//!
break;
case 203:
[Link]("203", r, 0);
[Link]("Ope. Asignacion", r, 1);
[Link](buffer, r, 2);
r++;//!!
break;
case 204:
[Link]("204", r, 0);
[Link]("Ope. Relacional", r, 1);
[Link](buffer, r, 2);
r++;//>=
break;
case 205:
[Link]("205", r, 0);
[Link]("Ope. Relacional", r, 1);
[Link](buffer, r, 2);
r++;//<=
break;
case 206:
[Link]("206", r, 0);
[Link]("Ope. Relacional", r, 1);
[Link](buffer, r, 2);
r++;//<>
break;
case 207:
[Link]("207", r, 0);
[Link]("Ope. Logico", r, 1);
[Link](buffer, r, 2);
r++;
break;
case 208:
[Link]("208", r, 0);
[Link]("Ope. Aritmetico", r, 1);
[Link](buffer, r, 2);
r++;//+
break;
case 209:
[Link]("209", r, 0);
[Link]("Ope. Aritmetico", r, 1);
[Link](buffer, r, 2);
r++;//-
break;
case 210:
[Link]("210", r, 0);
[Link]("Ope. Aritmetico", r, 1);
[Link](buffer, r, 2);
 r++;//*
break;
case 211:
[Link]("211", r, 0);
[Link]("Ope. Aritmetico", r, 1);
[Link](buffer, r, 2);
r++;// /
break;
case 212:
[Link]("212", r, 0);
[Link]("Ope. Aritmetico", r, 1);
[Link](buffer, r, 2);
r++;//++
break;
case 213:
[Link]("213", r, 0);
[Link]("Ope. Aritmetico", r, 1);
[Link](buffer, r, 2);
r++;//--
break;
case 214:
[Link]("214", r, 0);
[Link]("Ope. Delimitador", r, 1);
[Link](buffer, r, 2);
r++;//""
break;
case 215:
[Link]("215", r, 0);
[Link]("Ope. Delimitador", r, 1);
[Link](buffer, r, 2);
r++;//' '
break;
case 216:
[Link]("216", r, 0);
[Link]("Ope. Delimitador", r, 1);
[Link](buffer, r, 2);
r++;//{ llav
break;
case 217:
[Link]("217", r, 0);
[Link]("Ope. Delimitador", r, 1);
[Link](buffer, r, 2);
r++;//}
break;
case 218:
[Link]("218", r, 0);
[Link]("Ope. Delimitador", r, 1);
[Link](buffer, r, 2);
r++;// ( paren
 break;
case 219:
[Link]("219", r, 0);
[Link]("Ope. Delimitador", r, 1);
[Link](buffer, r, 2);
r++;// )
break;
case 220:
[Link]("220", r, 0);
[Link]("Ope. Delimitador", r, 1);
[Link](buffer, r, 2);
r++;// \
break;
case 221:
[Link]("221", r, 0);
[Link]("Ope. Delimitador", r, 1);
[Link](buffer, r, 2);
r++;// [ corch
break;
case 222:
[Link]("222", r, 0);
[Link]("Ope. Delimitador", r, 1);
[Link](buffer, r, 2);
r++;// ]
break;
case 223:
[Link]("223", r, 0);
[Link]("Ope. Delimitador", r, 1);
[Link](buffer, r, 2);
r++;//,
break;
case 224:
[Link]("224", r, 0);
[Link]("Ope. Delimitador", r, 1);
[Link](buffer, r, 2);
r++;//<-
break;
case 225:
[Link]("225", r, 0);
[Link]("Ope. Delimitador", r, 1);
[Link](buffer, r, 2);
r++;//>-
break;
case 226:
[Link]("226", r, 0);
[Link]("Ope. Delimitador", r, 1);
[Link](buffer, r, 2);
r++;//.
break;
case 500:

[Link]("500", r, 0);
[Link]("Identificador", r, 1);
[Link](buffer, r, 2);
r++;
[Link](buffer);
;
break;
case 510:
[Link]("510", r, 0);
[Link]("Variable", r, 1);
[Link](buffer, r, 2);
r++;
break;
case 520:
[Link]("520", r, 0);
[Link]("Comentario", r, 1);
[Link](buffer, r, 2);
r++;
break;
case 600:
[Link]("600", r, 0);
[Link]("Literal numerica", r, 1);
[Link](buffer, r, 2);
r++;
break;
case 610:
[Link]("610", r, 0);
[Link]("Num. Real", r, 1);
[Link](buffer, r, 2);
r++;
break;
case 620:
[Link]("620", r, 0);
[Link]("Num. Entero", r, 1);
[Link](buffer, r, 2);
r++;
break;
case 700:
[Link]("700", r, 0);
[Link]("literal caracter", r, 1);
[Link](buffer, r, 2);
r++;
break;
case 800:
[Link]("800", r, 0);
[Link]("literal de cadena", r, 1);
[Link](buffer, r, 2);
 r++;
break;
//DETALLA EL ERROR POR SI NO RECONOCE ALGÚN SÍMBOLO QUE NO SE USA EN NUESTRO
LENGUAJE
default:
[Link](" finalizo por error ");
salir = false;
}
} while (salir);
[Link](r);
MOSTRARTABLATODO(r);
MOSTRARTABLASIMBOLOS();
}

G) ASOCIAR AL BOTÓN BUTTON1 UN EVENTO JBUTTON1MOUSECLICKED Y

COLOCAR EL SIGUIENDE CÓDIGO

private void jButton1MouseClicked([Link] evt) {

// TODO add your handling code here:
String cadenas;
cadenas = "";//Todo el JTextArea
//CONCATENACIÓN DEL JTEXTAREA EN UN SOLO STRING
//Concatena todo el texto en un solo string
int lines = [Link]();
try {
for (int i = 0; i < lines; i++) {
int start = [Link](i);
int end = [Link](i);
cadenas = [Link](" ");
cadenas = [Link]([Link](start, end - start)).trim(); //el trim quita
los espacios de adelante y atras

}
} catch (BadLocationException e) {
[Link]("Error al concantenar");
}

AsignacionTOKENS(cadenas);
}

private void jTextField2ActionPerformed([Link] evt) {

/**
* @param args the command line arguments
*/
public static void main(String args[]) {
[Link](new Runnable() {
 @Override
public void run() {
Lexico nj1 = new Lexico();
[Link](true);

}
});
}

// Variables declaration - do not modify

private [Link] jButton1;
private [Link] jLabel1;
private [Link] jLabel2;
private [Link] jScrollPane1;
private [Link] jScrollPane2;
private [Link] jScrollPane3;
private [Link] jTable1;
private [Link] jTable2;
private [Link] jTextArea1;
private [Link] jTextField2;
private [Link] scrollPane1;
// End of variables declaration

}
ALGUNOS EJEMPLOS DE NUESTRO PROGRAMA

1)

Publico Promedio(nre n1, nre n2, nre n3){

nre prom !! 0.0\
prom !! (n1+n2+n3)/3\
out<-'El promedio es'+prom\
}

2)
Publico main(){
nre prom\
obj Alumno alum('Alejandro','46564721',15,16,14)\
prom !! [Link](15,16,14)\
"Obtiene el promedio"\
out<-'El alumno con codigo 46564721 tiene como
promedio:'+prom\
}
3)
si (promedio >= 11) and (promedio <= 20) {
out <- 'aprobo' \
}
sino {
out <- 'desaprobo'\
}