void lista_inicializadores() {
constante();
while (sbol->codigo == CCOMA) {
scanner();
constante();
}
}
void declarador_init() {
switch (sbol->codigo) {
case CASIGNAC: {
scanner();
constante();
break;
}
case CCOR_ABR: {
inf_id->desc.part_var.arr.ptero_tipo_base = inf_id->ptr_tipo; //si es un arreglo paso el tipo al tipo base
inf_id->ptr_tipo = en_tabla("TIPOARREGLO"); // y el tipo es ahora TIPOARREGLO
scanner();
if (sbol->codigo == CCONS_ENT) {
constante();
}
/** /
else
error_handler(41); // la cantidad de elementos debe estar especificada como constante entera
/**/
if (sbol->codigo == CCOR_CIE) {
scanner();
} else {
error_handler(21); // falta ]
}
if (sbol->codigo == CASIGNAC) {
scanner();
if (sbol->codigo == CLLA_ABR) {
scanner();
} else {
error_handler(23); // falta llave que abre
}
lista_inicializadores();
if (sbol->codigo == CLLA_CIE) {
scanner();
} else {
error_handler(24); // falta llave que cierra
}
}
break;
}
}
}
void factor() {
int clase_rerere_loca;
switch (sbol->codigo) {
case CIDENT:
if(en_tabla(sbol->lexema) != NIL) { /*&*/
clase_rerere_loca = Clase_Ident(sbol->lexema);
switch (clase_rerere_loca) {
case CLASPAR:
case CLASVAR:
variable();
break;
case CLASFUNC:
llamada_funcion();
break;
default:
error_handler(8);// palabra reservada
}
} else {
// no esta en la tabla
error_handler(33); // identificador no declarado
inf_id->ptr_tipo = en_tabla("TIPOERROR");
variable();
}
break;
case CCONS_ENT:
case CCONS_FLO:
case CCONS_CAR:
constante();
break;
case CCONS_STR:
scanner();
break;
case CPAR_ABR: {
scanner();
expresion();
if (sbol->codigo == CPAR_CIE) {
scanner();
} else {
error_handler(20); // falta )
}
break;
}
case CNEG: {
scanner();
expresion();
break;
}
default:
error_handler(31); // error de factor
}
}
int main()
{
// read the image
cv::Mat image= cv::imread(IMAGE_FOLDER "/boldt.jpg");
if (!image.data)
return 0;
// show original image
cv::namedWindow("Original image");
cv::imshow("Original image",image);
// convert into HSV space
cv::Mat hsv;
cv::cvtColor(image, hsv, CV_BGR2HSV);
// split the 3 channels into 3 images
std::vector<cv::Mat> channels;
cv::split(hsv,channels);
// channels[0] is the Hue
// channels[1] is the Saturation
// channels[2] is the Value
// display value
cv::namedWindow("Value");
cv::imshow("Value",channels[2]);
// display saturation
cv::namedWindow("Saturation");
cv::imshow("Saturation",channels[1]);
// display hue
cv::namedWindow("Hue");
cv::imshow("Hue",channels[0]);
// image with fixed value
cv::Mat newImage;
cv::Mat tmp(channels[2].clone());
// Value channel will be 255 for all pixels
channels[2]= 255;
// merge back the channels
cv::merge(channels,hsv);
// re-convert to BGR
cv::cvtColor(hsv,newImage,CV_HSV2BGR);
cv::namedWindow("Fixed Value Image");
cv::imshow("Fixed Value Image",newImage);
// image with fixed saturation
channels[1]= 255;
channels[2]= tmp;
cv::merge(channels,hsv);
cv::cvtColor(hsv,newImage,CV_HSV2BGR);
cv::namedWindow("Fixed saturation");
cv::imshow("Fixed saturation",newImage);
// image with fixed value and fixed saturation
channels[1]= 255;
channels[2]= 255;
cv::merge(channels,hsv);
cv::cvtColor(hsv,newImage,CV_HSV2BGR);
cv::namedWindow("Fixed saturation/value");
cv::imshow("Fixed saturation/value",newImage);
// Testing skin detection
// read the image
image= cv::imread(IMAGE_FOLDER "/girl.jpg");
if (!image.data)
return 0;
// show original image
cv::namedWindow("Original image");
cv::imshow("Original image",image);
// detect skin tone
cv::Mat mask;
detectHScolor(image,
160, 10, // hue from 320 degrees to 20 degrees
25, 166, // saturation from ~0.1 to 0.65
mask);
// show masked image
cv::Mat detected(image.size(), CV_8UC3, cv::Scalar(0, 0, 0));
image.copyTo(detected, mask);
cv::imshow("Detection result",detected);
// A test comparing luminance and brightness
// create linear intensity image
cv::Mat linear(100,256,CV_8U);
for (int i=0; i<256; i++) {
linear.col(i)= i;
}
// create a Lab image
linear.copyTo(channels[0]);
cv::Mat constante(100,256,CV_8U,cv::Scalar(128));
constante.copyTo(channels[1]);
constante.copyTo(channels[2]);
cv::merge(channels,image);
// convert back to BGR
cv::Mat brightness;
cv::cvtColor(image,brightness, CV_Lab2BGR);
cv::split(brightness, channels);
// create combined image
cv::Mat combined(200,256, CV_8U);
cv::Mat half1(combined,cv::Rect(0,0,256,100));
linear.copyTo(half1);
cv::Mat half2(combined,cv::Rect(0,100,256,100));
channels[0].copyTo(half2);
cv::namedWindow("Luminance vs Brightness");
cv::imshow("Luminance vs Brightness",combined);
cv::waitKey();
}
/*
* void sentencia(void)
* Analiza un bloque de sentencias
*/
void sentencia(void)
{
int im1, im2, im3, im4;
int dir, from, to, step;
while (pieza >= p_return)
{
test_buffer(&mem, &imem_max, imem);
switch (pieza)
{
case p_return:
inicio_sentencia();
lexico();
if (pieza == p_abrir)
{
lexico();
if (pieza != p_cerrar)
{
expresion();
if (pieza != p_cerrar)
error(3, 18); /* esperando ')' */
g1(lrtf);
}
else
{
g1(lret);
}
lexico();
}
else
{
g1(lret);
}
if (!free_sintax)
if (pieza != p_ptocoma)
error(3, 9); /* esperando ';' */
while (pieza == p_ptocoma || pieza == p_coma)
lexico();
final_sentencia();
grabar_sentencia();
break;
case p_if:
telseif[itelseif++] = 0;
inicio_sentencia();
lexico();
if (!free_sintax)
if (pieza != p_abrir)
error(3, 22); /* esperando '(' */
if (pieza == p_abrir)
lexico();
condicion();
if (!free_sintax)
if (pieza != p_cerrar)
error(3, 18); /* esperando ')' */
if (pieza == p_cerrar)
lexico();
g2(ljpf, 0);
im1 = imem - 1;
final_sentencia();
grabar_sentencia();
if1:
sentencia();
if (pieza == p_else)
{
inicio_sentencia();
lexico();
g2(ljmp, 0);
mem[im1] = imem;
im1 = imem - 1;
final_sentencia();
grabar_sentencia();
sentencia();
}
else if (pieza == p_elseif)
{
if (itelseif == 0)
error(0, 73); /* elseif fuera de bloque if */
inicio_sentencia();
g2(ljmp, 0);
telseif[itelseif++] = imem - 1;
mem[im1] = imem;
lexico();
if (!free_sintax)
if (pieza != p_abrir)
error(3, 22); /* esperando '(' */
if (pieza == p_abrir)
lexico();
condicion();
if (!free_sintax)
if (pieza != p_cerrar)
error(3, 18); /* esperando ')' */
if (pieza == p_cerrar)
lexico();
g2(ljpf, 0);
im1 = imem - 1;
final_sentencia();
grabar_sentencia();
goto if1;
}
mem[im1] = imem;
if (pieza != p_end)
error(0, 57);
lexico(); /* esperando END */
while (telseif[--itelseif] != 0)
mem[telseif[itelseif]] = imem;
break;
case p_loop:
tbreak[itbreak++] = 0;
tcont[itcont++] = 0;
lexico();
im1 = imem;
sentencia();
if (pieza != p_end)
error(0, 57); /* esperando END */
inicio_sentencia();
lexico();
g2(ljmp, im1);
while (tbreak[--itbreak] != 0)
mem[tbreak[itbreak]] = imem;
while (tcont[--itcont] != 0)
mem[tcont[itcont]] = im1;
final_sentencia();
grabar_sentencia();
break;
case p_while:
inicio_sentencia();
tbreak[itbreak++] = 0;
tcont[itcont++] = 0;
im1 = imem;
lexico();
if (!free_sintax)
if (pieza != p_abrir)
error(3, 22); /* esperando '(' */
if (pieza == p_abrir)
lexico();
condicion();
if (!free_sintax)
if (pieza != p_cerrar)
error(3, 18); /* esperando ')' */
if (pieza == p_cerrar)
lexico();
g2(ljpf, 0);
im2 = imem - 1;
final_sentencia();
grabar_sentencia();
sentencia();
if (pieza != p_end)
error(0, 57);
inicio_sentencia(); /* esperando END */
lexico();
g2(ljmp, im1);
mem[im2] = imem;
while (tbreak[--itbreak] != 0)
mem[tbreak[itbreak]] = imem;
while (tcont[--itcont] != 0)
mem[tcont[itcont]] = im1;
final_sentencia();
grabar_sentencia();
break;
case p_repeat:
tbreak[itbreak++] = 0;
tcont[itcont++] = 0;
lexico();
im1 = imem;
sentencia();
if (pieza != p_until)
error(0, 58); /* esperando UNTIL */
inicio_sentencia();
lexico();
if (!free_sintax)
if (pieza != p_abrir)
error(3, 22); /* esperando '(' */
if (pieza == p_abrir)
lexico();
condicion();
if (!free_sintax)
if (pieza != p_cerrar)
error(3, 18); /* esperando ')' */
if (pieza == p_cerrar)
lexico();
g2(ljpf, im1);
while (tbreak[--itbreak] != 0)
mem[tbreak[itbreak]] = imem;
while (tcont[--itcont] != 0)
mem[tcont[itcont]] = im1;
final_sentencia();
grabar_sentencia();
break;
case p_from:
inicio_sentencia();
tbreak[itbreak++] = 0;
tcont[itcont++] = 0;
lexico();
if (pieza != p_id)
error(0, 59); /* esperando una variable */
if (o->tipo == tvglo)
{
dir = o->vglo.offset;
g2(lcar, dir);
}
else if (o->tipo == tvloc && (!o->bloque || o->bloque == bloque_actual))
{
dir = -o->vloc.offset;
g2(lcar, -dir);
g1(laid);
}
else
error(0, 59); /* esperando una variable */
lexico();
if (pieza != p_asig)
error(3, 7);
lexico(); /* esperando '=' */
from = constante();
if (pieza != p_to)
error(1, 60);
lexico(); /* esperando TO */
to = constante();
if (from == to)
error(4, 61); /* sentencia FROM incorrecta */
if (pieza == p_step)
{
lexico();
step = constante();
if (from < to && step <= 0)
error(4, 62); /* el valor step no es válido */
if (from > to && step >= 0)
error(4, 62);
}
else
{
if (from < to)
step = 1;
else
step = -1;
}
g2(lcar, from); /* Asignación del from */
g1(lasi);
g1(lasp);
im1 = imem; /* Inicio del bucle */
if (dir >= 0)
{ /* Comparación de la condición de permanencia */
g2(lcar, dir);
}
else
{
g2(lcar, -dir);
g1(laid);
}
g1(lptr);
g2(lcar, to);
if (step > 0)
g1(lmei);
else
g1(lmai);
g2(ljpf, 0);
im2 = imem - 1;
final_sentencia();
grabar_sentencia();
if (!free_sintax)
if (pieza != p_ptocoma)
error(3, 9); /* esperando ';' */
while (pieza == p_ptocoma || pieza == p_coma)
lexico();
sentencia();
if (pieza != p_end)
error(0, 57);
inicio_sentencia(); /* esperando END */
lexico();
im3 = imem; /* Posición del continue */
if (dir >= 0)
{ /* Incremento y vuelta al inicio del bucle */
g2(lcar, dir);
}
else
{
g2(lcar, -dir);
g1(laid);
}
g2(lcar, step);
g1(lada);
g1(lasp);
g2(ljmp, im1);
mem[im2] = imem;
while (tbreak[--itbreak] != 0)
mem[tbreak[itbreak]] = imem;
while (tcont[--itcont] != 0)
mem[tcont[itcont]] = im3;
final_sentencia();
grabar_sentencia();
break;
case p_for:
inicio_sentencia();
tbreak[itbreak++] = 0;
tcont[itcont++] = 0;
lexico();
if (pieza != p_abrir)
error(3, 22);
lexico(); /* esperando '(' */
if (pieza != p_ptocoma)
{
expresion();
g1(lasp);
while (pieza == p_coma)
{
lexico();
expresion();
g1(lasp);
}
}
im1 = imem;
if (pieza != p_ptocoma)
error(3, 9);
lexico(); /* esperando ';' */
if (pieza == p_ptocoma)
{
g2(lcar, 1);
}
else
expresion();
g2(ljpf, 0);
im2 = imem - 1;
while (pieza == p_coma)
{
lexico();
expresion();
g2(ljpf, im2);
im2 = imem - 1;
}
g2(ljmp, 0);
im3 = imem - 1;
if (pieza != p_ptocoma)
error(3, 9);
lexico(); /* esperando ';' */
if (pieza != p_cerrar)
{
expresion();
g1(lasp);
while (pieza == p_coma)
{
lexico();
expresion();
g1(lasp);
}
}
g2(ljmp, im1);
if (pieza != p_cerrar)
error(3, 18);
lexico(); /* esperando ')' */
final_sentencia();
grabar_sentencia();
mem[im3++] = imem;
sentencia();
if (pieza != p_end)
error(0, 57); /* esperando END */
inicio_sentencia();
lexico();
g2(ljmp, im3);
do
{
im1 = mem[im2];
mem[im2] = imem;
im2 = im1;
} while (im2);
while (tbreak[--itbreak] != 0)
mem[tbreak[itbreak]] = imem;
while (tcont[--itcont] != 0)
mem[tcont[itcont]] = im3;
final_sentencia();
grabar_sentencia();
break;
case p_switch:
inicio_sentencia();
lexico();
if (!free_sintax)
if (pieza != p_abrir)
error(3, 22); /* esperando '(' */
if (pieza == p_abrir)
lexico();
condicion();
if (!free_sintax)
if (pieza != p_cerrar)
error(3, 18); /* esperando ')' */
if (pieza == p_cerrar)
lexico();
while (pieza == p_ptocoma)
{
lexico();
}
final_sentencia();
grabar_sentencia();
im1 = 0;
im2 = 0;
while (pieza != p_end)
{
inicio_sentencia();
if (pieza == p_case)
{
im3 = 0;
do
{
lexico();
if (im1)
mem[im1] = imem;
expresion();
if (pieza != p_rango)
{
g2(lcse, 0);
im1 = imem - 1;
}
else
{
lexico();
expresion();
g2(lcsr, 0);
im1 = imem - 1;
}
if (pieza == p_coma)
{
g2(ljmp, im3);
im3 = imem - 1;
}
} while (pieza == p_coma);
while (im3)
{
im4 = mem[im3];
mem[im3] = imem;
im3 = im4;
}
}
else if (pieza == p_default)
{
lexico();
if (im1)
mem[im1] = imem;
im1 = 0;
}
else
error(0, 63); /* esperando case, default o end */
if (!free_sintax)
if (pieza != p_ptocoma)
error(3, 64); /* esperando ':' */
while (pieza == p_ptocoma || pieza == p_coma)
lexico();
g1(lasp);
final_sentencia();
grabar_sentencia();
sentencia();
if (pieza != p_end)
error(0, 57); /* esperando END */
inicio_sentencia();
g2(ljmp, im2);
im2 = imem - 1;
pasa_ptocoma();
final_sentencia();
grabar_sentencia();
}
inicio_sentencia();
if (im1)
mem[im1] = imem;
g1(lasp);
while (im2)
{
im1 = mem[im2];
mem[im2] = imem;
im2 = im1;
}
lexico();
final_sentencia();
grabar_sentencia();
break;
case p_frame:
inicio_sentencia();
lexico();
if (pieza == p_abrir)
{
lexico();
if (pieza != p_cerrar)
{
expresion();
if (pieza != p_cerrar)
error(3, 18); /* esperando ')' */
g1(lfrf);
}
else
{
g1(lfrm);
}
lexico();
}
else
{
g1(lfrm);
}
if (!free_sintax)
if (pieza != p_ptocoma)
error(3, 9); /* esperando ';' */
while (pieza == p_ptocoma || pieza == p_coma)
lexico();
final_sentencia();
grabar_sentencia();
break;
case p_debug:
inicio_sentencia();
g1(ldbg);
lexico();
if (!free_sintax)
if (pieza != p_ptocoma)
error(3, 9); /* esperando ';' */
while (pieza == p_ptocoma || pieza == p_coma)
lexico();
final_sentencia();
grabar_sentencia();
break;
case p_break:
inicio_sentencia();
if (itbreak == 0)
error(0, 65);
lexico(); /* break fuera de un bucle */
if (!free_sintax)
if (pieza != p_ptocoma)
error(3, 9); /* esperando ';' */
while (pieza == p_ptocoma || pieza == p_coma)
lexico();
g2(ljmp, 0);
tbreak[itbreak++] = imem - 1;
final_sentencia();
grabar_sentencia();
break;
case p_continue:
inicio_sentencia();
if (itcont == 0)
error(0, 66);
lexico(); /* continue fuera de un bucle */
if (!free_sintax)
if (pieza != p_ptocoma)
error(3, 9); /* esperando ';' */
while (pieza == p_ptocoma || pieza == p_coma)
lexico();
g2(ljmp, 0);
tcont[itcont++] = imem - 1;
final_sentencia();
grabar_sentencia();
break;
case p_clone:
inicio_sentencia();
lexico();
g2(lclo, 0);
im1 = imem - 1;
final_sentencia();
grabar_sentencia();
sentencia();
if (pieza != p_end)
error(0, 57);
lexico(); /* esperando END */
mem[im1] = imem;
break;
case p_ptocoma:
lexico();
break;
default:
inicio_sentencia();
error_25 = 67;
expresion();
do
{
_exp--;
} while ((*_exp).tipo == eoper && (*_exp).token == p_string);
error_25 = 25;
switch ((*_exp).tipo)
{
case ecall:
break;
case efext:
break;
case eoper:
switch ((*_exp).token)
{
case p_asig:
case p_inc:
case p_suma:
case p_dec:
case p_resta:
case p_add_asig:
case p_sub_asig:
case p_mul_asig:
case p_div_asig:
case p_mod_asig:
case p_and_asig:
case p_or_asig:
case p_xor_asig:
case p_shr_asig:
case p_shl_asig:
case p_asigword:
case p_incword:
case p_sumaword:
case p_decword:
case p_restaword:
case p_add_asigword:
case p_sub_asigword:
case p_mul_asigword:
case p_div_asigword:
case p_mod_asigword:
case p_and_asigword:
case p_or_asigword:
case p_xor_asigword:
case p_shr_asigword:
case p_shl_asigword:
case p_asigchar:
case p_incchar:
case p_sumachar:
case p_decchar:
case p_restachar:
case p_add_asigchar:
case p_sub_asigchar:
case p_mul_asigchar:
case p_div_asigchar:
case p_mod_asigchar:
case p_and_asigchar:
case p_or_asigchar:
case p_xor_asigchar:
case p_shr_asigchar:
case p_shl_asigchar:
case p_strcpy:
case p_strcat:
case p_strsub:
break;
default:
error(4, 68);
break; /* expresion sin sentido */
}
break;
default:
error(4, 68); /* expresion sin sentido */
}
if (!free_sintax)
if (pieza != p_ptocoma)
error(3, 9); /* esperando ';' */
while (pieza == p_ptocoma || pieza == p_coma)
lexico();
g1(lasp);
final_sentencia();
grabar_sentencia();
break;
}
}
}
