Fecha actual Jue Ago 22, 2019 7:47 pm

Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Tecnología para implementar nuestro propio compilador e intérprete de código C.

Usuarios leyendo este tema: Ninguno

Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Sab Nov 18, 2017 5:01 am

ZIP COMPILER-2017-11-08start.zip

Aparte de escribir el compilador,
necesitamos pensar EXACTAMENTE, y de
forma general, paso a paso, caso por caso
sin faltar nada, cómo quedarán implementadas
las funciones que escribamos para el compilador,
en Ensamblador, y otros códigos de C y C++
para empezar a implementar las funciones
en cuestión del compilador para
echarlo a andar.

Para portear los programas a Windows,
podemos importar con símbolos referenciables
con los nombres de funciones a usar,
por ejemplo "printf" en vez de "printf@MSVCRT.dll",
para hacer todo directamente usable a nivel
de código de Ensamblador.

_______

Lo primero es el esqueleto del programa.
Un simple programa en C, capaz de tomar
algunos parámetros, especialmente
el nombre del archivo principal
a compilar.

Definir la información de versión al inicio
del código:
Código: Seleccionar todo
//Public Domain C/C++ compiler for x86.
//
//ArcheFire C Compiler version x86 2017-11-08start.
//
//This program must be directly compilable
//with Turbo C, Borland C, Open Watcom, GCC,
//and Visual Studio, with any C/C++ compiler
//using the basic standard language features,
//and with itself.
//
/*
//
//
//
//GCC:
gcc c.c -o c.exe
//
//
//
//Open Watcom (Windows):
wcc386 -bt=nt c.c
wcl386 -bt=nt c.obj
//
//
//
//Open Watcom (DOS):
wcc c.c
wcl c.obj
//
//
//
*/
///






Definir un área de cabeceras estándar
de C. Más adelante deberíamos reimplementar
estas cabeceras para nuestro propio compilador
y para cada sistema operativo a usar:
Código: Seleccionar todo
///INIT: Standard C headers used
///INIT: Standard C headers used
///INIT: Standard C headers used
///INIT: Standard C headers used

//printf, fopen
///
 #include <stdio.h>

//getcwd
///
 #include <unistd.h>

//malloc
///
 #include <stdlib.h>

//memset
///
 #include <string.h>

///END:  Standard C headers used
///END:  Standard C headers used
///END:  Standard C headers used
///END:  Standard C headers used





Definir un área estándar de funciones
de nuestro compilador:
Código: Seleccionar todo
///INIT: Function definitions of our compiler
///INIT: Function definitions of our compiler
///INIT: Function definitions of our compiler
///INIT: Function definitions of our compiler



int OPCODE__Application_get_Executable_Path(char **Executable_Path);

FILE * OPCODE__Application_open_Local_ReadOnly_ASCII_7bit_Name_File(char *file_name);

int OPCODE__Compiler_Print_ASCII_7bit_String(char *str);

int OPCODE__Compiler_Version_String_Request(char *cmdlinearg);

void OPCODE__Compiler_Print_Version();

int Main_Compiler();



///END:  Function definitions of our compiler
///END:  Function definitions of our compiler
///END:  Function definitions of our compiler
///END:  Function definitions of our compiler





Definir un área de variables globales:
Código: Seleccionar todo
///INIT: Compiler variables (mostly global for optimizing for easy program-wide data access)
///INIT: Compiler variables (mostly global for optimizing for easy program-wide data access)
///INIT: Compiler variables (mostly global for optimizing for easy program-wide data access)
///INIT: Compiler variables (mostly global for optimizing for easy program-wide data access)



char *Executable_Path=NULL;

char *Main_Source_File_string;
FILE *Main_Source_File;



///END:  Compiler variables (mostly global for optimizing for easy program-wide data access)
///END:  Compiler variables (mostly global for optimizing for easy program-wide data access)
///END:  Compiler variables (mostly global for optimizing for easy program-wide data access)
///END:  Compiler variables (mostly global for optimizing for easy program-wide data access)





C:\COMPILER\C\x86\C.c
C:\COMPILER\C\x86\C.exe
Código: Seleccionar todo
int main(int argc, char *argv[])
{
 //Show the usage if called with no parameters:
 ///
  if(argc<=1)
  {
   printf("Usage: c main_c_cpp_file\n");

   return 1;
  }


 return 0;
}


//EOF
Adjuntos
COMPILER.zip
2018-01-08 3:36 PM
(43.97 KiB) 57 veces
hello.c
(75 Bytes) 44 veces
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Piezas de Código del Compilador de C/C++ de ArcheFire (Archivos de Cabecera de Librería C) (v2017-11-08start)

Notapor ~ » Sab Nov 18, 2017 3:40 pm

Código: Seleccionar todo
//printf, fopen
///
 #include <stdio.h>

//getcwd
///
 #include <unistd.h>

//malloc
///
 #include <stdlib.h>

//memset
///
 #include <string.h>

Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start) (Función Principal del Motor del Compilador)

Notapor ~ » Sab Nov 18, 2017 4:09 pm

Necesitamos definir una función principal
para limpiar la estructura del programa
del compilador del código de main()
y usar de forma transparente los parámetros
de línea de comandos. Eso hará que
el programa sea mucho más porteable
fuera de un programa de C con una
función main() a cualquier otro entorno,
y lo mismo al usar las funciones de librería
únicamente desde funciones de interfaz wrapper,
que siempre podremos mantener idénticas desde la
primera hasta la última versión, cambiando internamente
las llamadas a cualesquiera funciones de librería
o de sistema según necesitemos:
Código: Seleccionar todo
///INIT: Function definitions of our compiler
///INIT: Function definitions of our compiler
///INIT: Function definitions of our compiler
///INIT: Function definitions of our compiler



int Main_Compiler();



///END:  Function definitions of our compiler
///END:  Function definitions of our compiler
///END:  Function definitions of our compiler
///END:  Function definitions of our compiler



///INIT: Compiler variables (mostly global for optimizing for easy program-wide data access)
///INIT: Compiler variables (mostly global for optimizing for easy program-wide data access)
///INIT: Compiler variables (mostly global for optimizing for easy program-wide data access)
///INIT: Compiler variables (mostly global for optimizing for easy program-wide data access)



char *Executable_Path=NULL;

char *Main_Source_File_string;
FILE *Main_Source_File;



///END:  Compiler variables (mostly global for optimizing for easy program-wide data access)
///END:  Compiler variables (mostly global for optimizing for easy program-wide data access)
///END:  Compiler variables (mostly global for optimizing for easy program-wide data access)
///END:  Compiler variables (mostly global for optimizing for easy program-wide data access)



Desde main(), necesitamos copiar
el nombre del archivo de código
especificado a una variable
de puntero global de cadena.
Código: Seleccionar todo
 //Copy the pointer to the main C/C++
 //source code file to a global variable:
 ///
  Main_Source_File_string=argv[1];




Después de eso y de otras posibles inicializaciones
futuras, debemos llamar la función principal del
compilador, desde main():
Código: Seleccionar todo
 //Call the actual main compiler function here:
 ///
  Main_Compiler();



Código: Seleccionar todo
int main(int argc, char *argv[])
{
 //Show the usage if called with no parameters:
 ///
  if(argc<=1)
  {
   OPCODE__Compiler_Print_ASCII_7bit_String("Usage: c main_c_cpp_file\n");

   return 1;
  }



 //Copy the pointer to the main C/C++
 //source code file to a global variable:
 ///
  Main_Source_File_string=argv[1];



 //Call the actual main compiler function here:
 ///
  Main_Compiler();



 return 0;
}






Lo primero que necesitamos hacer
en la función principal del compilador
es obtener la ruta actual del compilador.
Esto también nos permitirá encontrar
el archivo de configuración para ese
compilador, que debería estar en el mismo
directorio, junto con este.

En esta función para obtener la ruta
de directorio a nuestro compilador usamos
un doble puntero (doble indirección)
en el parámetro de cadena de caracteres,
para poder modificar la variable. Aquí
el primer nivel del puntero contiene
la dirección de la variable, y el
segundo nivel contiene el valor de
la variable de puntero, externa
a la función:
Código: Seleccionar todo
int OPCODE__Application_get_Executable_Path(char **Executable_Path)
{
 //Pass a NULL to the first parameter of
 //getcwd to make it to automatically
 //perform a malloc(int) for the full
 //directory string (excluding the file name):
 ///
  *Executable_Path = getcwd((char *)NULL, 4096);
  if(*Executable_Path == NULL)
  {
   *Executable_Path=NULL;
   return 0; //FALSE -- failure
  }



 return 1; //TRUE == success
}



Después de obtener la ruta principal,
trataremos de abrir el archivo de código
fuente especificado:
Código: Seleccionar todo
FILE * OPCODE__Application_open_Local_ReadOnly_ASCII_7bit_Name_File(char *file_name)
{
 return fopen(file_name,"rb");
}





Código: Seleccionar todo
int Main_Compiler()
{
 /*
 Global variables used in this function:
 -----------------------------------------

 char *Executable_Path=NULL;

 char *Main_Source_File_string;
 FILE *Main_Source_File;



 */

 if(OPCODE__Compiler_Version_String_Request(Main_Source_File_string))
 {
  OPCODE__Compiler_Print_Version();
  return 0;
 }



 OPCODE__Application_get_Executable_Path(&Executable_Path);
 if(Executable_Path == NULL)
 {
  OPCODE__Compiler_Print_ASCII_7bit_String("Error getting the current path to this compiler.\n");
  return 1;
 }



 Main_Source_File=OPCODE__Application_open_Local_ReadOnly_ASCII_7bit_Name_File(Main_Source_File_string);
 if(Main_Source_File==NULL)
 {
  OPCODE__Compiler_Print_ASCII_7bit_String("Error opening the specified source file.\n");
  return 0; //FALSE -- failure
 }

 //.Main_Compiler_getSourceFileSize



 return 1; //TRUE -- success
}

Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start) (Información de Versión)

Notapor ~ » Sab Nov 18, 2017 5:36 pm

Tenemos 2 funciones para saber
si el usuario está pidiendo que
imprimamos la versión del compilador.
La primera es para comparar la cadena
"--version" para saber si quieren
saber la versión, y la segunda imprime
la información de la versión en pantalla.

Al inicio del código, antes del cuerpo
de las funciones (agregar al área de definiciones
de cabeceras de funciones):
Código: Seleccionar todo
///INIT: Function definitions of our compiler
///INIT: Function definitions of our compiler
///INIT: Function definitions of our compiler
///INIT: Function definitions of our compiler



int OPCODE__Compiler_Version_String_Request(char *cmdlinearg);

void OPCODE__Compiler_Print_Version();

int Main_Compiler();



///END:  Function definitions of our compiler
///END:  Function definitions of our compiler
///END:  Function definitions of our compiler
///END:  Function definitions of our compiler





