コード例 #1
0
ファイル: main.c プロジェクト: josedotchigua/-MIA-201346084
int ejecutarComando(char* line)
{
    int maquina_estado=1;
    const int maquina_estado_inicial=1;
    const int comando_constante=2;
    const int parametro_constante=3;
    const int valor_cosntante=4;

    const int comando_ejecutado=0;
    const int error_const=-1;


    char comando[50];
    char parametro[50];
    char valor[1000];
    char aux='\0';
    memset(comando,'\0',sizeof(comando));
    memset(parametro,'\0',sizeof(parametro));
    memset(valor,'\0',sizeof(valor));

    int comando_detectado=0;
    const int comando_detectado_nulo=0;
    const int mkdisk_constante=1;
    const int rmdisk_constante=2;
    const int fdisk_constante =3;
    const int mount_constante =4;
    const int umount_constante=5;

    int       type_parametro=0;
    const int type_numero=1;
    const int type_char=2;
    const int type_string=3;

    int    parametro_detectado=0;
    const int size_constante=1;
    const int unit_constante=2;
    const int path_constante=3;
    const int name_constante=4;

    int    marcador=0;
    int    char_len=0;

    int    size_flag=0;
    int    unit_flag=0;
    int    path_flag=0;
    int    name_flag=0;


    char   size[500];
    char   unit='m';
    char   path[1000];
    char   name[500];
    memset(size,'\0',sizeof(size));
    memset(path,'\0',sizeof(path));
    memset(name,'\0',sizeof(name));

    //  mkdisk -size::1 -path::"/home/josedotchigua/Escritorio/" +unit::k -name::"DISK1.dsk"

    maquina_estado=maquina_estado_inicial;
    comando_detectado=comando_detectado_nulo;
    for(int i=0;i<=strlen(line);i++)
    {
        if(((line[i]!=' ')&&(line[i]!='\t')&&(line[i]!='\n')&&(i!=strlen(line)))&&((marcador<2)))
        {
            if(maquina_estado==maquina_estado_inicial)
            {
                maquina_estado=comando_constante;
                i--;
            }
            else if(maquina_estado==comando_constante)
            {
                aux=line[i];
                strncat(comando,&aux,1);
            }
            else if(maquina_estado==parametro_constante)
            {
                if(line[i]==':')
                {
                    marcador++;
                }
                    aux=line[i];
                    strncat(parametro,&aux,1);

            }
            else if(maquina_estado==valor_cosntante)
            {
                if(type_parametro==type_string)
                {
                    int marca_string=0;
                    for(int z=i;z<strlen(line);z++)
                    {
                        if(line[z]=='"')
                        {
                            marca_string++;
                        }
                        if(marca_string<2)
                        {
                            aux=line[z];
                            strncat(valor,&aux,1);
                        }
                        else if(marca_string==2)
                        {
                            aux=line[z];
                            strncat(valor,&aux,1);
                            break;
                        }
                        if((z==(strlen(line)-1))&&(marca_string<2))
                        {
                            break;
                        }
                        i++;
                    }
                 }
                else if(type_parametro==type_numero)
                {
                    aux=line[i];
                    strncat(valor,&aux,1);

                }
                else if(type_parametro==type_char)
                {

                    if(strlen(valor)<=char_len)
                    {
                        aux=line[i];
                        strncat(valor,&aux,1);

                    }
                    else
                    {
                        marcador==3;
                    }

                }
            }
        }
        else
        {
            if((maquina_estado==comando_constante)&&(strlen(comando)>0))
            {
                if(strcasecmp(comando,"mkdisk")==0)
                {
                    maquina_estado=parametro_constante;
                    marcador=0;
                    memset(parametro,'\0',sizeof(parametro));
                    comando_detectado=mkdisk_constante;
                }
                else if(strcasecmp(comando,"rmdisk")==0)
                {
                    maquina_estado=parametro_constante;
                    marcador=0;
                    memset(parametro,'\0',sizeof(parametro));
                    comando_detectado=rmdisk_constante;
                }
                else if(strcasecmp(comando,"fdisk")==0)
                {
                    maquina_estado=parametro_constante;
                    marcador=0;
                    memset(parametro,'\0',sizeof(parametro));
                    comando_detectado=fdisk_constante;
                }
                else if(strcasecmp(comando,"mount")==0)
                {
                    maquina_estado=parametro_constante;
                    marcador=0;
                    memset(parametro,'\0',sizeof(parametro));
                    comando_detectado=mount_constante;
                }
                else if(strcasecmp(comando,"umount")==0)
                {
                    maquina_estado=parametro_constante;
                    marcador=0;
                    memset(parametro,'\0',sizeof(parametro));
                    comando_detectado=umount_constante;
                }
                else
                {
                    comando_detectado=comando_detectado_nulo;
                    printf("No se reconoce '%s' como un instrucción valida.\n",comando);
                    return error_const;
                }
            }
            else if((maquina_estado==parametro_constante)&&(strlen(parametro)>0))
            {
                if(comando_detectado==mkdisk_constante)
                {
                    if(strcasecmp(parametro,"-size::")==0)
                    {
                        maquina_estado=valor_cosntante;
                        marcador=0;
                        parametro_detectado=size_constante;
                        type_parametro=type_numero;
                        memset(valor,'\0',sizeof(valor));
                        i--;
                    }
                    else if((strcasecmp(parametro,"+unit::")==0))
                    {
                        maquina_estado=valor_cosntante;
                        marcador=0;
                        parametro_detectado=unit_constante;
                        type_parametro=type_char;
                        char_len=1;
                        memset(valor,'\0',sizeof(valor));
                        i--;
                    }
                    else if((strcasecmp(parametro,"-path::")==0))
                    {
                        maquina_estado=valor_cosntante;
                        marcador=0;
                        parametro_detectado=path_constante;
                        type_parametro=type_string;
                        memset(valor,'\0',sizeof(valor));
                        i--;

                    }
                    else if((strcasecmp(parametro,"-name::")==0))
                    {
                        maquina_estado=valor_cosntante;
                        marcador=0;
                        parametro_detectado=name_constante;
                        type_parametro=type_string;
                        memset(valor,'\0',sizeof(valor));
                        i--;

                    }
                    else
                    {
                        printf("PARAMETRO ERRONEO\n");
                        return error_const;
                    }
                }
            }
            else if((maquina_estado==valor_cosntante)&&(strlen(valor)>0))
            {

                if(type_parametro==type_numero)
                {

                    for(int j=0;j<strlen(valor);j++)
                    {
                        if((valor[j]<'0')||(valor[j]>'9'))
                        {
                            printf("VALOR NUMERICO ERRONEO %s\n",valor);
                            return error_const;
                        }

                    }
                    if(parametro_detectado==size_constante)
                    {
                            memset(size,'\0',sizeof(size));
                            strcpy(size,valor);
                            size_flag=1;
                    }
                    maquina_estado=parametro_constante;
                    marcador=0;
                    memset(parametro,'\0',sizeof(parametro));

                }
                else if(type_parametro==type_string)
                {

                    if((valor[0]!='"')||(valor[strlen(valor)-1]!='"'))
                    {
                        printf("VALOR DE CADENA ERRONEO %s\n",valor);
                        return error_const;
                    }
                    else
                    {
                        char aux[1000];
                        memset(aux,'\0',sizeof(aux));
                        for(int k=0;k<strlen(valor)-2;k++)
                        {
                            aux[k]=valor[k+1];
                        }
                        if(parametro_detectado==name_constante)
                        {
                                memset(name,'\0',sizeof(name));
                                strcpy(name,aux);
                                name_flag=1;
                        }
                        else if(parametro_detectado==path_constante)
                        {

                                memset(path,'\0',sizeof(path));
                                strcpy(path,aux);
                                path_flag=1;

                        }
                    }
                    maquina_estado=parametro_constante;
                    marcador=0;
                    memset(parametro,'\0',sizeof(parametro));
                }
                else if(type_parametro==type_char)
                {

                    for(int j=0;j<strlen(valor);j++)
                    {
                        if(!(((valor[j]>='A')&&(valor[j]<='Z'))||((valor[j]>='a')&&(valor[j]<='z'))))
                        {
                            printf("VALOR CHAR ERRONEO %s \n",valor);
                            return error_const;
                        }


                    }
                    if(parametro_detectado==unit_constante)
                    {
                            unit=valor[0];
                            unit_flag=1;
                    }
                    maquina_estado=parametro_constante;
                    marcador=0;
                    memset(parametro,'\0',sizeof(parametro));
                }
            }
        }

    }
    if(comando_detectado==mkdisk_constante)
    {
        if(size_flag==1)
        {
            if(path_flag==1)
            {
                if(name_flag==1)
                {
                    mkdisk(size,unit,path,name);
                    maquina_estado=comando_ejecutado;
                    return maquina_estado;

                }
                else
                {
                    printf("Falta parametro '-name::'.\n");
                    return error_const;
                }
            }
            else
            {
                printf("Falta parametro '-path::'.\n");
                return error_const;
            }
        }
        else
        {
            printf("Falta parametro '-size::'\n.");
            return error_const;
        }

    }

return 0;
}
コード例 #2
0
ファイル: automata.c プロジェクト: rafa594/proyectomia
void leer(char *cadena){
    limpiar(cadena);
    if (strcasecmp(cadena,"mount")==0){
        listarMount();
        return;
    }
    int tipoFDISK = 0;
    atributeStruct atributos;
    atributos.path = (char*)malloc(100);
    atributos.name = (char*)malloc(100);
    atributos.type = (char*)malloc(5);
    atributos.fit = (char*)malloc(3);
    atributos.id = (char*)malloc(5);
    atributos.deleteAtr= (char*)malloc(5);
    int id = 1;
    int obligatorio=-1;
    int atributo = 0;
    int estado=0;
    int i=0;
    int j=0;
    int operacion=0;
    char bufer[50];
    limpiarBufer(bufer,50);

    while(cadena[i]!='\0'){

        switch(estado){

            case 0:

                if(cadena[i]==' '){
                estado=0;
                i++;
                }else if(cadena[i]=='#'){
                printf("Comentario.\n");
                estado=100;
                i++;
                }
                else if((cadena[i]>64 && cadena[i]<91)||(cadena[i]>96 &&cadena[i]<123)){
                    estado=1;
                    bufer[j]=cadena[i];
                    i++;
                    j++;
                }
                else{
                    printf("Comando incorrecto.\n");
                    return;
                }
                break;
            case 1:
                if((cadena[i]>64 && cadena[i]<91)||(cadena[i]>96 &&cadena[i]<123)){
                    estado=1;
                    bufer[j]=cadena[i];
                    i++;
                    j++;
                }else if(cadena[i]==' '){
                estado = 50;
                }
                else{
                    printf("Comando incorrecto.\n");
                    return;
                }
                break;
            case 2:
                if(cadena[i]=='-'){
                    //obligatorio
                    obligatorio = 1;
                    estado = 3;
                    i++;
                }else if(cadena[i]=='+'){
                    //opcional
                    obligatorio = 0;
                    estado = 4;
                    i++;
                }else if(cadena[i]==' '){
                    estado = 2;
                    i++;
                }else if(cadena[i]=='\0'){
                    estado = 0;
                    i++;
                }else if(cadena[i]=='\\'&& cadena[i+1]==13 && cadena[i+2]==10){
                    estado = 2;
                    i=i+3;
                }
                else {
                    printf("Comando incorrecto.\n");
                    return;
                }

                break;

            case 3:
                if((cadena[i]>64 && cadena[i]<91)||(cadena[i]>96 &&cadena[i]<123)){
                    estado=3;
                    bufer[j]=cadena[i];
                    i++;
                    j++;
                }else if(cadena[i]==':'){
                    estado = 5;
                    i++;
                }else if((cadena[i]>48) &&(cadena[i]<58)){
                    bufer[j]='\0';
                    if(strcasecmp(bufer,"id")==0){
                        bufer[j] == cadena[i];
                        j++;
                        operacion = 5;
                        estado = 7;
                        i++;
                        break;
                    }
                }
                else{
                    printf("Comando incorrecto.\n");
                    return;
                }
                break;
            case 4:
                if((cadena[i]>64 && cadena[i]<91)||(cadena[i]>96 &&cadena[i]<123)){
                    estado = 4;
                    bufer[j]=cadena[i];
                    i++;
                    j++;
                }else if(cadena[i]==':'){
                    estado = 6;
                    i++;
                }else{
                    printf("Comando incorrecto.\n");
                    return;
                }
                break;

            case 5:
                if(cadena[i]==':'){
                    i++;
                    bufer[j]='\0';
                    j=0;
                    if(strcasecmp(bufer,"size")==0){
                        atributo = 1;
                        switch(operacion){
                            case 1:
                            case 3:
                                estado = 11;//numero
                                break;
                            default:
                                printf("Comando incorrecto.\n");
                                return;
                        }

                        break;
                    }else if(strcasecmp(bufer,"path")==0){
                        atributo = 2;

                        switch(operacion){
                            case 1:
                            case 2:
                            case 3:
                            case 4:
                            case 6:
                            case 7:
                                estado = 10;//path
                                break;
                            default:
                                printf("Comando incorrecto.\n");
                                return;
                        }


                        break;
                    }else if(strcasecmp(bufer,"name")==0){
                        atributo = 3;
                        limpiarBufer(bufer,50);
                        j=0;
                        switch(operacion){
                            case 1:
                            case 3:
                            case 4:
                            case 7:
                                estado = 10;//path
                                break;
                            default:
                                printf("Comando incorrecto.\n");
                                return;
                        }
                        break;
                    }else if(strcasecmp(bufer,"id")==0){
                        atributo = 3;
                        limpiarBufer(bufer,50);
                        j=0;
                        switch(operacion){
                            case 3:
                            case 4:
                            case 7:
                                i--;
                                estado = 17;//path
                                break;
                            default:
                                printf("Comando incorrecto.\n");
                                return;
                        }
                        break;
                    }
                    else{
                        printf("Comando incorrecto.\n");
                        return;
                    }

                }else{
                    printf("Comando incorrecto.\n");
                    return;
                }
                break;

            case 6:
                if(cadena[i]==':'){
                    i++;
                    bufer[j]='\0';
                    j=0;
                    if(strcasecmp(bufer,"unit")==0){

                        atributo = 6;
                        switch(operacion){
                            case 1:
                            case 3:
                                estado = 12;//char
                                break;
                            default:
                                printf("Comando incorrecto.\n");
                                return;
                        }

                        break;
                    }else if(strcasecmp(bufer,"delete")==0){
                        atributo = 9;
                        if (tipoFDISK!=0)
                            tipoFDISK=-1;
                            else tipoFDISK =1;

                        switch(operacion){
                            case 1:
                            case 3:
                                estado = 15;//char
                                break;
                            default:
                                printf("Comando incorrecto.\n");
                                return;
                        }

                        break;
                    }else if(strcasecmp(bufer,"add")==0){
                        atributo = 10;
                        if (tipoFDISK!=0)
                            tipoFDISK=-1;
                            else tipoFDISK =2;

                        switch(operacion){
                            case 1:
                            case 3:
                                estado = 11;//char
                                break;
                            default:
                                printf("Comando incorrecto.\n");
                                return;
                        }

                        break;
                    }else if(strcasecmp(bufer,"type")==0){
                        atributo = 7;

                        switch(operacion){
                            case 3:
                                estado = 15;//cadena sin comillas
                                break;
                            default:
                                printf("Comando incorrecto.\n");
                                return;
                        }

                        break;
                    }else if(strcasecmp(bufer,"fit")==0){
                        atributo = 8;

                        switch(operacion){
                            case 3:
                                estado = 15;//cadena sin comillas
                                break;
                            default:
                                printf("Comando incorrecto.\n");
                                return;
                        }

                        break;
                    }

                    else{
                    printf("Comando incorrecto.\n");
                    return;
                    }

                }else{
                    printf("Comando incorrecto.\n");
                    return;
                }
                break;

            case 7:
                if((cadena[i]>48) &&(cadena[i]<58)){
                    bufer[j]=cadena[i];
                    i++;
                    j++;
                    estado=7;
                }else if(cadena[i]==':'){
                    limpiarBufer(bufer,50);
                    j=0;
                    estado = 17;
                    i++;
                }else{
                    printf("Comando incorrecto.\n");
                    return;
                }
                break;

            case 10:
                if(cadena[i]=='"'){
                    limpiarBufer(bufer,50);
                    j=0;
                    estado = 20;
                    i++;
                }else{
                    printf("Comando incorrecto.\n");
                    return;
                }
                break;

           case 15:
                if((cadena[i]>64 && cadena[i]<91)||(cadena[i]>96 &&cadena[i]<123)){
                    estado = 15;
                    bufer[j]=cadena[i];
                    j++;
                    if(cadena[i+1]=='\0')
                        estado = 16;
                    else i++;

                }else if(cadena[i]==' '){
                    estado = 16;
                }else{
                    printf("Comando incorrecto.\n");
                    return;
                }


                break;
            case 16:
                bufer[j]='\0';
                i++;
                if(atributo==7){
                    strcpy(atributos.type, bufer);
                    estado = 2;
                }else if(atributo==8){
                    strcpy(atributos.fit, bufer);
                    estado = 2;
                }else if(atributo==9){
                    strcpy(atributos.deleteAtr, bufer);
                    estado = 2;
                }else{
                    printf("Comando incorrecto.\n");
                    return;
                }
                limpiarBufer(bufer,50);
                    j=0;
                break;
            case 11:
                if((cadena[i]>47) &&(cadena[i]<58)||(cadena[i]=='-')){
                    bufer[j]=cadena[i];
                    j++;
                    estado=11;
                    if(cadena[i+1]=='\0'){
                        estado = 22;
                    }else i++;
                }else if(cadena[i]== ' '){
                    estado = 22;
                }else{
                    printf("Comando incorrecto.\n");
                    return;
                }
                break;
            case 12:
                if((cadena[i]>64 && cadena[i]<91)||(cadena[i]>96 &&cadena[i]<123)){
                    estado = 2;

                    j=0;
                    limpiarBufer(bufer,50);
                    if (atributo == 6){
                        atributos.unit = cadena[i];
                        i++;
                    }else{
                        printf("Comando incorrecto.\n");
                        return;
                    }
                }else{
                    printf("Comando incorrecto.\n");
                    return;
                }
                break;
            case 20:
                if (cadena[i]!='"'){
                    bufer[j]= cadena[i];
                    i++;
                    j++;
                    estado = 20;
                }else{
                    bufer[j]='\0';
                    estado = 21;

                }
                break;

            case 21:
            i++;
                if (atributo == 2){
                    strcpy(atributos.path,bufer);
                    estado =2;
                    j = 0;
                    limpiarBufer(bufer,50);
                }else if(atributo == 3){
                    strcpy(atributos.name,bufer);
                    estado =2;
                    j = 0;
                    limpiarBufer(bufer,50);
                }else{
                    printf("Comando incorrecto.\n");
                    return;
                }


                break;
            case 22:
                bufer[j]='\0';i++;
                switch(atributo){
                    case 1:
                        atributos.size = atoi(bufer);
                        j = 0;
                        limpiarBufer(bufer,50);
                        estado = 2;
                        break;
                    default:
                        printf("Comando incorrecto.\n");
                        return;
                }

                break;
            case 17:
                if (cadena[i]==':'){
                    i++;
                    if((cadena[i]=='v'||cadena[i]=='V')&&(cadena[i+1]=='d'||cadena[i+1]=='D')){
                        bufer[j]=cadena[i];
                        i++;j++;
                        bufer[j]=cadena[i];
                        i++;j++;
                        if((cadena[i]>64 && cadena[i]<91)||(cadena[i]>96 &&cadena[i]<123)){
                            bufer[j]=cadena[i];
                            i++;
                            j++;
                            while((cadena[i]>48) &&(cadena[i]<58)){
                                bufer[j] = cadena[i];
                                i++;
                                j++;
                            }
                            estado = 18;
                            if(cadena[i]=='\0')
                                i--;
                            break;
                        }else{
                        printf("Comando incorrecto.\n");
                        return;
                        }

                    }else{
                        printf("Comando incorrecto.\n");
                        return;
                    }

                }else{
                    printf("Comando incorrecto.\n");
                    return;
                }

                break;
            case 18:
                bufer[j]='\0';
                j=0;
                strcpy(atributos.id,bufer);
                limpiarBufer(bufer,50);
                estado = 2;
                i++;
                break;

            case 50:
                bufer[j]='\0';
                if(strcasecmp(bufer,"mkdisk")==0){
                        atributos.unit = 'M';
                        operacion = 1;
                        estado = 2;
                        i++;
                        j=0;
                }else if(strcasecmp(bufer,"rmdisk")==0){
                        operacion = 2;
                        estado = 2;
                        i++;
                        j=0;
                }else if(strcasecmp(bufer,"fdisk")==0){
                        atributos.unit = 'K';
                        strcpy(atributos.type,"P");
                        strcpy(atributos.fit,"WF");
                        operacion = 3;
                        estado = 2;
                        i++;
                        j=0;

                }else if(strcasecmp(bufer,"mount")==0){
                        operacion = 4;
                        estado = 2;
                        i++;
                        j=0;

                }else if(strcasecmp(bufer,"umount")==0){
                        operacion = 5;
                        estado = 2;
                        i++;
                        j=0;

                }else if(strcasecmp(bufer,"exec")==0){
                        operacion = 6;
                        estado = 2;
                        i++;
                        j=0;

                }else if(strcasecmp(bufer,"rep")==0){
                        operacion = 7;
                        estado = 2;
                        i++;
                        j=0;

                }else{
                    printf("amm");
                    return;
                }
                break;
            case 100:
                if(cadena[i]!='\0'){
                    i++;
                    estado = 100;
                    break;
                }
            default:

                break;
        }//switch


    }//while
    switch (operacion){
        case 1:
            printf("mkdisk\n");
            mkdisk(atributos);
            return;
        case 2:
            printf("rmdisk\n");
            rmdisk(atributos);
            return;
        case 3:
            printf("fdisk\n");
            fdisk(atributos,tipoFDISK);
            return;
        case 4:
            printf("mount\n");
            mount(atributos);
            return;
        case 5:
            printf("umount\n");
            umount(atributos);
            return;
        case 6:
            printf("exec\n");
            exec(atributos);
            return;
        case 7:
            printf("rep\n");
            rep(atributos);
            return;
        break;
    }


}