'/**
' * Archivos
' *
' * @author  Jovani Pérez Damián (@BlackBlex)
' *
' * ==============Information==============
' *      Filename: Archivo.cml
' * ---------------------------------------
'*/

'APIS'
API CDECL fwrite(buffer, size, number, file:Entero):Entero, "msvcrt"
API CDECL fscanf(file:Entero, formato:Cadena, destino:Entero):Entero, "msvcrt"
API CDECL fopen(fileName:Cadena, modo:Cadena):Entero, "msvcrt"
API CDECL fclose(file:Entero):Entero, "msvcrt"
API CDECL fseek(file, offset, origin:Entero):Entero, "msvcrt"
API CDECL ftell(file:Entero):Entero, "msvcrt"

Clase InfoArchivo
    Var nombreArchivo:Cadena
    Var directorioArchivo:Cadena
    Var extensionArchivo:Cadena
    Var lecturaArchivo:Booleano
    Var escrituraArchivo:Booleano
    Var tamañoArchivo:Entero
    Var ptrArchivo:Entero
    
    Proc conseguirNombre():Cadena
        Resultado = nombreArchivo
    FinProc

    Proc conseguirDirectorio():Cadena
        Resultado = directorioArchivo
    FinProc
    
    Proc conseguirExtension():Cadena
        Resultado = extensionArchivo
    FinProc

    Proc conseguirTamaño():Entero
        Resultado = tamañoArchivo
    FinProc

    Proc esLectura():Booleano
        Resultado = lecturaArchivo
    FinProc

    Proc esEscritura():Booleano
        Resultado = escrituraArchivo
    FinProc

    Proc conseguirPtr():Entero
        Resultado = ptrArchivo
    FinProc

    Proc checarApertura():Booleano
        Si (ptrArchivo = 0) Entonces
            Mensaje("No puedes realizar operaciones si no está abierto el archivo")
            Resultado = Falso
        SiNo
            Resultado = Verdad
        FinSi
    FinProc
FinClase

Clase ArchivoC(InfoArchivo),_
    archivoNombre[],_
    archivoExtension[],_
    separador,_
    texto:Cadena,_
    temp:Entero

    Destructor:Finalizador

    Proc Finalizador
        cerrar()
    FinProc

    Sección Pública
        Proc abrir(dirección:Cadena, DesiredAccess, CreationDisposition:Entero)
            Si Buscar(dirección, "\\") > 0 Entonces
                separador = "\\"
            SiNo
                separador = "\/"
            FinSi

            archivoNombre = Separar(dirección, separador)
            nombreArchivo = archivoNombre[&archivoNombre-1]
            archivoExtension = Separar(nombreArchivo, ".")
            extensionArchivo = archivoExtension[&archivoExtension-1]
            directorioArchivo = Reemplazar(dirección, separador + nombreArchivo, "")

            Si DesiredAccess = GENERIC_READ Entonces
                lecturaArchivo = Verdad
                escrituraArchivo = Falso
            OSi (DesiredAccess = GENERIC_WRITE) Or (DesiredAccess = FILE_APPEND_DATA) Entonces
                escrituraArchivo = Verdad
                lecturaArchivo = Falso
            OSi DesiredAccess = (GENERIC_WRITE + GENERIC_READ) Entonces
                escrituraArchivo = Verdad
                lecturaArchivo = Verdad
            FinSi

            ptrArchivo = CreateFile(dirección, DesiredAccess, nulo , nulo, CreationDisposition, FILE_ATTRIBUTE_NORMAL,0)

            Si ( ptrArchivo = INVALID_HANDLE ) Entonces
                Mensaje("El archivo no pudo ser abierto: " + dirección)
            FinSi

            tamañoArchivo = GetFileSize(ptrArchivo, nulo)
        FinProc

        Proc escribir(Referencia txt:Cadena)
            Si( checarApertura() = Verdad ) Entonces
                Si( escrituraArchivo = Verdad ) Entonces
                    WriteFile(ptrArchivo, StrPtr(txt), CadLong(txt), temp, nulo)
                SiNo
                    Mensaje("No se permite la escritura cuando el archivo esta abierto como solo lectura.")
                FinSi
            FinSi
        FinProc

        Proc leer():Cadena
            Si( checarApertura() = Verdad ) Entonces
                Si( lecturaArchivo = Verdad ) Entonces
                    texto = Espacio(tamañoArchivo+1)
                    ReadFile(ptrArchivo, StrPtr(texto), tamañoArchivo, temp, nulo)
                    Resultado = texto
                SiNo
                    Mensaje("No se permite la lectura cuando el archivo esta abierto como solo escritura.")
                FinSi
            FinSi
        FinProc

        Proc cerrar()
            Si ( checarApertura() = Verdad ) Entonces
                CloseFile(ptrArchivo)
            FinSi
        FinProc