Después de main():
Código: Seleccionar todo
int OPCODE__Compiler_Version_String_Request(char *cmdlinearg)
{
 if(strncmp(cmdlinearg, "--version", 9)==0)return 1;
 return 0;
}







void OPCODE__Compiler_Print_Version()
{
 OPCODE__Compiler_Print_ASCII_7bit_String("Generic C/C++ compiler, version 2017-11-08start\n");
}





Justo al principio de la función Main_Compiler,
necesitamos llamar a las funciones para ver
si nos están pidiendo la cadena de versión.
Debemos hacer eso ahí porque si ese es el caso,
solo imprimimos la cadena y terminamos el programa,
justo antes de hacer más que eso:
Código: Seleccionar todo
 if(OPCODE__Compiler_Version_String_Request(Main_Source_File_string))
 {
  OPCODE__Compiler_Print_Version();
  return 0;
 }

Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start) (Obtener el Tamaño del Archivo de Código Principal)

Notapor ~ » Dom Nov 19, 2017 8:02 am

Detectar el tamaño del archivo de código especificado.

Necesitamos agregarle el siguiente código
a la función Main_Compiler, justo
después de verificar que pudimos abrir
el archivo de código especificado
(en la marca de //.Main_Compiler_getSourceFileSize)
y reemplazarla por el código a continuación
(o agregarle un espacio o información de
versión en // .Main_Compiler_getSourceFileSize):
Código: Seleccionar todo
 // .Main_Compiler_getSourceFileSize

 Main_Source_File_Size=OPCODE__Application_get_Opened_File_Size(Main_Source_File);



Código: Seleccionar todo
long OPCODE__Application_get_Opened_File_Size(FILE *filehandle)
{
 long sz;
 fseek(filehandle, 0L, SEEK_END);
 sz=ftell(filehandle);
 rewind(filehandle);
 return sz;
}




Agregar la siguiente línea extra en la sección
de definiciones de cabeceras de funciones:
Código: Seleccionar todo
///INIT: Function definitions of our compiler
///INIT: Function definitions of our compiler
///INIT: Function definitions of our compiler
///INIT: Function definitions of our compiler



long OPCODE__Application_get_Opened_File_Size(FILE *filehandle);



///END:  Function definitions of our compiler
///END:  Function definitions of our compiler
///END:  Function definitions of our compiler
///END:  Function definitions of our compiler





Agregar la nueva variable global para guardar
el tamaño del archivo de código principal:
Código: Seleccionar todo
///INIT: Compiler variables (mostly global for optimizing for easy program-wide data access)
///INIT: Compiler variables (mostly global for optimizing for easy program-wide data access)
///INIT: Compiler variables (mostly global for optimizing for easy program-wide data access)
///INIT: Compiler variables (mostly global for optimizing for easy program-wide data access)



long Main_Source_File_Size;



///END:  Compiler variables (mostly global for optimizing for easy program-wide data access)
///END:  Compiler variables (mostly global for optimizing for easy program-wide data access)
///END:  Compiler variables (mostly global for optimizing for easy program-wide data access)
///END:  Compiler variables (mostly global for optimizing for easy program-wide data access)

Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Mar Nov 21, 2017 10:40 am

Agregar funciones para delimitar y contar las líneas en un archivo de código fuente en modo binario.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Vie Nov 24, 2017 10:50 pm

Tenemos las siguentes funciones para
buscar los diferentes tipos de nueva línea.
Estas leen un solo carácter pero eso es
demasiado lento, se tarda varios segundos
si un archivo tiene varios kilobytes.

También necesitamos agregar funciones
para detectar el final efectivo de cada
línea individual aunque no haya ninguna
nueva línea.

Tenemos que hacer que estas funciones
lean 4 Kilobytes a la vez pero que solo
avancen 2 cada vez que el búfer se acabe.
Esto hará que podamos encontrar cosas
que van más allá de límite de un búfer,
aunque si es algo más grande en varios
búferes, fallará y necesitaremos más
arreglos, pero esta función será una
buena mejora para correr a toda velocidad:
Código: Seleccionar todo
//OPCODE__Compiler_BinarySourceFile_find_Nearest_CR --
//    Find the nearest carry return character (byte 0x0D).
//
///
long OPCODE__Compiler_BinarySourceFile_find_Nearest_CR(FILE *src)
{
//Description.
//
//This function parses the specified binary-mode file
//byte by byte from its current position (specified
//by its file handle) looking for the nearest byte with value 0x0D.
//
//This function is normally only used internally by
//the C/C++ language compiler to detect the nearest
//variation of possible newlines.
//
//
//
//Parameters.
//
//FILE *src
//   source code text file to be parsed searching for the
//   nearest 0x0D byte offset.
//
//
//
//Return value.
//
//long
//   Returns the offset of the nearest
//   8-bit byte with value 0x0D or 1
//   byte beyond the end of the text contents
//   (to return the offset of EOF instead
//   of the offset of a non-existent 0x0D byte).
//
///
 char char0, char1;

 while(!OPCODE__Application__is_EOF(src))
 {
  OPCODE__Application_read_C_unsigned_char_byte_BinaryFile(src, &char0);
  OPCODE__Application_read_C_unsigned_char_byte_BinaryFile(src, &char1);
  if(char0==0x0D && char1!=0x0A)
  {
   return OPCODE__Application_get_File_Position(src)-2; //Mark end of line just before CRLF
  }

  if(OPCODE__Application_get_File_Position(src)==EOF_offset)return OPCODE__Application_get_File_Position(src)+1;
 }

 return OPCODE__Application_get_File_Position(src);
}




long OPCODE__Compiler_BinarySourceFile_find_Nearest_LF(FILE *src)
{
 char char0;

 while(!OPCODE__Application__is_EOF(src)) //Mark end of line just before LF
 {
  OPCODE__Application_read_C_unsigned_char_byte_BinaryFile(src, &char0);
  if(char0==0x0A)
  {
   return OPCODE__Application_get_File_Position(src)-1;
  }

  if(OPCODE__Application_get_File_Position(src)==EOF_offset)return OPCODE__Application_get_File_Position(src)+1;
 }

 return OPCODE__Application_get_File_Position(src);
}




long OPCODE__Compiler_BinarySourceFile_find_Nearest_CR_LF(FILE *src)
{
 char char0, char1;

 while(!OPCODE__Application__is_EOF(src))
 {
  OPCODE__Application_read_C_unsigned_char_byte_BinaryFile(src, &char0);
  OPCODE__Application_read_C_unsigned_char_byte_BinaryFile(src, &char1);
  if(char0==0x0D && char1==0x0A)
  {
   return OPCODE__Application_get_File_Position(src)-2; //Mark end of line just before CRLF
  }

  //If we didn't find CRLF, move file pointer back
  //1 byte:
  ///
  if(!OPCODE__Application_move_File_Position(src, OPCODE__Application_get_File_Position(src)-1))
  {
   return -1;
  }

  if(OPCODE__Application_get_File_Position(src)==EOF_offset)return OPCODE__Application_get_File_Position(src)+1;
 }

 return OPCODE__Application_get_File_Position(src);
}

Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Mar Nov 28, 2017 9:22 am

Función unificada rápida con lectura en búfer de 4 Kilobytes para delimitar las líneas.

Al fin de cuentas implementé esta función que es más rápida que leer los archivos carácter por carácter y que es capaz de reconocer todos los tipos de nuevas líneas, CR, CRLF y LF:
Código: Seleccionar todo
long OPCODE__Compiler_BinarySourceFile_find_Nearest_NewlineMarkers(FILE *src)
{
 /*
 Global variables used:

 long linecount=0;


//General use variables:
///
 unsigned char *COMPIER__fileBuf0000=NULL;
 long           COMPIER__fileBuf0000_logical_file_offset=0;
 long           COMPIER__fileBuf0000_file_buffer_offset=0;
 long           COMPIER__fileBuf0000_charbuflen=0;
 long           COMPIER__fileBuf0000origfilepos1=0;
 long           COMPIER__fileBuf0000_bufferOverrun=0;


 */

 char char0, char1;
 long linestart=0,lineend=0;

 /*
 Global variables used here:

 //Per-source-file compilation data files:
 ///
  FILE *lines_dat;


  unsigned long linecount;
 */

 long lines_dat_pos=0;
 long lineelement_offset=4;
 long Main_Source_File_position=0;
 long tmpstartMain_Source_File_position=0;
 long off0=0;
 long off1=0;



 COMPIER__fileBuf0000_logical_file_offset=0;
 COMPIER__fileBuf0000_file_buffer_offset=0;
 COMPIER__fileBuf0000_charbuflen=0;
 COMPIER__fileBuf0000_origfilepos0=0;
 COMPIER__fileBuf0000_bufferOverrun=0;


 linecount=0;


 //Write the first line count at the start of lines.dat
 //and then go to the offset where we will record line
 //starts/ends:
 ///
 OPCODE__Application_move_File_Position(lines_dat,lineelement_offset);
 if(!OPCODE__Application_write_C_long_BinaryFile(lines_dat, linecount))
 {
  rewind(src);
  return -1;
 }

 OPCODE__Application_move_File_Position(lines_dat,lineelement_offset);





 //Go to the start of the file
 //to parse the whole file at once.
 //This function is thought for speed
 //by avoiding re-reading big buffers
 //every time we return for finding
 //
 ///
  rewind(src);



 //Get the current file offset and put it
 //as the logical file offset. In turn,
 //the file buffer offset will always go
 //from 0-4095 unless the remaining file chunk
 //is smaller:
 ///
  COMPIER__fileBuf0000_logical_file_offset=OPCODE__Application_get_File_Position(src);
  COMPIER__fileBuf0000_origfilepos0=COMPIER__fileBuf0000_logical_file_offset;


 //As soon as we go beyond the end file buffer offset
 //(>4095) we need to read the file 2048 byts beyond
 //and reload the buffer by reading more 4096 bytes.
 ///


  //Mark start of line at current position:
  ///
   OPCODE__Application_write_C_long_BinaryFile(lines_dat, COMPIER__fileBuf0000_logical_file_offset);




 while(!OPCODE__Application__is_EOF(src))
 {
  //Go back into the file 2048 bytes
  //and then read another 4096 bytes
  //to find any inter-sector/inter-buffer
  //CRLF, CR at the last byte of the current
  //buffer, and LF at the first byte of the
  //next buffer. This is only usable when
  //we know that the string to test has a fixed
  //known size and that it fits in less than
  //1 single fuffer:
  ///
   if(COMPIER__fileBuf0000_logical_file_offset>0)
   COMPIER__fileBuf0000_logical_file_offset--;
   if(!OPCODE__Application_move_File_Position(src, COMPIER__fileBuf0000_logical_file_offset))
   {
    free(COMPIER__fileBuf0000);
    rewind(src);
    return -1;
   }



 //Read 4096 bytes of text to search for CRLF, LF or CR newlines.
 //We will save the actual size of the string read:
 ///
  COMPIER__fileBuf0000_charbuflen=OPCODE__Application_read_C_unsigned_char_buffer_BinaryFile(src, &COMPIER__fileBuf0000, 4096);

  COMPIER__fileBuf0000_file_buffer_offset=0;



 if(COMPIER__fileBuf0000_charbuflen>0)
 while(COMPIER__fileBuf0000_file_buffer_offset<COMPIER__fileBuf0000_charbuflen)
 {
  char0=COMPIER__fileBuf0000[COMPIER__fileBuf0000_file_buffer_offset];
  char1=0;
  if((COMPIER__fileBuf0000_file_buffer_offset+1)<COMPIER__fileBuf0000_charbuflen)
  char1=COMPIER__fileBuf0000[COMPIER__fileBuf0000_file_buffer_offset+1];
  else COMPIER__fileBuf0000_bufferOverrun=1;

  COMPIER__fileBuf0000_newlineMarkerSZ=0;
  if(char0==0x0D && char1==0x0A)
  {
   COMPIER__fileBuf0000_newlineMarkerSZ=2;
  }

  else if(char0==0x0A)
  {
   COMPIER__fileBuf0000_newlineMarkerSZ=1;
  }

  else if(COMPIER__fileBuf0000_bufferOverrun==0 && (char0==0x0D && char1!=0x0A))
  {
   COMPIER__fileBuf0000_newlineMarkerSZ=1;
  }

  COMPIER__fileBuf0000_logical_file_offset+=COMPIER__fileBuf0000_newlineMarkerSZ;
  COMPIER__fileBuf0000_file_buffer_offset+=COMPIER__fileBuf0000_newlineMarkerSZ;

  //If there was no newline marker at this byte offset,
  //we must advance the buffer offset by 1:
  ///
   if(COMPIER__fileBuf0000_newlineMarkerSZ==0)
   {
    COMPIER__fileBuf0000_file_buffer_offset++;
    COMPIER__fileBuf0000_logical_file_offset++;
   }
    else
   {
     linecount++;

     //Mark end of line at current position:
     ///
      OPCODE__Application_write_C_long_BinaryFile(lines_dat, COMPIER__fileBuf0000_logical_file_offset-COMPIER__fileBuf0000_newlineMarkerSZ);



     //Mark start of line at current position:
     ///
      OPCODE__Application_write_C_long_BinaryFile(lines_dat, COMPIER__fileBuf0000_logical_file_offset);
   }




  if(COMPIER__fileBuf0000_logical_file_offset==EOF_offset)
  {
   if(!OPCODE__Application_move_File_Position(src, COMPIER__fileBuf0000_logical_file_offset+1))
   {
    free(COMPIER__fileBuf0000);
    rewind(src);
    return -1;
   }

   //Mark end of line at current position:
   ///
    OPCODE__Application_write_C_long_BinaryFile(lines_dat, COMPIER__fileBuf0000_logical_file_offset+1);



   linecount++;



   //Update line count:
   ///
    OPCODE__Application_move_File_Position(lines_dat, 0);
    OPCODE__Application_write_C_long_BinaryFile(lines_dat, linecount);



    rewind(src);
   return OPCODE__Application_get_File_Position(src)+1;
  }
 };


   COMPIER__fileBuf0000_bufferOverrun=0;
   free(COMPIER__fileBuf0000);

 }



    rewind(src);
 return -1;
}





También la función wrapper para delimitar las líneas:
Código: Seleccionar todo
//OPCODE__Compiler_define_ASCII_text_lines --
//    Saves the line count of a text file and
//    start/end offsets of each line up to
//    the nearest newline character start offset,
//    into the file pointed to by the lines_dat
//    file handle.
//
///
int OPCODE__Compiler_define_ASCII_text_lines(FILE *srcfilehandle)
{
//Description.
//
//This function takes a file handle and parses it
//byte by byte from its current position (specified
//by its file handle), setting up an initial 32-bit
//line count at offset 0, then a 32-bit initial
//start line offset at srcfilehandle's file offset 4.
//It then searches the nearest newline mark or the
//end of file, and records it, which will produce
//the length of the line when subtracting the
//end offset minus the start offset of the line,
//which will allow to extract each individual line
//without taking into account any newline characters.
//
//This function is normally used every time
//we want to load a current source file for analysis.
//One of the first things performed will be to count
//and delimit the start/end offsets of every line
//in that source file.
//
//
//
//Parameters.
//
//FILE *srcfilehandle
//   Source code text file to be parsed to count
//   the text lines inside it and to record
//   the start/end offsets of each line.
//
//
//
//Return value.
//
//int
//   Returns 1 (TRUE) on success
//   or 0 (FALSE) if there was any error
//   reading the source file or writing
//   the data file containing the line offset data.
//
///


 /*
 Global variables used here:

 //Per-source-file compilation data files:
 ///
  FILE *lines_dat;


  unsigned long linecount;
 */

 long lines_dat_pos=0;
 long lineelement_offset=4;
 long Main_Source_File_position=0;
 long tmpstartMain_Source_File_position=0;
 long off0=0;
 long off1=0;



 if(!OPCODE__Application_move_File_Position(srcfilehandle, 0))
 {
  return 0;
 }



 OPCODE__Application_move_File_Position(lines_dat,lineelement_offset);
 if(!OPCODE__Application_write_C_long_BinaryFile(lines_dat, linecount))
 {
  return 0;
 }

 OPCODE__Application_move_File_Position(lines_dat,lineelement_offset);



 if(!OPCODE__Compiler_BinarySourceFile_find_Nearest_NewlineMarkers(Main_Source_File))
 {
  return 0;
 }



 return 1;
}





Otro wrapper para cargar el archivo actual de código de forma más global y general:
Código: Seleccionar todo
int OPCODE__Compiler_Load_ASCII_Text_File(FILE *filehandle)
{
 /*
 Global variables used here:

 //Global compilation data files:
 ///
  FILE *includes_dat;
  FILE *function_dat;
  FILE *vars_dat;
  FILE *datatype_dat;
  FILE *strings_dat;
  FILE *expr_dat;
  FILE *comments_dat;
  FILE *pre_dat;
  FILE *lines_dat;

 */



 lines_dat=OPCODE__Application_open_Local_ReadWrite_ASCII_7bit_Name_BinaryFile("_build_/lines.dat");
 if(lines_dat==NULL)return 0;


 OPCODE__Compiler_define_ASCII_text_lines(lines_dat);


 return 1;
}





Después actualicé la función principal para llamar esta función:
Código: Seleccionar todo
int Main_Compiler()
{
 /*
 Global variables used in this function:
 -----------------------------------------

 char *Executable_Path=NULL;

 char *Main_Source_File_string;
 FILE *Main_Source_File;
 long Main_Source_File_Size;



 */

 long lines=0;


 if(OPCODE__Compiler_is_Version_String_Request(Main_Source_File_string))
 {
  OPCODE__Compiler_Print_Version_to_Screen();
  return 0;
 }



 OPCODE__Application_get_Executable_Path(&Executable_Path);
 if(Executable_Path == NULL)
 {
  OPCODE__Compiler_Println_ASCII_7bit_String("Error getting the current path to this compiler.");
  return 1;
 }



 Main_Source_File=OPCODE__Application_open_Local_ReadOnly_ASCII_7bit_Name_BinaryFile(Main_Source_File_string);
 if(Main_Source_File==NULL)
 {
  OPCODE__Compiler_Println_ASCII_7bit_String("Error opening the specified source file.");
  return 0; //FALSE -- failure
 }


 //.Main_Compiler_getSourceFileSize 2017-11-19-08:21
 Main_Source_File_Size=OPCODE__Application_get_Opened_File_Size(Main_Source_File);
 EOF_offset=Main_Source_File_Size-1;



 if(Main_Source_File_Size<=0)
 {
  OPCODE__Compiler_Println_ASCII_7bit_String("The file is empty. Terminating.");
  return 0; //FALSE -- failure
 }



 if(!OPCODE__Compiler_Create_build_Directory("_build_"))
 {
  OPCODE__Compiler_Println_ASCII_7bit_String("Error setting up compilation _build_ directory. Terminating.");
  return 0; //FALSE -- failure
 }





 OPCODE__Compiler_Load_ASCII_Text_File(Main_Source_File);
//printf("rrrrrrrrr %d\n",linecount);


// do
// {
//  OPCODE__Compiler_BinarySourceFile_ASCII_8bit_readline(Main_Source_File, lines);
//  printf("%s\n", COMPILER__currentASCII_8bit_LineString);
// }
// while(lines++ < linecount);






 return 1; //TRUE -- success
}

Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Mar Nov 28, 2017 9:41 am

Escribir una función capaz de registrar cada elemento de código en secuencia.


Los offsets de inicio de línea y el
de final de línea también son elementos
de código que nos ayudarán a saber dónde
empieza una instrucción y así darle el
significado correspondiente a caracteres que
significan diferentes cosas.

Necesitaremos una función capaz de encontrar
los finales de instrucción correspondientes
como caracteres ; o , y así saber si una línea
es demasiado grande, pudiendo leerla poco a poco
en todo caso.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Vie Dic 01, 2017 6:22 pm

Agregar variables para registrar la línea más larga, el número de línea y el archivo con la línea más larga.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Vie Dic 08, 2017 7:04 pm

Agregar función para desplazarnos y devolver
la posición de byte en el archivo a cambio de
la línea y columna:
Código: Seleccionar todo
//OPCODE__Compiler_BinarySourceFile_ASCII_8bit_goto_line_char --
//
///
long OPCODE__Compiler_BinarySourceFile_ASCII_8bit_goto_line_char(FILE *src, unsigned long linenumber, unsigned long charpos)
{
//Description.
//
//
//
//
//Parameters.
//
//FILE *src
//   Source code text file to read lines from.
//
//unsigned long linenumber
//   Line number we want to read from.
//
//unsigned long charpos
//
//
//
//Return value.
//
//long
//
///


 /*
 Global variables used here:

 //Global compilation data files:
 ///
  FILE *lines_dat;

 */



 long stringstart = 0;
 long stringend   = 0;
 long stringsize  = 0;


 //If we are asked line 0 or a negative line,
 //return 0 to indicate an empty string
 //(relaxed as in PHP or JavaScript):
 ///
  if(linenumber==0)return OPCODE__Application_get_File_Position(src);
  if(charpos==0)return OPCODE__Application_get_File_Position(src);



 //Read the first DWORD of lines_dat at offset 0
 //to see how many lines there are.
 ///
  //It's anlready loaded in linecount while the current
  //source file is loaded.


 //Move the lines.dat file pointer
 //at offset sizeof(long)+linenumber*(sizeof(long)*2)
 //to get the low level start and end offset for the line:
 ///
  OPCODE__Application_move_File_Position(lines_dat, sizeof(unsigned long)+ ((linenumber-1)*(sizeof(unsigned long)*2)) );


 //Get the size of the string by reading the first
 //long at this position and the second long.
 //Then do second_long-first_long. If the size is 0,
 //we will just return a zero-length ASCIIZ string.
 ///
  if(!OPCODE__Application_read_C_long_BinaryFile(lines_dat, &stringstart))return OPCODE__Application_get_File_Position(src);
  if(!OPCODE__Application_read_C_long_BinaryFile(lines_dat, &stringend))return OPCODE__Application_get_File_Position(src);
  stringsize=stringend-stringstart;


  //If we are asked a column/character position
  //beyond the line limits, ensure to generate
  //an empty string:
  ///
   if((stringstart+(charpos-1))>=stringend)
   {
    charpos=1;
   }


 //Move the file pointer to the specified byte offset:
 ///
  OPCODE__Application_move_File_Position(src, stringstart+(charpos-1));


 return OPCODE__Application_get_File_Position(src);
}



Necesito una función para obtener el número de línea
y de columna a cambio de un offset de archivo.

Creo que voy a usar offsets crudos y avances de solo
unos 16 bytes a la vez aunque todavía tengo que
optimizar para no leer tan poco que la lectura se
vuelva lenta, como mínimo necesito leer 512 bytes
o usar el buffer de 4096 bytes, pero escanear solo
de 16 en 16 en memoria, o técnicas similares, por
ejemplo para buscar los finales de instrucciones.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Dom Dic 10, 2017 2:22 pm

Levantar el Codigo del Bucle que Recorre el Código Entero
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Dom Dic 10, 2017 3:01 pm

Podemos poner este código justo
después de la llamada de definir las
líneas en el código, para ver el
tamaño y la posición en el archivo del
inicio o final de cada línea.

Con estas funciones tenemos la ventaja
de poder saber cuántas líneas hay en el
archivo actual de código, en qué offset
en el archivo empieza y termina cada línea,
y qué tamaño tiene cada línea desde el
principio o desde cualquier posición en la
línea, y así podemos ubicarnos más fácilmente
de forma aleatoria y con piezas moderadas en
memoria en el código. Estamos tratando de hacer
que el compilador sea capaz potencialmente de
reconocer identificadores de tamaño infinito.
Eso nos dará enorme robusteza sobre todo para
manenar cadenas de caracteres, búferes binarios
y arreglos, así que es algo que probablemente
deberíamos hacer paso a paso desde el principio
aunque se tarde.
Código: Seleccionar todo
 //Define/count current source file lines:
 ///
  OPCODE__Compiler_Load_ASCII_Text_File(Main_Source_File);


while(lines<=linecount)
{
 printf("Line No. %ld: %lX (%ld bytes)\n",lines, OPCODE__Compiler_BinarySourceFile_ASCII_8bit_goto_line_char(Main_Source_File, lines, 1048576), OPCODE__Compiler_BinarySourceFile_ASCII_8bit_getLength_line_char(lines, 1));
 lines++;
}




Este código depende de que primero hagamos el trabajo de definir las líneas presentes en el archivo con posición inicial, final, contar el número de líneas, guardar la longitud de la línea más larga y poder obtener el tamaño de cada línea.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Dom Dic 10, 2017 6:30 pm

Escribir una función capaz de comparar una cadena de una longitud cualquiera entre 2 archivos.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Mar Dic 12, 2017 1:30 pm

Agregar funciones que alteren y preserven por sí mismas la posición de archivo para diferentes datos.

Código: Seleccionar todo
int OPCODE__Application_write_C_long_BinaryFile_Position(FILE *srcfilehandle, long longvalue, unsigned long filepos);
int OPCODE__Application_write_C_long_BinaryFile_PositionPreserve(FILE *srcfilehandle, long longvalue, unsigned long filepos);




Extender las funciones de definición y obtención de metadatos de líneas para que pueda usar cualquier archivo en vez de lines.dat.

Código: Seleccionar todo
int OPCODE__Compiler_define_ASCII_text_lines(FILE *srcfilehandle)
long OPCODE__Compiler_BinarySourceFile_find_Nearest_NewlineMarkers(FILE *src)
long OPCODE__Compiler_BinarySourceFile_ASCII_8bit_readline(FILE *src, unsigned long linenumber)
long OPCODE__Compiler_BinarySourceFile_ASCII_8bit_readline_char_size(FILE *src, unsigned long linenumber, unsigned long charpos, unsigned long size)
long OPCODE__Compiler_BinarySourceFile_ASCII_8bit_goto_line_char(FILE *src, unsigned long linenumber, unsigned long charpos)
long OPCODE__Compiler_BinarySourceFile_ASCII_8bit_getLength_line_char(unsigned long linenumber, unsigned long charpos)


Código: Seleccionar todo
//OPCODE__Compiler_define_ASCII_text_lines --
//    Saves the line count of a text file and
//    start/end offsets of each line up to
//    the nearest newline character start offset,
//    into the file pointed to by the lines_dat
//    file handle.
//
///
int OPCODE__Compiler_define_ASCII_text_lines(FILE *srcfilehandle)
{
//Description.
//
//This function takes a file handle and parses it
//byte by byte from its current position (specified
//by its file handle), setting up an initial 32-bit
//line count at offset 0, then a 32-bit initial
//start line offset at srcfilehandle's file offset 4.
//It then searches the nearest newline mark or the
//end of file, and records it, which will produce
//the length of the line when subtracting the
//end offset minus the start offset of the line,
//which will allow to extract each individual line
//without taking into account any newline characters.
//
//This function is normally used every time
//we want to load a current source file for analysis.
//One of the first things performed will be to count
//and delimit the start/end offsets of every line
//in that source file.
//
//
//
//Parameters.
//
//FILE *srcfilehandle
//   Source code text file to be parsed to count
//   the text lines inside it and to record
//   the start/end offsets of each line.
//
//
//
//Return value.
//
//int
//   Returns 1 (TRUE) on success
//   or 0 (FALSE) if there was any error
//   reading the source file or writing
//   the data file containing the line offset data.
//
///


 /*
 Global variables used here:

 //Per-source-file compilation data files:
 ///
  FILE *lines_dat;


  unsigned long linecount;
 */

 long lines_dat_pos=0;
 long lineelement_offset=4;
 long Main_Source_File_position=0;
 long tmpstartMain_Source_File_position=0;
 long off0=0;
 long off1=0;



 if(!OPCODE__Application_move_File_Position(srcfilehandle, 0))
 {
  return 0;
 }



 OPCODE__Application_move_File_Position(lines_dat,lineelement_offset);
 if(!OPCODE__Application_write_C_long_BinaryFile(lines_dat, linecount))
 {
  return 0;
 }

 OPCODE__Application_move_File_Position(lines_dat,lineelement_offset);



 if(!OPCODE__Compiler_BinarySourceFile_find_Nearest_NewlineMarkers(Main_Source_File))
 {
  return 0;
 }



 return 1;
}



int OPCODE__Application_move_File_Position(FILE *srcfilehandle, long newabspos)
{
 if(fseek(srcfilehandle, newabspos, SEEK_SET)==0)return 1;
 return 0;
}



long OPCODE__Application_get_File_Position(FILE *srcfilehandle)
{
 return ftell(srcfilehandle); //If this returns -1, there was an error.
}



int OPCODE__Application_read_C_long_BinaryFile(FILE *srcfilehandle, long *longvalue)
{
 if(fread(longvalue, sizeof(long), 1, srcfilehandle)==1)return 1; //If this returns !=1, there was an error.
 return 0;
}



long OPCODE__Compiler_BinarySourceFile_find_Nearest_NewlineMarkers(FILE *src)
{
 /*
 Global variables used:

 long linecount=0;


//General use variables:
///
 unsigned char *COMPIER__fileBuf0000=NULL;
 long           COMPIER__fileBuf0000_logical_file_offset=0;
 long           COMPIER__fileBuf0000_file_buffer_offset=0;
 long           COMPIER__fileBuf0000_charbuflen=0;
 long           COMPIER__fileBuf0000origfilepos1=0;
 long           COMPIER__fileBuf0000_bufferOverrun=0;


 */

 char char0, char1;
 long tmplinestart=0,tmplineend=0,tmplinelength=0;

 /*
 Global variables used here:

 //Per-source-file compilation data files:
 ///
  FILE *lines_dat;


  unsigned long linecount;
 */

 long lines_dat_pos=0;
 long lineelement_offset=4;
 long Main_Source_File_position=0;
 long tmpstartMain_Source_File_position=0;
 long off0=0;
 long off1=0;



 COMPIER__fileBuf0000_logical_file_offset=0;
 COMPIER__fileBuf0000_file_buffer_offset=0;
 COMPIER__fileBuf0000_charbuflen=0;
 COMPIER__fileBuf0000_origfilepos0=0;
 COMPIER__fileBuf0000_bufferOverrun=0;


 linecount=0;


 //Write the first line count at the start of lines.dat
 //and then go to the offset where we will record line
 //starts/ends:
 ///
 OPCODE__Application_move_File_Position(lines_dat,lineelement_offset);
 if(!OPCODE__Application_write_C_long_BinaryFile(lines_dat, linecount))
 {
  rewind(src);
  return -1;
 }

 OPCODE__Application_move_File_Position(lines_dat,lineelement_offset);





 //Go to the start of the file
 //to parse the whole file at once.
 //This function is thought for speed
 //by avoiding re-reading big buffers
 //every time we return for finding
 //
 ///
  rewind(src);



 //Get the current file offset and put it
 //as the logical file offset. In turn,
 //the file buffer offset will always go
 //from 0-4095 unless the remaining file chunk
 //is smaller:
 ///
  COMPIER__fileBuf0000_logical_file_offset=OPCODE__Application_get_File_Position(src);
  COMPIER__fileBuf0000_origfilepos0=COMPIER__fileBuf0000_logical_file_offset;


 //As soon as we go beyond the end file buffer offset
 //(>4095) we need to read the file 2048 byts beyond
 //and reload the buffer by reading more 4096 bytes.
 ///


  //Mark start of line at current position:
  ///
   tmplinestart=COMPIER__fileBuf0000_logical_file_offset;
   OPCODE__Application_write_C_long_BinaryFile(lines_dat, tmplinestart);



 while(!OPCODE__Application__is_EOF(src))
 {
  //Go back into the file 2048 bytes
  //and then read another 4096 bytes
  //to find any inter-sector/inter-buffer
  //CRLF, CR at the last byte of the current
  //buffer, and LF at the first byte of the
  //next buffer. This is only usable when
  //we know that the string to test has a fixed
  //known size and that it fits in less than
  //1 single fuffer:
  ///
   if(COMPIER__fileBuf0000_logical_file_offset>0)
   COMPIER__fileBuf0000_logical_file_offset--;
   if(!OPCODE__Application_move_File_Position(src, COMPIER__fileBuf0000_logical_file_offset))
   {
    free(COMPIER__fileBuf0000);
    rewind(src);
    return -1;
   }



 //Read up to 4096 bytes of text to search for CRLF, LF or CR newlines.
 //We will save the actual size of the string read:
 ///
  COMPIER__fileBuf0000_charbuflen=OPCODE__Application_read_C_unsigned_char_buffer_BinaryFile(src, &COMPIER__fileBuf0000, 4096);

  COMPIER__fileBuf0000_file_buffer_offset=0;



 if(COMPIER__fileBuf0000_charbuflen>0)
 while(COMPIER__fileBuf0000_file_buffer_offset<COMPIER__fileBuf0000_charbuflen)
 {
  char0=COMPIER__fileBuf0000[COMPIER__fileBuf0000_file_buffer_offset];
  char1=0;
  if((COMPIER__fileBuf0000_file_buffer_offset+1)<COMPIER__fileBuf0000_charbuflen)
  char1=COMPIER__fileBuf0000[COMPIER__fileBuf0000_file_buffer_offset+1];
  else COMPIER__fileBuf0000_bufferOverrun=1;

  COMPIER__fileBuf0000_newlineMarkerSZ=0;
  if(char0==0x0D && char1==0x0A)
  {
   COMPIER__fileBuf0000_newlineMarkerSZ=2;
  }

  else if(char0==0x0A)
  {
   COMPIER__fileBuf0000_newlineMarkerSZ=1;
  }

  else if(COMPIER__fileBuf0000_bufferOverrun==0 && (char0==0x0D && char1!=0x0A))
  {
   COMPIER__fileBuf0000_newlineMarkerSZ=1;
  }

  COMPIER__fileBuf0000_logical_file_offset+=COMPIER__fileBuf0000_newlineMarkerSZ;
  COMPIER__fileBuf0000_file_buffer_offset+=COMPIER__fileBuf0000_newlineMarkerSZ;

  //If there was no newline marker at this byte offset,
  //we must advance the buffer offset by 1:
  ///
   if(COMPIER__fileBuf0000_newlineMarkerSZ==0)
   {
    COMPIER__fileBuf0000_file_buffer_offset++;
    COMPIER__fileBuf0000_logical_file_offset++;
   }
    else
   {
     linecount++;

     //Mark end of line at current position:
     ///
      tmplineend=COMPIER__fileBuf0000_logical_file_offset-COMPIER__fileBuf0000_newlineMarkerSZ;
      OPCODE__Application_write_C_long_BinaryFile(lines_dat, tmplineend);



///INIT: Record the heaviest line size
///INIT: Record the heaviest line size
///INIT: Record the heaviest line size
///INIT: Record the heaviest line size

     //Get the length of this line to store it
     //in case it's the longest across all of
     //the source code files, to have an idea of
     //how much memory we will need to allocate at most
     //for lines and whether we have it available:
     ///
      tmplinelength=tmplineend-tmplinestart;
      if(tmplinelength>longestlinelength)
      {
       longestlinelength=tmplinelength;


       //These variables are global to all source files
       //so the longest line number will be meaningless
       //if we don't also record the file name with the
       //heaviest line:
       ///
        longestlinenumber=linecount;
      }

///END:  Record the heaviest line size
///END:  Record the heaviest line size
///END:  Record the heaviest line size
///END:  Record the heaviest line size




     //Mark start of line at current position:
     ///
      tmplinestart=COMPIER__fileBuf0000_logical_file_offset;
      OPCODE__Application_write_C_long_BinaryFile(lines_dat, tmplinestart);
   }




  if(COMPIER__fileBuf0000_logical_file_offset==EOF_offset)
  {
   if(!OPCODE__Application_move_File_Position(src, COMPIER__fileBuf0000_logical_file_offset+1))
   {
    free(COMPIER__fileBuf0000);
    rewind(src);
    return -1;
   }

   //Mark end of line at current position, at EOF position,
   //which is the last existing character +1:
   ///
    tmplineend=COMPIER__fileBuf0000_logical_file_offset+1;
    OPCODE__Application_write_C_long_BinaryFile(lines_dat, tmplineend);

///INIT: Record the heaviest line size
///INIT: Record the heaviest line size
///INIT: Record the heaviest line size
///INIT: Record the heaviest line size

     //Get the length of this line to store it
     //in case it's the longest across all of
     //the source code files, to have an idea of
     //how much memory we will need to allocate at most
     //for lines and whether we have it available:
     ///
      tmplinelength=tmplineend-tmplinestart;
      if(tmplinelength>longestlinelength)
      {
       longestlinelength=tmplinelength;


       //These variables are global to all source files
       //so the longest line number will be meaningless
       //if we don't also record the file name with the
       //heaviest line:
       ///
        longestlinenumber=linecount;
      }

///END:  Record the heaviest line size
///END:  Record the heaviest line size
///END:  Record the heaviest line size
///END:  Record the heaviest line size




   linecount++;



   //Update line count:
   ///
    OPCODE__Application_move_File_Position(lines_dat, 0);
    OPCODE__Application_write_C_long_BinaryFile(lines_dat, linecount);



    rewind(src);
   return OPCODE__Application_get_File_Position(src)+1;
  }
 };


   COMPIER__fileBuf0000_bufferOverrun=0;
   free(COMPIER__fileBuf0000);

 }



    rewind(src);
 return -1;
}














//OPCODE__Compiler_BinarySourceFile_readline --
//    Read the contents of the line at the specified line number,
//    excluding any newline characters.
//
///
long OPCODE__Compiler_BinarySourceFile_ASCII_8bit_readline(FILE *src, unsigned long linenumber)
{
//Description.
//
//This function reads the specified text line number
//counting from 1. If it is asked a line beyond
//the existing lines, it shall return an empty string.
//Values are loaded in the global register-like
//global dynamically-allocated string variable
//COMPILER__currentASCII_8bit_LineString
//
//
//
//Parameters.
//
//FILE *src
//   Source code text file to read lines from.
//
//long linenumber
//   Line number we want to read from.
//
//
//
//Return value.
//
//long
//   Returns the length of the read line
//   or -1 on error, for example if the program
//   could not allocate memory for the line
//   to read.
//
///


 /*
 Global variables used here:

 //Global compilation data files:
 ///
  FILE *lines_dat;

 */



 long stringstart = 0;
 long stringend   = 0;
 long stringsize  = 0;


 //If we are asked line 0 or a negative line,
 //return 0 to indicate an empty string
 //(relaxed as in PHP or JavaScript):
 ///
  if(linenumber==0)return 0;



 //Read the first DWORD of lines_dat at offset 0
 //to see how many lines there are.
 ///
  //It's anlready loaded in linecount while the current
  //source file is loaded.


 //Move the lines.dat file pointer
 //at offset sizeof(long)+linenumber*(sizeof(long)*2)
 ///
  OPCODE__Application_move_File_Position(lines_dat, sizeof(unsigned long)+ ((linenumber-1)*(sizeof(unsigned long)*2)) );


 //Get the size of the string by reading the first
 //long at this position and the second long.
 //Then do second_long-first_long. If the size is 0,
 //we will just return a zero-length ASCIIZ string.
 ///
   if(!OPCODE__Application_read_C_long_BinaryFile(lines_dat, &stringstart))return 0;
   if(!OPCODE__Application_read_C_long_BinaryFile(lines_dat, &stringend))return 0;
   stringsize=stringend-stringstart;


 //Read in the ASCIIZ string into the buffer:
 ///
  OPCODE__Application_move_File_Position(src, stringstart);

 //End the function:
 ///
  return OPCODE__Application_read_C_ASCIIZ_byte_string_BinaryFile(src, stringsize);
}





//OPCODE__Compiler_BinarySourceFile_ASCII_8bit_readline_char_size --
//    Reads up to the number of asked byte characters
//    from the contents of the line at the specified line/character number,
//    excluding any newline characters.
//    If the character position is greater than the line length,
//    nothing will be read and a blank line will be returned.
//
///
long OPCODE__Compiler_BinarySourceFile_ASCII_8bit_readline_char_size(FILE *src, unsigned long linenumber, unsigned long charpos, unsigned long size)
{
//Description.
//
//This function reads the specified text line/character number
//counting from 1. If it is asked a line beyond
//the existing lines, it shall return an empty string.
//Values are loaded in the global register-like
//global dynamically-allocated string variable
//COMPILER__currentASCII_8bit_LineString
//
//
//
//Parameters.
//
//FILE *src
//   Source code text file to read lines from.
//
//unsigned long linenumber
//   Line number we want to read from.
//
//unsigned long charpos
//
//
//
//unsigned long size
//
//
//
//Return value.
//
//long
//   Returns the length of the read line
//   or -1 on error, for example if the program
//   could not allocate memory for the line
//   to read.
//
///


 /*
 Global variables used here:

 //Global compilation data files:
 ///
  FILE *lines_dat;

 */



 long stringstart = 0;
 long stringend   = 0;
 long stringsize  = 0;


 //If we are asked line 0 or a negative line,
 //return 0 to indicate an empty string
 //(relaxed as in PHP or JavaScript):
 ///
  if(linenumber==0)return 0;
  if(charpos==0)return 0;



 //Read the first DWORD of lines_dat at offset 0
 //to see how many lines there are.
 ///
  //It's anlready loaded in linecount while the current
  //source file is loaded.


 //Move the lines.dat file pointer
 //at offset sizeof(long)+linenumber*(sizeof(long)*2)
 ///
  OPCODE__Application_move_File_Position(lines_dat, sizeof(unsigned long)+ ((linenumber-1)*(sizeof(unsigned long)*2)) );


 //Get the size of the string by reading the first
 //long at this position and the second long.
 //Then do second_long-first_long. If the size is 0,
 //we will just return a zero-length ASCIIZ string.
 ///
  if(!OPCODE__Application_read_C_long_BinaryFile(lines_dat, &stringstart))return 0;
  if(!OPCODE__Application_read_C_long_BinaryFile(lines_dat, &stringend))return 0;
  stringsize=stringend-stringstart;



  //If we are asked a column/character position
  //beyond the line limits, ensure to generate
  //an empty string.
  //
  //But put the pointer at the end of the actual
  //string, just like wheb we try to go far in a
  //non-existent line position in DOS EDIT:
  ///
   if((stringstart+(charpos-1))>=stringend)
   {
//    charpos=1;
    charpos=OPCODE__Compiler_BinarySourceFile_ASCII_8bit_getLength_line_char(linenumber, 1);
    if(charpos==0)charpos=1;
    size=0;
   }

  //If we are asked more bytes than present
  //in the line, ensure to read up to the
  //end of the line, not beyond:
  ///
   if(stringsize<size)
   {
    size=stringsize-(charpos-1);
   }



 //Read in the ASCIIZ string into the buffer:
 ///
  OPCODE__Application_move_File_Position(src, stringstart+(charpos-1));

//printf("sise %d\n",size);

 //End the function:
 ///
  return OPCODE__Application_read_C_ASCIIZ_byte_string_BinaryFile(src,  size);
}





//OPCODE__Compiler_BinarySourceFile_ASCII_8bit_goto_line_char --
//
///
long OPCODE__Compiler_BinarySourceFile_ASCII_8bit_goto_line_char(FILE *src, unsigned long linenumber, unsigned long charpos)
{
//Description.
//
//
//
//
//Parameters.
//
//FILE *src
//   Source code text file to read lines from.
//
//unsigned long linenumber
//   Line number we want to read from.
//
//unsigned long charpos
//
//
//
//Return value.
//
//long
//
///


 /*
 Global variables used here:

 //Global compilation data files:
 ///
  FILE *lines_dat;

 */



 long stringstart = 0;
 long stringend   = 0;
 long stringsize  = 0;


 //If we are asked line 0 or a negative line,
 //return 0 to indicate an empty string
 //(relaxed as in PHP or JavaScript):
 ///
  if(linenumber==0)return OPCODE__Application_get_File_Position(src);
  if(charpos==0)return OPCODE__Application_get_File_Position(src);



 //Read the first DWORD of lines_dat at offset 0
 //to see how many lines there are.
 ///
  //It's anlready loaded in linecount while the current
  //source file is loaded.


 //Move the lines.dat file pointer
 //at offset sizeof(long)+linenumber*(sizeof(long)*2)
 //to get the low level start and end offset for the line:
 ///
  OPCODE__Application_move_File_Position(lines_dat, sizeof(unsigned long)+ ((linenumber-1)*(sizeof(unsigned long)*2)) );


 //Get the size of the string by reading the first
 //long at this position and the second long.
 //Then do second_long-first_long. If the size is 0,
 //we will just return a zero-length ASCIIZ string.
 ///
  if(!OPCODE__Application_read_C_long_BinaryFile(lines_dat, &stringstart))return OPCODE__Application_get_File_Position(src);
  if(!OPCODE__Application_read_C_long_BinaryFile(lines_dat, &stringend))return OPCODE__Application_get_File_Position(src);
  stringsize=stringend-stringstart;


  //If we are asked a column/character position
  //beyond the line limits, ensure to generate
  //an empty string.
  //
  //But put the pointer at the end of the actual
  //string, just like wheb we try to go far in a
  //non-existent line position in DOS EDIT:
  ///
   if((stringstart+(charpos-1))>=stringend)
   {
//    charpos=1;
    charpos=OPCODE__Compiler_BinarySourceFile_ASCII_8bit_getLength_line_char(linenumber, 1);
    if(charpos==0)charpos=1;
   }


 //Move the file pointer to the specified byte offset:
 ///
  OPCODE__Application_move_File_Position(src, stringstart+(charpos-1));


 return OPCODE__Application_get_File_Position(src);
}





//OPCODE__Compiler_BinarySourceFile_ASCII_8bit_getLength_line_char_size --
//
///
long OPCODE__Compiler_BinarySourceFile_ASCII_8bit_getLength_line_char(unsigned long linenumber, unsigned long charpos)
{
//Description.
//
//
//
//
//Parameters.
//
//unsigned long linenumber
//   Line number we want to read from.
//
//unsigned long charpos
//
//
//
//
//Return value.
//
//long
//   Returns the length of the read line
//   or -1 on error, for example if the program
//   could not allocate memory for the line
//   to read.
//
///

 long stringstart = 0;
 long stringend   = 0;
 long stringsize  = 0;


 //If we are asked line 0 or a negative line,
 //return 0 to indicate an empty string
 //(relaxed as in PHP or JavaScript):
 ///
  if(linenumber==0)return 0;
  if(charpos==0)return 0;



 //Read the first DWORD of lines_dat at offset 0
 //to see how many lines there are.
 ///
  //It's anlready loaded in linecount while the current
  //source file is loaded.


 //Move the lines.dat file pointer
 //at offset sizeof(long)+linenumber*(sizeof(long)*2)
 ///
  OPCODE__Application_move_File_Position(lines_dat, sizeof(unsigned long)+ ((linenumber-1)*(sizeof(unsigned long)*2)) );


 //Get the size of the string by reading the first
 //long at this position and the second long.
 //Then do second_long-first_long. If the size is 0,
 //we will just return a zero-length ASCIIZ string.
 ///
  if(!OPCODE__Application_read_C_long_BinaryFile(lines_dat, &stringstart))return 0;
  if(!OPCODE__Application_read_C_long_BinaryFile(lines_dat, &stringend))return 0;
  stringsize=stringend-stringstart;


  //If we are asked a column/character position
  //beyond the line limits, ensure to generate
  //an empty string:
  ///
   if((stringstart+(charpos-1))>=stringend)
   {
    return 0;
   }




 //Return the size:
 ///
  return stringsize-(charpos-1);
}





Para detectar que pasamos de definiciones a código,
antes de cualquier instrucción como if, como expresiones
independientes de una definición de identificador con tipo,
las cosas deben considerarse definiciones, pero una vez
que encontramos la primera instrucción de C como if, while,
expresiones usando un identificador que no se precede por
palabras clave de tipo, debemos considerar todo como datos
y para el caso de C, opcionalmente marcar definiciones nuevas
inválidas por lo menos dentro de las funciones, y usar un reseteo
de esa regla fuera de las funciones. Después de todo, fuera
del código de C estándar, normalmente no hay código, solo
declaraciones y cuerpos de funciones, variables, preprocesador....
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Vie Ene 05, 2018 4:35 am

No dejar que el cansancio o aparentente tedio
mientras hacemos el esfuerzo de resolver cada
paso de un progam con complejidad nos empuje a
implementar las cosas con menos caliad. Debemos
implementar todo exactamente como lo pensemos, y
la forma escogida debe ser la mejor por razones
técnicas, la mejor elaborada, aunque se tarde más.
Eso hará que mantengamos el impulso y la claridad
mental ya que estaremos copiando el contenido de
nuestra mente al programa sin altararlo, en vez de
dejar que una implementación a medias nos retuerza
gradualmente hasta volverse confusa e inutilizable.



La complejidad real de lo que hagamos, la dificultad
real y las cosas a las que debemos ponerles atención
están dadas por los problemas técnicos a resolver,
el paso actual a implementar, lo que hemos hecho,
lo que sabemos hacer y lo que no, lo que tenemos
que contiene errores y lo de alta calidad que sea lo
mejor que hayamos logrado.

Si nos concentramos en esas cosas y no dejamos que
nada nos preocupe o desespere, si disfrutamos
el seguir haciendo cosas de desarrollo después de
tanto tiempo y simplemente nos enfocamos en las
cosas que resolver como la problemática real, podremos
sobrepasar el resto de cosas que se quieren enmascarar
como los problemas, y simplemente se irán pasando,
ya que no tendrán el componente práctico de lo que
estamos resolviendo y ejecutando humanamente de forma
estructurada para avanzar en lo que necesitamos,
simplemente no tendrá razón de ser ponerle atención
y mucho menos preocupación porque estaremos tocando
el problema real, no adentrándonos en caminos lógicos
mal formados.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Vie Ene 05, 2018 5:53 am

Agregar información de posición de línea, carácter y offset para los archivos de metadatos de líneas de cada archivo de texto de código fuente.

JPG




Diseñar una función para obtener el número de carácter y línea en base al offset actual del archivo.

Necesito una función que tome el offset actual del archivo de texto y busque un rango que encaje. En ese caso el número de línea será el valor del elemento de línea que concuerda con el rango, y el número de carácter se determinaría así:

- Obtener el offset actual del archivo.
- Obtener el offset del inicio de línea.
- Efectuar offset_actual-offset_inicio_linea.
- Obtendremos un valor entre 0 y n, a este debemos sumarle 1 para obtener el número de carácter.

Si el offset está justo al final de la línea, en el offset donde empieza la secuencia de nueva línea, entonces tenemos que aumentar el número de línea, poner el número de carácter a 1, y mover el offset ahí, registrándolo, así que tenemos que revisar todas las funciones de manipulación de línea para que se reposicionen al principio de la siguiente línea en vez de quedar en un punto intermedio.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Vie Ene 05, 2018 8:15 pm

Lista de funciones a actualizar para mantener la posición de líneas.

long OPCODE__Compiler_BinarySourceFile_ASCII_8bit_goto_line_char(FILE *src, FILE *lines_dat_file, unsigned long linenumber, unsigned long charpos)

long OPCODE__Compiler_BinarySourceFile_ASCII_8bit_get_line_char_from_fileOffset(FILE *src, FILE *lines_dat_file, unsigned long fileOffset, unsigned long *linenumber, unsigned long *charpos)

long OPCODE__Compiler_BinarySourceFile_ASCII_8bit_readline_char_size(FILE *src, FILE *lines_dat_file, unsigned long linenumber, unsigned long charpos, unsigned long size)

long OPCODE__Compiler_BinarySourceFile_ASCII_8bit_readline(FILE *src, FILE *lines_dat_file, unsigned long linenumber)



Determine the tables
Determine the fields
Determine the relationships
Determine the indexes
Normalize the data

The data design above is in pretty good shape with regard to normalization. With practice, you will usually design in appropriate normal forms when you create your tables and fields. However, it's a good idea to check your normalization just to make sure you haven't missed anything. 281--VB6 design, specification, objects

Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Sab Ene 06, 2018 9:42 am

El primer archivo de código, el especificado en la línea de comandos del compilador, debe considerarse como un #include para que la lógica del compilador inicie de forma limpia, solo teniendo cuidado de ver que antes de este no habrá elementos y por lo tanto deberemos terminar la compilación cuando la pila de archivos pendientes esté totalmente vacía y lleguemos al final del primer archivo, para entonces pasar a las otras etapas de la compilación, como la generación del código y datos de la estructura del ejecutable destino.

Empezar leyendo las directivas del preprocesador (#include, #ifdef, #ifndef, #else, #endif, #undef, etc...)

Necesito implementar la siguiente función:
long OPCODE__Compiler_BinarySourceFile_ASCII_8bit_readline_char_size_PositionPreserve(FILE *src, FILE *lines_dat_file, unsigned long linenumber, unsigned long charpos, unsigned long size)

...para leer con reintentos la palabra clave actual y así comparar todas las palabras clave conocidas de forma más fácil sin mover el puntero del archivo de código a leer.

La primer tarea que necesitamos es el esqueleto del bucle para leer todos los archivos de código secuencialmente, cada vez que haya un #include agregaremos y usaremos las posiciones de línea registradas en los archivos de metadatos de líneas, y cuando lleguemos al final de cada archivo incluido lo descartaremos para seguir hasta el final del código entero.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Sab Ene 06, 2018 10:45 pm

Implementar las funciones de opcode para la función de #include de archivos locales/relativos y para los archivos de cabecera del mismo compilador.


int OPCODE__Compiler_Language_C_pre_include(unsigned char *included_file_path);

int OPCODE__Compiler_Language_C_pre_include_library_header(unsigned char *included_file_path);



Lo primero que necesito es considerar el archivo especificado en la línea de comandos como una directiva #include.

Para eso necesito que las funciones anteriores agreguen incondicionalmente el archivo especificado a filelist.txt, que refresquen las líneas de filelist.txt en filelist.dat con las funciones del administrador de líneas, que mantenga un índice, que agregue el índice a una pila/puntero de pila de archivos actual y aumente el índice de los archivos para agregar el arhivo a incluir. Además necesitamos crear un archivo con el número de índice en filelist.txt, que inicie desde 1 ya que usaremos los números de línea como índice, que sea un archivo de tipo lines.dat para poder recorrer todos los archivos incluidos.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Dom Ene 07, 2018 7:31 am

Agregarle los tipos de datos wideword y modificador wide (para wide unsigned int, wide int, wide float, etc...) para que nuestro código pueda tener más portabilidad al más bajo nivel y todavía así usar C estándar.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Mar Ene 09, 2018 3:11 am

Mantener el índice de archivos desde 1, desde el inicial,
que correspondería a la primera línea que registra el
archivo especificado en la línea de comandos, algo como
files_index.

Escribir el archivo fstack.dat, con la cuenta, posición
actual de pila en el archivo, y el índice en la pila
del índice actual de archivo.

Ya que estamos tratando con el archivo especificado
en la línea de comandos, tratar eso como un #include "archivo_local".
Escribir el archivo filelist.txt con el valor del
directorio actual y después, si no hay una pleca invertida
al final de esta ruta, escribir una, y después escribir
el valor del archivo especificado en la línea de comandos.
Cuando obtengamos #includes reales del código, entonces
volveremos a hacer esto pero con:

- La ruta actual y lo encerrado entre #include "archivo"
- La ruta del compilador y lo encerrado entre #include <archivo>
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Mar Ene 09, 2018 4:23 am

Función para convertir un número long en cadena para usarse como nombre de archivo para mantener estructuras al estilo lines.dat
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Mar Ene 09, 2018 5:26 am

Creo que si no implemento rápido las ideas que tengo,
estas se quedarán consumiendo mi energía mental más
tiempo del que deberían, y me atrasarán, así que como
mínimo tengo que escribir lo que pienso implementar
para después en vez de tener que acordarme, leer lo más
reciente por hacer, e implementarlo cuando tenga suficiente
energía, más que solo para descansar y recuperar energía
sin tanta dificultad.

Por ejemplo, necesito definir la estructura del archivo
fstack.dat (long elementcount, long elementoffset, array{long file_indexes})
desde la función inicial que crea y abre todos los archivos
del proceso de compilación, para que después este archivo, y otros,
estén listos solo para usarse.

Hacer las cosas con esa intención de anotar y después implementar,
o viceversa según la fuerza que tengamos en un momento dado,
va a hacer que tengamos más fuerza ya que las ideas que tengamos no
se quedarán pendientes consumiendo energía mental para mantenerlas
si ya podemos vertirlas al exterior para usarlas.


recuperar reponer
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Mar Ene 09, 2018 7:13 am

Manejar los #includes (abrir y cerrar archivos de código y metadatos del compilador asociados) en el bucle principal de compilación.

Tenemos que mantener control de qué archivo está
abierto actualmente, tenemos que cerrar los archivos
actualmente abiertos, si los hay, antes de abrir
otros por #include, y tenemos que poder regresar a
abrir los archivos anteriores cuando lleguemos al
final del archivo de código actualmente abierto,
si es que no llegamos ya al final del archivo de
código principal, lo que indica que ya no hay más
archivos de código fuente a compilar que abrir o
cerrar de parte de los includes del compilador o
del código del programa compilado proporcionado
por el usuario.

Esa es la lógica que tengo que pensar cuidadosamente,
cómo registrar, abrir y cerrar archivos con los #includes
para implementar el esqueleto básico de incluir
y recorrer todos los archivos de código a medida vayamos
encontrando las directivas #include, fines de archivo
y finalmente condicionales #if... y el resto del preprocesador
para controlar esto bien.

Esta siento es una oportunidad para limpiar mi entorno
mental, imaginarme y sentir cómo voy arreglando todo en
mi mente y el el funcionamiento de mi sistema a medida
ideo cómo administrar los archivos como expliqué antes,
siento que puedo usar este proceso y otros, para ayudar
a todos mis aspectos y a mi exterior, al entorno, usando
el proceso de desarrollo para arreglar también esos
detalles a medida que resuelva los elementos a implementar,
hasta implementarlos, pero mientras tanto ir arreglando todo
desde mi mente y cuerpo hacia todo el espacio exterior a mí.

Hasta me siento más feliz cuando logro llegar a un punto
de una tarea como esta de administrar los archivos en el
compilador, puede que internamente esté entendiendo hasta
cómo manejar un sistema de archivos, pero creo que más que
sentirme feliz porque encontré la tarea ideal para ese momento,
es porque estoy con la mentalidad más adecuada posible para
mi nivel actual que me permita ver las cosas mejor al usar
esa solución para todos los aspectos de forma reusable,
clara, limpia, óptima y al máximo de mi creatividad.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Mar Ene 09, 2018 11:05 am

Creo que para cosas que hacen que cambiemos de archivo
de código fuente, como #includes y alcanzar el final
de archivo, necesitamos una lógica en la que cada vez
que encontremos lo que nos pida cambiar de archivo,
hagamos lo siguiente:

- Que tengamos 2 bucles uno dentro de otro.

- Que el bucle exterior tenga código para abrir/cargar/restaurar
los metadatos del archivo actualmente especificado,
probablemente al final del bucle para descargar y al
principio del bucle para cargar el que sigue en la pila,
o para detener el proceso.

- Que el bucle interior tenga todo el árbol de procesamiento
de la sintaxis, escaneo, y también para los #includes,
finales de archivo, y para detener el bucle en esos casos,
o ante errores, de una forma en la que pudiéramos descargar/cerrar
los archivos del archivo de código actual y preparar los datos
para abrir el siguiente, que parece mucho más robusto que
hacer eso al final del bucle exterior, ya que lo haríamos
justo cuando aparezcan esos casos con los datos que
tendremos a la mano en ese momento.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Mié Ene 10, 2018 8:39 am

Necesito implementar un bucle que me permita
recoger todos los elementos, identificadores,
definiciones de código globales, estén donde estén,
de una forma en la que sin importar dónde esté
el código, lo pueda usar antes de declararse,
en vez de dar errores, que funcione como JavaScript.

Tal vez me sirva pasarle los datos basado en las
variables usadas, pero ya que estas también puede
ser desconocidas en el momento en que se usen,
realmente necesito quizás 2 bucles, uno para
recoger las declaraciones y otro para compilar,
o uno para tratar de compilar y marcar lo que no se
pudo y otro para tratar de compilar otra vez a lo que
le faltaba declaraciones.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Vie Ene 12, 2018 8:25 am

Inicio del Árbol de Sintaxis para el Preprocesador.

Necesito una función para leer el carácter efectivo
más cercano en una línea, para ir a la siguiente línea,
a la línea anterior, y para obtener la línea/carácte a partir
del offset actual del archivo, que siempre debería estar
en una posición registrada, nunca en bytes de nueva línea
que no están en los rangos de los metadatos de archivo,
por ejemplo que podría pasar para nuevas líneas "\r\n".
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Lun Ene 15, 2018 1:43 pm

Funciones OPCODE para marcar bloques a ser saltados/ignorados, diferentes de comentarios, de código activo.



Necesito funciones para registrar bloques de código a ser saltado, por ejemplo bloques #if que no se cumplan o tal vez bloques ya procesados en etapas anteriores, para cada etapa, preprocesador, declaraciones globales, declaraciones externas, tal vez en diferentes archivos, o en un archivo acumulativo, que indique la etapa que se salta.


Funciones OPCODE para interpretar de forma completa cada instrucción de C, no solo obtener el identificador o operador/carácter que tenemos a continuación.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Mié Ene 24, 2018 5:36 am

Agregar más código para obtener la ruta estática de instalación del compilador con argv[0], función de WinAPI o $HOME (UNIX).
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Mié Ene 24, 2018 5:45 am

Limpiar el código y agregarle documentación para que sea claro desde ahí, además de pasar dicha documentación a un documento tipo HTML con el estilo de PHP.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Mié Ene 24, 2018 6:02 am

Buscando Directivas de Preprocesador

Usar la función que lee una línea, busca un
carácter específico, mueve el puntero, y
devuelve 0 o 1 para saber si encontró la
posición.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Sab Ene 27, 2018 2:33 pm

Empezando a recuperar cadenas de texto con significado para el lenguaje.


Puedo empezar a usar funciones del tipo getTypedString().

Necesito mantener la posición de lo que lea y potencialmente
sin alterar la posición actual del archivo.

Necesito mantener la posición de offset y línea/carácter actuales,
pero tengo diferentes formas y lugares en las que mantengo esa
información. Tal vez debería hacer todo a través de la estructura
de "cadena objeto con tipo de código fuente", que solo es una y se
actualiza cada vez que se lee la siguiente.

Podría usar eso como un registro de CPU de compilador,
y todo lo demás que mantenga el valor de esos offsets
serían copias temporales aunque sean globales, la estructura
misma para ese objetivo debería ser como un registro,
y tendría que acostumbrarme a batirme en el manejo de todas
las líneas y elementos de código solo a través de ese registro,
igual que con un CPU, que sería algo limpio, conciso e inmediato.

El otro lugar en el que mantendrían offsets válidos necesariamente,
sería en la pila de archivos de código fuente, que solo se usa
al procesar #includes y llegar al final del archivo, pero que
dependería de la estructura registro de elementos de código,
que es la que mantiene la posición y tamaño/tipo del elemento
más recientemente encontrado, que solo es un espejo temporal
secundario igual que el resto de copias de offsets que no
sean la estructura registro de elementos de código fuente.


skipTypedString si usamos positionPreserve en getTypedString
en 2 variedades, una que salte usando los datos más recientemente
obtenidos, y otra saltando por su cuenta determinando la cadena
más reciente, guardando, usando y restaurando la estructura registro.


Para lograr seguir, simplemente tengo que usar las
funciones del administrador de elementos de código
(code elements manager) para el lenguaje dado en vez
de manualmente las de administración de líneas.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Jue Feb 01, 2018 2:19 pm

Agregar funciones para intercambiar entre offsets y línea/carácter.



Hacer más estricto el uso de la detección del compilador, detectar el directorio base y generar los directorios hacia los elementos que queremos.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Vie Feb 02, 2018 9:05 am

rewind_before_newlines
advance_after_newlines

Funciones del administrador de líneas para siempre estar
dentro de los límites de contenido de las líneas, para evitar
trabarnos si el puntero queda sobre un carácter de nueva línea
después de lecturas/escrituras arbitrarias. El administrador
de líneas no registra offsets para nuevas líneas, así que
si nos quedamos ahí no podremos encontrar en qué línea estamos
solo con los offsets de inicio/fin de una línea.




char *COMPILER_newline_string="\r\n";
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Jue Feb 15, 2018 8:08 pm

Agregar una función de árbol de sintaxis basado en cadenas con tipo basado en sintaxis básica


Al estilo de getTypedString.

Lo más fácil es agregar un solo bucle
para cadenas alfanuméricas y guión bajo '_'.

Después, capturar el carácter '#'.

Una vez que agreguemos eso, específicamente
el soporte del carácter '#', y devolver la estructura
descriptora del tipo de cadena, podemos
empezar a agregar un segundo nivel de sintaxis
para las diferentes etapas de la compilación,
el preprocesador, para el código de C en cada
una de sus capas a descubrir (global, local),
podemos empezar a agregar un árbol de sintaxis
de segundo nivel.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Jue Feb 22, 2018 2:20 am

Usar la función de obtención de tipos de cadena y agregar un contador general u offset de archivo a Main_Loop.



...., y poco a poco el índice del archivo actualmente abierto de código y la pila de archivos de código con la línea en la que nos quedamos después de #include (push) y después de EOF (pop).



Creo que para Abril ya voy a tener todo lo básico del compilador, solo me va a faltar lo más difícil pero voy a tener el resto del año para investigar función por función (punteros, expresiones, números decimales, goto, Ensamblador, generación de código configurable, formatos de archivo, selección del idioma del compilador).


sistema de punteros, structs/unions, * & y arreglos.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Vie Feb 23, 2018 12:29 pm

Ver qué directiva le sigue a nuestro carácter '#', empezando por las que vamos a usar inmediatamente, empezando por #include según lo que tenemos en hello.c
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Vie Feb 23, 2018 9:58 pm

Agregar arreglos con las cadenas de las directivas de preprocesador y las instrucciones de C en Inglés y Español y un arreglo que pueda seleccionar entre el idioma predeterminado del compilador.

Una vez que nuestro compilador se pueda compilar a sí mismo va a poder usar las directivas de pragmas pero también va a estar usando código que las aplique, así que hay que ver si no causa conflicto o código mal generado, pero sino podríamos configurar los pragmas de nuestro compilador con un #define para usarlos manualmente y que solo sean aplicables una vez que el compilador esté compilado, usar los pragmas para todo menos para él mismo u otros programas especiales que necesiten usar uno u otro.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Vie Feb 23, 2018 10:06 pm

Pensar en los diferentes pragmas que pueden darle a nuestro compilador tanta flexibilidad como estar programando en Ensamblador crudo.



Solo que lo generaremos automáticamente con el compilador. Lo único que vamos a hacer es configurar la generación con pragmas para generar un tipo conocido de ensamblador para hacer prácticamente lo mismo pero extremadamente acelerado programar en C como si fuera directamente en Ensamblador, como si fuera nuestro esfuerzo de traducir de C a Ensamblador manualmente, pero ahora con nuestro propio compilador.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Vie Feb 23, 2018 10:16 pm

Para optimizar el código generado, tenemos que escoger al tamaño de los tipos de datos de tamaño variable de C como int/short/double, no por el tamaño de los registros de un modo del CPU, sino que por el tamaño seleccionado que debe ser un tamaño válido como 8, 16, 32 o 64. Esto hará que los tipos de datos de este tipo se queden en su nivel de complejidad y se puedan seleccionar más fácilmente en el código de C en sí que escribamos para nuestro compilador.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Vie Feb 23, 2018 10:22 pm

Tengo que pensar cómo implementar la pila de archivos de código fuente, esta solo debería contener el índice del archivo y el offset donde se encontró la última directiva antes de cambiar de archivo. La comprobación de que esto está bien implementado es que podremos generar un archivo de C postprocesado que contenga el código en el orden que debe ser. Una vez esto está bien, podremos preocuparnos por implementar el resto del preprocesador y árbol de sintaxis del código de C.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Vie Mar 02, 2018 3:03 am

Los comentarios // tienen un componente
de fin de instrucción asociado así que
no se pueden escapar con \, pero los
comentarios /**/ no tienen eso asociado
así que hay que usarlos para eso.

Inválido:
Código: Seleccionar todo
# //    \
include <stdio.h>





Válido:
Código: Seleccionar todo
# /**/    \
include <stdio.h>

Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Sab Mar 03, 2018 3:45 pm

Agregar una función para comparar cadenas y el contenido de archivos en modo binario para comparar cadenas sin límite.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Mié Mar 07, 2018 10:19 am

Para empezar necesito usar todas las formas
de usar espacios en blanco o bloques inactivos
como comentarios multilínea, y nuevas líneas
escapadas y de ahí incluir esos tipos de espacio pero
con todas las subcombinaciones posibles. Con eso
puedo probar de entrada si todo el código que escriba
para simplemente saltarme los espacios, y por ende
también para registrar bloques de comentarios, espacios
de todo tipo, no tiene errores.

Así que lo siguiente debería ser la variación
de un espacio complejo para el que debemos saltarnos
tabs, espacios, comentarios multilíneas y
nuevas líneas escapadas.

Lo siguiente a hacer deberían ser funciones
capaces de saltarse bloques de código con y sin
espacios de todo tipo circundantes de forma que
al eliminarlos/ignorarlos podamos formar una sola
cadena unida como si esos espacios no existieran,
para reconocer cosas como <std/**/io.h>
o como str/*ing */cmp/*are*/(...), aunque eso es
ningún compilador reconoce, solo Open Watcom
puede interpretar bien <std/**/io.h>, así que si
agregamos eso estaremos creando una variedad de
lenguaje de C. Tendríamos que definir un comentario
multilínea especial como por ejemplo /. ./
para simplemente descartarlo de donde aparezca y
aumir que lo que separa realmente está unido y este
solo está agregando texto para completar frases
coherentes al idioma natural para hacerlo mucho más
inteligible.

/> </



Código: Seleccionar todo
    /*SPACE*/\   

Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Jue Mar 08, 2018 7:37 pm

Agregar de forma seguida todas las opciones posibles
de lo que puede salir en un programa, y uno que
otro error, puede ayudarnos realmente a "serializar"
el problema para resolver todas las opciones
inmediatamante una tras otra en el mismo bloque de
programación. Si son partes de una misma opción,
crear archivos iniciales especiales que las incluyan
todas seguidas hará que resolverlas todas sea tan
fácil como resolver solo una.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Dom Mar 11, 2018 6:48 am

Crear un archivo de código fuente donde pondremos todo el código ya listo para empezar a interpretarse/compilarse.


En la función del bucle principal, cada vez que
saltemos un bloque, volverlo a escribir en el
archivo de C/C++ generado, 0.c

¿Y qué hacemos después? Es la pregunta que nunca deja
de salir porque la gracia es poder hacer algo con esto,
algo interesante que nos dé impulso y más estructura.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Vie Mar 23, 2018 8:28 am

Los identificadores pueden estar escapados por \
para ponerlos en diferentes líneas, así que la
longitud del identificador en cuestión puede
ser diferente al número de caracteres con todo
y lo escapado.

Devolver la cadena en sí en la estructura de
Typed String. Ya que esta tendrá malloc()s anidados,
tenemos que liberar primero la cadena apuntada
a la cadena devuelta, y también otras cosas reservadas
dinámicamente, y después el puntero de la estructura
en sí.

Así que en general las estructuras deberían tener
funciones para liberarlas sin que nos equivoquemos,
entre otras tareas que sean demasiado pesadas y
con las que podríamos equivocarnos.



Probar si se puede hacer lo mismo con números,
cadenas, etc.


WARNING: Checking and free()ing a pointer without setting it to NULL /the checked value.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Lun Abr 09, 2018 5:20 am

Agregar código de malloc/realloc/free y de recoger las cadenas carácter por carácter para cada tipo de carácter, o el programa fallará por no tener memoria reservada para la cadena limpia, que aumentaremos de 1 byte en 1 byte.



Agregar Función RTrim/LTrim/Trim de Visual Basic 6 en C.



Comprobar que podemos recoger cualquier cadena alfanumérica escapada o no y que esta no confunda identificadores con palabras reservadas de C o preprocesador.



Implementar recoger todo tipo de cadenas y convertirlas en cadenas de NASM.



Implementar funciones para reservar/liberar variables globales, estáticas, locales, en Ensamblador.

Las param stack, local dynalloc.
Los parámetros de funciones deben estar en la pila, las variables locales deben reservarse dinámicamente, si son const debemos reconectarlas de alguna forma.

Para devolver valores debemos ensayar devolverlos en WIDEAX, en la pila, en variables por referencia, aunque tengamos que aprender cómo pasar o devolver estructuras, cadenas, etc., por la pila, pero si hay compiladores que soportan eso, tenemos que soportarlo para poder usar todo el código bueno que hay.





Agregar los tipos de datos de nivel de Ensamblador byte_t, word_t, dword_t, qword_t, wideword_t (byte_x86portable_t, word_x86portable_t, dword_x86portable_t, qword_x86portable_t, wideword_x86portable_t).

Si los implementamos con los nombres largos, siempre se entenderá que son de otro lenguaje y así podremos agregar limpiamente cosas limpias de todos los lenguajes a nuestro compilador de C. Más adelante, si se comprueba que es totalmente necesario, podemos usar namespaces de C++ aunque sea como wrappers para esto.

Y ya que necesitamos máxima portabilidad, necesitaremos implementar la mayoría de tipos básicos, banderas, etc., en el compilador mismo, no en archivos de cabecera. Eso seguramente hará que nuestro compilador sea más simple pero también generará código muchísimo más portable, como si fuera un motor de JavaScript que corre en todos lados mientras que el resto de compiladores son semiportables.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Piezas de Código del Compilador de C/C++ de ArcheFire (v2017-11-08start)

Notapor ~ » Mar Abr 24, 2018 1:36 am

Agregar función para recargar automáticamente el búfer de lectura del archivo de código basado en el tamaño del búfer, tamaño del archivo, posición actual en el búfer de lectura, reconfigurando también esos parámetros para hacer mucho más limpia la programación general a la hora de leer los archivos de código fuente.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Siguiente

Volver a Compilador de C

¿Quién está conectado?

Usuarios navegando por este Foro: No hay usuarios registrados visitando el Foro y 23 invitados


cron