FinClase

Clase ArchivoF(InfoArchivo),_
    archivoNombre[],_
    archivoExtension[],_
    separador,_
    texto:Cadena,_
    temp:Entero

    Destructor:Finalizador

    Proc Finalizador
        cerrar()
    FinProc

    Sección Pública
        Proc abrir(dirección, modo:Cadena)
            Si Buscar(dirección, "\\") > 0 Entonces
                separador = "\\"
            SiNo
                separador = "\/"
            FinSi

            temp = fopen(dirección, "r")
            fseek(temp, 0, SEEK_END)
            tamañoArchivo = ftell(temp)
            fclose(temp)
            temp = 0

            archivoNombre = Separar(dirección, separador)           
            nombreArchivo = archivoNombre[&archivoNombre-1]
            archivoExtension = Separar(nombreArchivo, ".")
            extensionArchivo = archivoExtension[&archivoExtension-1]
            directorioArchivo = Reemplazar(dirección, separador + nombreArchivo, "")

            Si Buscar(modo, "+") Entonces
                lecturaArchivo = Verdad
                escrituraArchivo = Verdad
            OSi Buscar(modo, "r") Entonces
                lecturaArchivo = Verdad
                escrituraArchivo = Falso
            OSi Buscar(modo, "w") or Buscar(modo, "a") Entonces
                lecturaArchivo = Falso
                escrituraArchivo = Verdad
            FinSi

            ptrArchivo = fopen(dirección, modo)

            Si ( ptrArchivo = INVALID_HANDLE ) Entonces
                Mensaje("El archivo no pudo ser abierto: " + dirección)
            FinSi

        FinProc

        Proc escribir(Referencia txt:Cadena)
            Si( checarApertura() = Verdad ) Entonces
                Si( escrituraArchivo = Verdad ) Entonces
                    fwrite(StrPtr(txt), CadLong(txt), 1, ptrArchivo)
                SiNo
                    Mensaje("No se permite la escritura cuando el archivo esta abierto como solo lectura.")
                FinSi
            FinSi
        FinProc

        Proc leer():Cadena
            Si( checarApertura() = Verdad ) Entonces
                Si( lecturaArchivo = Verdad ) Entonces
                    texto = Espacio(MAX_PATH)
                    fscanf(ptrArchivo, "%[^" + CRLF + "] " + CRLF, StrPtr(texto))
                    Resultado = texto
                SiNo
                    Mensaje("No se permite la lectura cuando el archivo esta abierto como solo escritura.")
                FinSi
            FinSi
        FinProc

        Proc cerrar()
            Si ( checarApertura() = Verdad ) Entonces
                fclose(ptrArchivo)
            FinSi
        FinProc
FinClase

'/**
' * Constantes para el archivo
' *
' * @author  Jovani Pérez Damián (@BlackBlex)
' *
' * ==============Information==============
' *      Filename: Constantes.cml
' * ---------------------------------------
'*/
 
' File '
Const FILE_ATTRIBUTE_NORMAL = &80
Const FILE_APPEND_DATA = 4
Const SEEK_CUR = 1
Const SEEK_END = 2
Const SEEK_SET = 0
Const FILE_SEEK_OK = 0

Importar "Cramel.cml"
Importar "MSVBVM60\MSVBVM60.cml"
Importar "Constantes.cml"
Importar "Archivo.cml"

Var contenido, salida:Cadena
Var archivoC:ArchivoC
Var tempCad:Cadena

Crear archivoC
archivoC.abrir("D:\BlackBlex_antiguo\Desktop\LogF.txt", GENERIC_READ, OPEN_EXISTING)

contenido = archivoC.leer()

salida = "Nombre del archivo: " + archivoC.conseguirNombre() + CRLF
salida = salida + "Directorio del archivo: " + archivoC.conseguirDirectorio() + CRLF
salida = salida + "Extension del archivo: " + archivoC.conseguirExtension() + CRLF
salida = salida + "Archivo de lectura: " + EntCad(archivoC.esLectura()) + CRLF
salida = salida + "Archivo de escritura: " + EntCad(archivoC.esEscritura()) + CRLF
salida = salida + "Tama\x241o del archivo: " + EntCad(archivoC.conseguirTamaño()) + " bytes" + CRLF
salida = salida + "Puntero: " + EntCad(archivoC.conseguirPtr()) + CRLF
salida = salida + "Contenido: " + contenido
Mensaje(salida)

archivoC.cerrar()
Destruir archivoC

'/**
' * Consola
' *
' * @author  Jovani Pérez Damián (@BlackBlex)
' *
' * ==============Information==============
' *      Filename: Consola.cml
' * ---------------------------------------
'*/

Clase Consola,_
    hEntrada,_
    hSalida,_
    hError,_
    textoEscritura,_
    contador:Entero,_
    caracter,_
    letra,_
    texto:Cadena,_
    modo:WORD,_
    tecla:Byte

    Constructor:Inicializar
    Destructor:Finalizar

    Proc Inicializar
        AllocConsole()
        hEntrada = GetStdHandle(STD_INPUT_HANDLE)
        hSalida = GetStdHandle(STD_OUTPUT_HANDLE)
        hError = GetStdHandle(STD_ERROR_HANDLE)

        Si hEntrada = INVALID_HANDLE Entonces
            Mensaje("Error al obtener STDIN")
        FinSi

        Si hSalida = INVALID_HANDLE Entonces
            Mensaje("Error al obtener STDOUT")
        FinSi

        Si hError = INVALID_HANDLE Entonces
            Mensaje("Error al obtener STDERR")
        FinSi

    FinProc

    Proc Finalizar
        CloseHandle(hEntrada)
        CloseHandle(hSalida)
        CloseHandle(hError)
        FreeConsole()
    FinProc

    Sección Privada
        Proc getChar():Byte
            caracter = Espacio(1)
            GetConsoleMode(hEntrada, modo)
            SetConsoleMode(hEntrada, modo and (-1*ENABLE_ECHO_INPUT) and (-1*ENABLE_PROCESSED_INPUT))
            ReadConsole(hEntrada, StrPtr(caracter), 1, 1, 0)
            SetConsoleMode(hEntrada, modo)
            Resultado = ASCII(caracter)
        FinProc

    Sección Pública
        Proc escribir(Referencia txt:Cadena)
            WriteConsole(hSalida, StrPtr(txt), CadLong(txt), textoEscritura, nulo)
        FinProc

        Proc escribirLinea(Referencia txt:Cadena)
            escribir(txt + LF)
        FinProc

        Proc establecerColor(atributos:Entero)
            SetConsoleTextAttribute(hSalida, atributos)
        FinProc

        Proc establecerTitulo(Referencia titulo:Cadena)
            SetConsoleTitle(titulo)
        FinProc

        Proc leer():Cadena
            contador = 0
            texto = ""
            Repetir
                tecla = getChar()
                letra = Carácter(tecla)
                Si (tecla = 8) Entonces
                    Si (contador > 0) Entonces
                        escribir("\x08 \x08")
                        texto = Izquierda(texto, CadLong(texto)-1)
                        contador = contador - 1
                    FinSi
                SiNo
                    Si (tecla <> 13) Entonces
                        escribir(letra)
                        texto = texto + letra
                        contador = contador + 1
                    FinSi
                FinSi
            HastaQue (tecla = 13) or (contador = MAX_PATH)
            escribirLinea("")
            Resultado = texto
        FinProc

        Proc pausarConsola
            escribirLinea("Presione una tecla para continuar . . . ")
            tecla = getChar()
        FinProc

        Proc limpiarConsola
            Var Temp:Entero
            Temp = CreateConsoleScreenBuffer(GENERIC_READ Or GENERIC_WRITE,FILE_SHARE_READ Or FILE_SHARE_WRITE,Nulo,1,0)
            Si (Temp = 0) Entonces Salir
            SetConsoleActiveScreenBuffer(Temp)
            CloseHandle(hSalida)
            hSalida = Temp
        FinProc
        
FinClase

'/**
' * Constantes para la consola
' *
' * @author  Jovani Pérez Damián (@BlackBlex)
' *
' * ==============Information==============
' *      Filename: Constantes.cml
' * ---------------------------------------
'*/

' Consola '
Const STD_OUTPUT_HANDLE = -11
Const STD_INPUT_HANDLE = -10
Const STD_ERROR_HANDLE = -12

' Colores '
Const FOREGROUND_BLUE = &1
Const FOREGROUND_GREEN = &2
Const FOREGROUND_RED = &4
Const FOREGROUND_INTENSITY = &8
Const FOREGROUND_SEARCH = (&10)
Const BACKGROUND_BLUE = &10
Const BACKGROUND_GREEN = &20
Const BACKGROUND_RED = &40
Const BACKGROUND_INTENSITY = &80
Const BACKGROUND_SEARCH = &20

' Console mode flag'
Const ENABLE_ECHO_INPUT = &4
Const ENABLE_PROCESSED_INPUT = &1
Const ENABLE_LINE_INPUT = &2
Const ENABLE_MOUSE_INPUT = &10
Const ENABLE_WINDOW_INPUT = &8
Const ENABLE_PROCESSED_OUTPUT = &1
Const ENABLE_WRAP_AT_EOL_OUTPUT = &2
Const ENABLE_INSERT_MODE = &20
Const ENABLE_QUICK_EDIT_MODE = &40
Const ENABLE_EXTENDED_FLAGS = &80
Const ENABLE_AUTO_POSITION = &100

Importar "Cramel.cml"
Importar "MSVBVM60\MSVBVM60.cml"
Importar "Constantes.cml"
Importar "Consola.cml"

Var texto:Cadena
Var cmd:Consola

Crear cmd

cmd.establecerTitulo("cmd [Cramel]")
cmd.escribirLinea("Hola, como estas?")
texto = cmd.leer()

Si texto = "bien" Entonces
    cmd.escribirLinea("Me alegra")
SiNo
    cmd.escribirLinea("Suena mal, que paso?")
FinSi

cmd.escribirLinea("Como te llamas??")
texto = cmd.leer()

cmd.limpiarConsola()

cmd.escribirLinea("Hola " + texto)

cmd.pausarConsola()

Destruir cmd

Proc Nombre(Parametros):TipoRetorno Exportar "Identificador"

API Nombre(Parametros):TipoRetorno , "miDLL.dll" "Identificador"

"translate_tabs_to_spaces": true

%YAML 1.2
---
file_extensions:
  - cml
scope: source.cml
contexts:
  main:
    # Comentarios
    - match: "'|;"
      scope: punctuation.definition.comment.c
      push: line_comment
    - match: \"
      scope: punctuation.definition.string.begin.c
      push:
        - meta_scope: string.quoted.other.lt-gt.include.c
        - match: \"
          scope: punctuation.definition.string.end.c
          pop: true

    # Palabras de variables
    - match: '\b(Opcional|Referencia|Var|ClaseVar|ClaseVarPriv|Const|Local|Global|Parámetro)\b'
      scope: keyword.control.c

    # Palabras reservadas
    - match: '\b(CDECL|VBCALL|STDCALL|API|Alias|Contar|Seguir|Constructor|Clase|FinClase|Crear|Devolver|Destructor|Destruir|Estruct|Exportar|Escritura|Importar|Lectura|Mientras|FinMientras|NoResultado|Nulo|Prototipo|Proc|FinProc|Preservar|Paso|Prop|FinProp|Repetir|PorSiempre|HastaQue|MientrasQue|FinRepetir|ReDim|Resultado|Referencia|Seleccionar|Caso|Otro|FinSeleccionar|Si|Entonces|OSi|SiNo|FinSi|Salir|Sección Privada|Sección Pública|Unión|AdmErr|Controlar|FinAdmErr)\b'
      scope: keyword.control.c

    #Tipo de datos
    - match: '\b(Booleano|Byte|Word|Entero|Real|Cadena|Nulo)\b'
      scope: storage.type.c

    #Misc
    - match: '\(|\)|\:'
      scope: storage.type.c

    # Numeros
    - match: '\b((-)?[0-9.]+)\b'
      scope: constant.numeric.c
    - match: '\b((0(x|X)[0-9a-fA-F]*(\.[0-9a-fA-F]+p-?\d+)?)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)(L|l|UL|ul|u|U|F|f|ll|LL|ull|ULL)?\b'
      scope: constant.numeric.c

    # Operadores Aritmeticos
    - match: \+|\-|\^|\*|\/|Shl|Shr|Rol|Ror
      scope: keyword.operator.arithmetic.c

    # Operadores Lógicos
    - match: \>|\<|\>\=|\<\=|\<\>|Not|Neg|And|Y|Or|O|Xor|\!\=|\=|\&|\@
      scope: keyword.operator.c

  line_comment:
    - meta_scope: comment.line.example-c
    - match: $
      pop: true

{
    "shell_cmd": "(IF EXIST \"${file_base_name}.exe\" del \"${file_base_name}.exe\") && %Cramel% /f \"${file}\" /d \"${file_path}/${file_base_name}.exe\"",
    "selector": "source.cml",

    "variants": [
        { 
            "name": "Compilar DLL",
            "shell_cmd": "(IF EXIST \"${file_base_name}.dll\" del \"${file_base_name}.dll\") && %Cramel% /f \"${file}\" /dll /d \"${file_path}/${file_base_name}.dll\"",
            "shell": true
        },

        {
            "name": "Compilar & Ejecutar",
            "shell_cmd": "(IF EXIST \"${file_base_name}.exe\" del \"${file_base_name}.exe\") && %Cramel% /f \"${file}\" /d \"${file_path}/${file_base_name}.exe\" /ej",
            "shell": true
        },
       
    ]
}

#include <stdio.h> 

int	 main()
{
  float fahr;
  float celsius;

	//limites de las tablas superior y u inferior 

	float min;
	float max;
	float aumento;

	//letreros de la tabla 
	char temp_celsius[5] = "Cº";
	char temp_fahr[5] = "F";
    
	min = 0.0;
	max = 300.0;
	aumento = 20.0;
							
	printf(" %s\t\t  %s\n", temp_fahr, temp_celsius);
						
	fahr = min;
						
	while (fahr <= max)
	{
		celsius = ((fahr - 32.0) * (5.0/9.0));
		printf("%3.2f\t\t%6.2f\n", fahr, celsius);
		fahr = fahr + aumento;
	}
	return 0;
}