Herramientas de usuario

Diferencias

Muestra las diferencias entre dos versiones de la página.

Enlace a la vista de comparación

Ambos lados, revisión anteriorRevisión previa
Próxima revisión		Revisión previa
ecce.c [2023/07/28 19:41] – peronecce.c [2026/04/21 16:06] (actual) – editor externo 127.0.0.1
Línea 1: Línea 1:
-<code c> +<file c ecce.c>
-/* This file is http://ecce.sourceforge.net/ecce.c +
-   It is written in reasonably portable C and should +
-   be easy to compile with any C compiler, eg on Linux: +
-   cc -o ecce -DWANT_UTF8 ecce.c +
-  +
-   You may need to do: export LC_ALL=es_ES.UTF-8 +
-  +
-   Although it's reasonable portable C, there are now +
-   a couple of places where linux filenames are used - +
-   you may need to make some small changes if compiling +
-   for Windows or other non-unix systems.  Look for *SYS* +
-   in the source below.  Feedback portability improvements +
-   to gtoal@gtoal.com please.  Note that we assume that +
-   even a linux system is single-user.  The use of +
-   tmpnam() for saving in an emergency is potentially +
-   unsafe in a multi-user environment if there are +
-   bad actors. +
-  +
-   Version 2.10a adds support for more robust embedding +
-   of ecce in Emacs, by making a version of the "-command" +
-   parameter (-hex-command) accept a hex string in order +
-   to pass the ecce command as a parameter while avoiding +
-   problems such as the use of " characters in the ecce command. +
-  +
-  +
-*SYS* +
-Add this to your ~/.emacs file (or some equivalent for Windows): +
-  +
-;; hex encoding needed below. Came from https://github.com/jwiegley/emacs-release/blob/master/lisp/hex-util.el +
-(eval-when-compile +
-  (defmacro num-to-hex-char (num) +
-    `(aref "0123456789abcdef" ,num)) +
-  ) +
-  +
-(defun encode-hex-string (string) +
-  "Encode octet STRING to hexadecimal string." +
-  (let* ((len (length string)) +
-         (dst (make-string (* len 2) 0)) +
-         (idx 0)(pos 0)) +
-    (while (< pos len) +
-      (aset dst idx (num-to-hex-char (/ (aref string pos) 16))) +
-      (setq idx (1+ idx)) +
-      (aset dst idx (num-to-hex-char (% (aref string pos) 16))) +
-      (setq idx (1+ idx) pos (1+ pos))) +
-    dst)) +
-  +
-;; Embedded ECCE support +
-  +
-(defun e (ecce_command) +
-  (interactive "sEcce> ") +
-  (let (oldpoint (point)) +
-    (setq oldpoint (point)) +
-    (call-process-region (point-min) (point-max) +
-                         "/bin/bash" +
-                         t t nil +
-                         "-c" +
-                         (concat "ecce - - -hex-command " +
-                                 (concat (encode-hex-string (concat (concat (format "(r,m)%d(l,m-r0)?\n" (point)) ecce_command) +
-                                                                    (format "\ni/%%EMACS%dCURSOR%%/\n%%c" (+ 495620 oldpoint)) +
-                                                                    ) +
-                         ) " 2> ~/.ecce-emacs.err")) +
-    ) +
-    (goto-char (point-min)) +
-    (search-forward (format "%%EMACS%dCURSOR%%" (+ 495620 oldpoint))) +
-    (replace-match "" nil nil) +
-  ) +
-) +
-  +
-(global-set-key "\C-e" 'e) +
-  +
- */ +
- +
 #define VERSION "V2.10b" /* %V */ #define VERSION "V2.10b" /* %V */
  static const char *RCS_Version = "$Revision: 1.4 $"; /* only relevant to my home linux /usr/local/src/ecce */  static const char *RCS_Version = "$Revision: 1.4 $"; /* only relevant to my home linux /usr/local/src/ecce */
 #define DATE "$Date: 2021/11/30 03:55:52 $" #define DATE "$Date: 2021/11/30 03:55:52 $"
- +
 #include <stdio.h> #include <stdio.h>
 #include <string.h> #include <string.h>
Línea 82: Línea 10:
 #include <signal.h> #include <signal.h>
 #include <errno.h> #include <errno.h>
- +
 #ifdef WANT_UTF8 #ifdef WANT_UTF8
 /* EXPERIMENTAL SUPPORT FOR UTF-8 - been tested for a few years now, seems robust enough to make default. */ /* EXPERIMENTAL SUPPORT FOR UTF-8 - been tested for a few years now, seems robust enough to make default. */
 #include <wchar.h> #include <wchar.h>
 #include <locale.h> #include <locale.h>
- +
 typedef wint_t ecce_int; typedef wint_t ecce_int;
 typedef wchar_t ecce_char; typedef wchar_t ecce_char;
Línea 103: Línea 31:
 /*                                                */ /*                                                */
 /*                                                */ /*                                                */
-/*     ECCE was designed by Hamish Dewar, now     */ +/*     ECCE fue diseñado por Hamish Dewar, ahora  */ 
-/* retired.  This implementation is by Graham     */ +/* retirado.  Esta implementación es de Graham    */ 
-/* Toal, of the Edinburgh Computer History        */ +/* Toal, del Proyecto de Historia del Cómputo     */ 
-/* Project.                                       */+/* de Edimburgo.                                  */
 /*                                                */ /*                                                */
-/* This source is released into the public domain */ +/* Este código fuente fue lanzado al dominio      */ 
-/* by the author, without restriction.            */+/* público por su autor, sin restricciones        */
 /*                                                */ /*                                                */
 /* (c) Graham Toal, 1984. (Original BCPL version, */ /* (c) Graham Toal, 1984. (Original BCPL version, */
 /*   translated into C in 1992).                  */ /*   translated into C in 1992).                  */
 /**************************************************/ /**************************************************/
- +
 /**************************************************************************/ /**************************************************************************/
-  + 
- +
 #define NOTE_FILE "/tmp/Note0" /* Specific to Linux - unfortunately, /tmp is shared by other users */ #define NOTE_FILE "/tmp/Note0" /* Specific to Linux - unfortunately, /tmp is shared by other users */
              /* so this version of Ecce is really only expected to be used on a single-user system */              /* so this version of Ecce is really only expected to be used on a single-user system */
- +
 /* #define NOTE_FILE "/dev/shm/Note0" // Specific to the variation of Linux I'm using (ram disk)  *SYS*/ /* #define NOTE_FILE "/dev/shm/Note0" // Specific to the variation of Linux I'm using (ram disk)  *SYS*/
- +
  /* I'm aware that this area of the code needs work to be made robust.  It looks like I can't  /* I'm aware that this area of the code needs work to be made robust.  It looks like I can't
    have robustness without some OS-specific code.    have robustness without some OS-specific code.
- +
    This code is already less portable than was first intended.    This code is already less portable than was first intended.
    Look for lines containing the marker *SYS* to see if the    Look for lines containing the marker *SYS* to see if the
    small deviations from portability affect your system.    small deviations from portability affect your system.
- +
    Note that the libraries with most windows C compilers try to handle    Note that the libraries with most windows C compilers try to handle
    some unix constructs such as / as a filename separator, so even some    some unix constructs such as / as a filename separator, so even some
    of the code marked *SYS* is likely to work on Windows.    of the code marked *SYS* is likely to work on Windows.
 */ */
- +
               /* Name of temp file for multiple contexts - system dependant. */               /* Name of temp file for multiple contexts - system dependant. */
               /* Something like "/tmp/Note%c" would be a small improvement,  */               /* Something like "/tmp/Note%c" would be a small improvement,  */
               /* but using a proper function like tmpnam() would be best.    */               /* but using a proper function like tmpnam() would be best.    */
- +
               /* Unfortunately tmpnam is deprecated due to timing issues     */               /* Unfortunately tmpnam is deprecated due to timing issues     */
        /* with setting up file permissions - but it is the only call  */        /* with setting up file permissions - but it is the only call  */
               /* in this area that is portable to Win/DOS, and I'm trying    */               /* in this area that is portable to Win/DOS, and I'm trying    */
               /* to keep this source OS-independent. (without ifdef's)       */               /* to keep this source OS-independent. (without ifdef's)       */
- +
               /* This is the remaining code issue I'ld like to fix before    */               /* This is the remaining code issue I'ld like to fix before    */
               /* moving this to sourceforge.                                 */               /* moving this to sourceforge.                                 */
-  + 
- +
 #define CONTEXT_OFFSET (strlen(NOTE_FILE)-1) #define CONTEXT_OFFSET (strlen(NOTE_FILE)-1)
               /* Index of variable part in name above (i.e. of '0')         */               /* Index of variable part in name above (i.e. of '0')         */
- +
 static char *ProgName = NULL; static char *ProgName = NULL;
 static char *parameter[4] = {NULL, NULL, NULL, NULL}; /* parameters - from, to, log, command */ static char *parameter[4] = {NULL, NULL, NULL, NULL}; /* parameters - from, to, log, command */
 static char *commandp = NULL; static char *commandp = NULL;
- +
 #define    F       0  /* FROM */ #define    F       0  /* FROM */
 #define    T       1  /* TO */ #define    T       1  /* TO */
 #define    L       2  /* LOG */ #define    L       2  /* LOG */
 #define    C       3  /* COMMAND */ #define    C       3  /* COMMAND */
- +
 unsigned long estimate_buffer_size(char *fname) unsigned long estimate_buffer_size(char *fname)
 { {
Línea 165: Línea 93:
   unsigned long maxbuf = 0UL;   unsigned long maxbuf = 0UL;
   long rc;   long rc;
- +
   /* since we allocate RAM for the whole file, don't bother handling   /* since we allocate RAM for the whole file, don't bother handling
      files longer than 32 bits.  It's just a text editor after all... */      files longer than 32 bits.  It's just a text editor after all... */
- +
   if (tmp == NULL) return 2UL*1024UL*1024UL;   if (tmp == NULL) return 2UL*1024UL*1024UL;
   (void)fseek(tmp, 0L, SEEK_END);   (void)fseek(tmp, 0L, SEEK_END);
Línea 176: Línea 104:
   return (maxbuf + 1024UL*256UL) * 3UL;   return (maxbuf + 1024UL*256UL) * 3UL;
 } }
- +
 /**************************************************************************/ /**************************************************************************/
- +
 #define FALSE (0!=0) #define FALSE (0!=0)
 #define TRUE (0==0) #define TRUE (0==0)
- +
 /* Types */ /* Types */
- +
 typedef int bool; typedef int bool;
 typedef ecce_char *cindex; typedef ecce_char *cindex;
- +
 /* Consts */ /* Consts */
- +
 #define    bs              8 #define    bs              8
 #define    bell            7 #define    bell            7
Línea 198: Línea 126:
 #define    minusbit        casebit #define    minusbit        casebit
 #define    plusbit         0x80 #define    plusbit         0x80
- +
 /* I know it is bad practise to have these fixed length arrays and I will /* I know it is bad practise to have these fixed length arrays and I will
    work on that eventually.  I increased the size of these considerably    work on that eventually.  I increased the size of these considerably
Línea 208: Línea 136:
 #define    Max_parameter     4095 #define    Max_parameter     4095
 #define    Max_prompt_length 4095 #define    Max_prompt_length 4095
- +
 #define    rep             1 #define    rep             1
 #define    txt             2 #define    txt             2
Línea 227: Línea 155:
 #define    star            8 #define    star            8
 #define    termin          15 #define    termin          15
- +
 void init_globals (void);  void init_globals (void); 
 void free_buffers (void);  void free_buffers (void); 
Línea 260: Línea 188:
 bool find (void);  bool find (void); 
 bool find_back (void); bool find_back (void);
- +
 /* Global variables */ /* Global variables */
- +
 static unsigned long buffer_size = 0UL; static unsigned long buffer_size = 0UL;
 static char *note_file; static char *note_file;
Línea 270: Línea 198:
 static int   max_unit; static int   max_unit;
 static ecce_int pending_sym; static ecce_int pending_sym;
- +
 /* significance of file pointers using the 'buffer gap' method: */ /* significance of file pointers using the 'buffer gap' method: */
- +
 /* [NL] o n e NL t w . . . o NL n e x t NL . . NL l a s t NL [NL] */ /* [NL] o n e NL t w . . . o NL n e x t NL . . NL l a s t NL [NL] */
 /*      !        !   !     !  !                                !  */ /*      !        !   !     !  !                                !  */
Línea 279: Línea 207:
 /*      e        e            n                                n  */ /*      e        e            n                                n  */
 /*      g        g            d                                d  */ /*      g        g            d                                d  */
- +
 /* Note that when the buffer is 100% full, pp and fp are equal, /* Note that when the buffer is 100% full, pp and fp are equal,
    and any insertion operations will fail.  This is valid as    and any insertion operations will fail.  This is valid as
    pp is exclusive and fp is inclusive. */    pp is exclusive and fp is inclusive. */
- +
 /* When editing a secondary input buffer, these pointers are saved /* When editing a secondary input buffer, these pointers are saved
    and re-created within the buffer gap */    and re-created within the buffer gap */
- +
 /* Hamish's implementations forced the top part of the buffer out /* Hamish's implementations forced the top part of the buffer out
    to file when the buffer was full (cf 'makespace()'); this isn't    to file when the buffer was full (cf 'makespace()'); this isn't
    really an option in today's environment.  Alternative choices    really an option in today's environment.  Alternative choices
    are:    are:
- +
    1) crash.  (what we did, prior to 2.7)    1) crash.  (what we did, prior to 2.7)
    2) fail to insert (what we do now)    2) fail to insert (what we do now)
Línea 303: Línea 231:
         to what we had on EMAS) - but the argument against is just         to what we had on EMAS) - but the argument against is just
         a delayed version of (3) above.         a delayed version of (3) above.
- +
    Note that the failure mode of this code is *not* atomic.    Note that the failure mode of this code is *not* atomic.
    A complete 'get line' or 'insert string' operation would fail    A complete 'get line' or 'insert string' operation would fail
Línea 310: Línea 238:
    cost of the buffer-full test.    cost of the buffer-full test.
  */  */
- +
 static cindex fbeg; static cindex fbeg;
 static cindex lbeg; static cindex lbeg;
Línea 317: Línea 245:
 static cindex lend; static cindex lend;
 static cindex fend; static cindex fend;
- +
 static int   type; static int   type;
 static ecce_int command; static ecce_int command;
Línea 345: Línea 273:
 static bool  in_second; static bool  in_second;
 static char *com_prompt; static char *com_prompt;
- +
 static int symtype[256] = { static int symtype[256] = {
    ext+termin,          /*NL*/    ext+termin,          /*NL*/
Línea 493: Línea 421:
    err, err, err, err, err, err, err, err    err, err, err, err, err, err, err, err
 }; };
- +
 static int sym_type(ecce_char c) { static int sym_type(ecce_char c) {
   if ((0 <= c) && (c <= 255)) return symtype[(unsigned int)c];   if ((0 <= c) && (c <= 255)) return symtype[(unsigned int)c];
   return err;   return err;
 } }
- +
 static cindex a; static cindex a;
 static FILE *main_in; static FILE *main_in;
Línea 505: Línea 433:
 static FILE *tty_out; static FILE *tty_out;
 static FILE *log_out; static FILE *log_out;
- +
 static ecce_int *com; static ecce_int *com;
 static int  *link; static int  *link;
Línea 511: Línea 439:
 static long *num; static long *num;
 static long *lim; static long *lim;
- +
 /*****************************************************************************/ /*****************************************************************************/
- +
 static int IntSeen = FALSE; /* set asynchronously by signal routine on ^C */ static int IntSeen = FALSE; /* set asynchronously by signal routine on ^C */
- +
 void gotint(int n) { void gotint(int n) {
   (void)n; /* Supress the annoying 'not used' warning message... */   (void)n; /* Supress the annoying 'not used' warning message... */
   IntSeen = TRUE;   IntSeen = TRUE;
 } }
- +
 int h(char c) { int h(char c) {
   if (('0' <= c) && (c <= '9')) return c - '0';   if (('0' <= c) && (c <= '9')) return c - '0';
   if (('A' <= c) && (c <= 'F')) return c - 'A' + 10;   if (('A' <= c) && (c <= 'F')) return c - 'A' + 10;
   if (('a' <= c) && (c <= 'f')) return c - 'a' + 10;   if (('a' <= c) && (c <= 'f')) return c - 'a' + 10;
-  fprintf(stderr, "%s: hex-command parameter corrupt - char '%c' is not hex\n", ProgName, c);+  fprintf(stderr, "%s: hex-command parámetro corrupto - char '%c' no es hex\n", ProgName, c);
   exit(1);   exit(1);
 } }
- +
 char *hex_to_ascii(char *hex) { char *hex_to_ascii(char *hex) {
   static char commandline[Max_parameter], *f, *t;   static char commandline[Max_parameter], *f, *t;
   if (strlen(hex)/2+3 >= Max_parameter) {   if (strlen(hex)/2+3 >= Max_parameter) {
-    fprintf(stderr, "%s: hex-command parameter was too long.\n", ProgName);+    fprintf(stderr, "%s: hex-command parámetro muy largo.\n", ProgName);
     exit(1);     exit(1);
   }   }
Línea 541: Línea 469:
     c1 = h(*f++);     c1 = h(*f++);
     if (*f == '\0') {     if (*f == '\0') {
-      fprintf(stderr, "%s: hex-command parameter corrupt. (Odd no. of chars)\n", ProgName);+      fprintf(stderr, "%s: hex-command parámetro corrupto. (nro. impar de caracteres)\n", ProgName);
       exit(1);       exit(1);
     }     }
Línea 550: Línea 478:
   return commandline;   return commandline;
 } }
- +
 char *backup_save; char *backup_save;
- +
 int main(int argc, char **argv) { int main(int argc, char **argv) {
   static char backup_save_buf[256+L_tmpnam+1];   static char backup_save_buf[256+L_tmpnam+1];
Línea 558: Línea 486:
   int argno = 1, inoutlog = 0;   int argno = 1, inoutlog = 0;
   char *s;   char *s;
- +
 #ifdef WANT_UTF8 #ifdef WANT_UTF8
   /* If your native locale doesn't use UTF-8 encoding    /* If your native locale doesn't use UTF-8 encoding 
Línea 566: Línea 494:
   char *locale = setlocale(LC_ALL, "");   char *locale = setlocale(LC_ALL, "");
 #endif #endif
- +
   backup_save = tmpnam(backup_save_buf);  /*SYS*/   backup_save = tmpnam(backup_save_buf);  /*SYS*/
- +
   /* Historical code, not really needed nowadays as   /* Historical code, not really needed nowadays as
      people only use Windows and Unix variants :-( */      people only use Windows and Unix variants :-( */
- +  
   ProgName = argv[0];   ProgName = argv[0];
   s = strrchr(ProgName, '/');   s = strrchr(ProgName, '/');
Línea 580: Línea 508:
   ProgName = malloc(strlen(s)+1); strcpy(ProgName, s);   ProgName = malloc(strlen(s)+1); strcpy(ProgName, s);
   s = strchr(ProgName, '.'); if (s != NULL) *s = '\0';   s = strchr(ProgName, '.'); if (s != NULL) *s = '\0';
- +
   /* decode argv into parameter[0..3] and buffer_size */   /* decode argv into parameter[0..3] and buffer_size */
   for (;;) {   for (;;) {
Línea 587: Línea 515:
       int offset = 1;       int offset = 1;
       if (argv[argno][1] == '-') offset += 1;       if (argv[argno][1] == '-') offset += 1;
-      if (strcmp(argv[argno]+offset, "from") == 0) {+      if (strcmp(argv[argno]+offset, "desde") == 0) {
         parameter[F] = argv[argno+1];         parameter[F] = argv[argno+1];
-      } else if (strcmp(argv[argno]+offset, "to") == 0) {+      } else if (strcmp(argv[argno]+offset, "a") == 0) {
         parameter[T] = argv[argno+1];         parameter[T] = argv[argno+1];
       } else if (strcmp(argv[argno]+offset, "log") == 0) {       } else if (strcmp(argv[argno]+offset, "log") == 0) {
Línea 595: Línea 523:
       } else if (strcmp(argv[argno]+offset, "hex-command") == 0) {       } else if (strcmp(argv[argno]+offset, "hex-command") == 0) {
         if (parameter[C] != NULL) {         if (parameter[C] != NULL) {
-          fprintf(stderr, "%s: only one -hex-command \"...\" or -command \"...\" is allowed\n", ProgName);+          fprintf(stderr, "%s: solo un -hex-command \"...\" o -comando \"...\" se permite\n", ProgName);
           exit(1);           exit(1);
         }         }
Línea 611: Línea 539:
         buffer_size = strtoul(buf_size_str, &endptr, 10);         buffer_size = strtoul(buf_size_str, &endptr, 10);
         if (errno != 0) {         if (errno != 0) {
-          fprintf(stderr, "%s: parámetro de tamaño malo '%s'\n", ProgName, buf_size_str);+          fprintf(stderr, "%s: parámetro de tamaño incorrecto '%s'\n", ProgName, buf_size_str);
           exit(1);           exit(1);
  }  }
Línea 622: Línea 550:
    } else {    } else {
             fprintf(stderr,             fprintf(stderr,
-                    "%s: tipo de unidad mala '%s' (espero %luK o %luM)\n",+                    "%s: tipo incorrecto de unidad '%s' (se espera %luK o %luM)\n",
                     ProgName, endptr, buffer_size, buffer_size);                     ProgName, endptr, buffer_size, buffer_size);
             exit(1);             exit(1);
Línea 629: Línea 557:
       } else {       } else {
         fprintf (stderr,         fprintf (stderr,
-                 "%s: opción desconocida'%s'\n",+                 "%s: Opción desconocida '%s'\n",
  ProgName, argv[argno]);  ProgName, argv[argno]);
         exit(1);         exit(1);
Línea 639: Línea 567:
     }     }
   }   }
- +
   if (buffer_size == 0UL) buffer_size = estimate_buffer_size(parameter[F]);   if (buffer_size == 0UL) buffer_size = estimate_buffer_size(parameter[F]);
    parameter[F] = argv[1];    parameter[F] = argv[1];
- +
    if (parameter[F] == NULL) {    if (parameter[F] == NULL) {
       fprintf (stderr,       fprintf (stderr,
-         "%s: {-from} fichero_entrada {{-to} fichero_salida}? {-log archivo}? {-{hex-}command 'comandos;%%c'} {-size bytes}?\n",+         "%s: {-desde} fichero_entrada {{-to} fichero_salida}? {-log fichero}? {-{hex-}comando 'comandos;%%c'} {-tamaño_ bytes}?\n",
           ProgName);           ProgName);
       exit (30);       exit (30);
    }    }
- +
    IntSeen = FALSE;    IntSeen = FALSE;
- +
    tty_in = stdin;    tty_in = stdin;
    tty_out = stderr;    tty_out = stderr;
- +
    if ((strcmp(parameter[F], "-") == 0) || (strcmp(parameter[F], "/dev/stdin") == 0)) {  /*SYS*/    if ((strcmp(parameter[F], "-") == 0) || (strcmp(parameter[F], "/dev/stdin") == 0)) {  /*SYS*/
       /* If the input file is stdin, you cannot read commands from stdin as well. */       /* If the input file is stdin, you cannot read commands from stdin as well. */
       if (commandp == NULL) {       if (commandp == NULL) {
-        fprintf(stderr, "%s: \"-command '...'\" opción requerida cuando el fichero de entrada es la entrada estándar\n", ProgName); exit(1);+        fprintf(stderr, "%s: \"-comando '...'\" opción requerida cuando el fichero de entrada es la entrada estándar\n", ProgName); exit(1);
       }        } 
       main_in = stdin;       main_in = stdin;
Línea 665: Línea 593:
       tty_in = fopen("/dev/tty", "rb"); /*SYS*/       tty_in = fopen("/dev/tty", "rb"); /*SYS*/
       if (tty_in) {       if (tty_in) {
- fprintf(stderr, "%s: usando /dev/tty para la entrada de comando\n", ProgName);+ fprintf(stderr, "%s: usando /dev/tty para entrada de comando\n", ProgName);
       } else {       } else {
             tty_in = fopen("CON:", "r");             tty_in = fopen("CON:", "r");
             if (tty_in) {              if (tty_in) { 
-        fprintf(stderr, "%s: using CON: for command input\n", ProgName);+        fprintf(stderr, "%s: usando CON: para entrada de comando\n", ProgName);
      } else {      } else {
                tty_in = fopen("/dev/null", "rb");                tty_in = fopen("/dev/null", "rb");
                if (tty_in == NULL) tty_in = fopen("NUL:", "rb");                if (tty_in == NULL) tty_in = fopen("NUL:", "rb");
-        fprintf(stderr, "%s: cuidado - no hay cadena de entrada de comando\n", ProgName);+        fprintf(stderr, "%s: cuidado - no hay cadena de entrado de comando\n", ProgName);
                if (tty_in == NULL) tty_in = stdin; /* It'll be EOF by the time it is used */                if (tty_in == NULL) tty_in = stdin; /* It'll be EOF by the time it is used */
      }      }
Línea 680: Línea 608:
       main_in = fopen (parameter[F], "rb");       main_in = fopen (parameter[F], "rb");
    }    }
- +
    if (main_in == NULL) {    if (main_in == NULL) {
       fprintf (stderr, "Fichero \"%s\" no encontrado\n", parameter[F]);       fprintf (stderr, "Fichero \"%s\" no encontrado\n", parameter[F]);
       exit (30);       exit (30);
    }    }
- +
    if (parameter[L] == NULL) {    if (parameter[L] == NULL) {
       log_out = NULL;       log_out = NULL;
Línea 691: Línea 619:
       log_out = fopen (parameter[L], "wb");       log_out = fopen (parameter[L], "wb");
       if (log_out == NULL) {       if (log_out == NULL) {
-         fprintf (stderr, "%s: Advertencia - No puedo crear \"%s\"\n",+         fprintf (stderr, "%s: Cuidado - No puedo crear \"%s\"\n",
           ProgName, parameter[L]);           ProgName, parameter[L]);
       }       }
    }    }
- +
    init_globals ();    init_globals ();
- +
    a[0]           = '\n';    a[0]           = '\n';
    a[buffer_size] = '\n';    a[buffer_size] = '\n';
- +
    fprintf (tty_out, "Ecce\n");    fprintf (tty_out, "Ecce\n");
- +
    if (main_in != NULL) load_file ();    if (main_in != NULL) load_file ();
- +
    signal(SIGINT, &gotint);    signal(SIGINT, &gotint);
- +
    percent ('E'); /* Select either-case searches, case-flipping C command. */    percent ('E'); /* Select either-case searches, case-flipping C command. */
    for (;;) {    for (;;) {
Línea 716: Línea 644:
          if (!printed) execute_command ();          if (!printed) execute_command ();
       }       }
- +
       if (IntSeen) {       if (IntSeen) {
         signal(SIGINT, &gotint);         signal(SIGINT, &gotint);
- +
         IntSeen = FALSE;         IntSeen = FALSE;
         fprintf(stderr, "* Escape!\n");         fprintf(stderr, "* Escape!\n");
       }       }
- +
    }    }
 } }
- +
 void init_globals (void) { void init_globals (void) {
- +
    a = malloc ((buffer_size+1) * sizeof(ecce_char));    a = malloc ((buffer_size+1) * sizeof(ecce_char));
- +
    note_file = malloc (Max_parameter+1);    note_file = malloc (Max_parameter+1);
- +
    com  = (ecce_int *) malloc ((Max_command_units+1)*sizeof(ecce_int));    com  = (ecce_int *) malloc ((Max_command_units+1)*sizeof(ecce_int));
    link = (int *) malloc ((Max_command_units+1)*sizeof(int));    link = (int *) malloc ((Max_command_units+1)*sizeof(int));
    text = (ecce_char *) malloc ((Max_command_units+1) * sizeof(ecce_char));    text = (ecce_char *) malloc ((Max_command_units+1) * sizeof(ecce_char));
- +
    num = (long *) malloc ((Max_command_units+1)*sizeof(long));    num = (long *) malloc ((Max_command_units+1)*sizeof(long));
    lim = (long *) malloc ((Max_command_units+1)*sizeof(long));    lim = (long *) malloc ((Max_command_units+1)*sizeof(long));
- +
    com_prompt = malloc (Max_prompt_length+1);    com_prompt = malloc (Max_prompt_length+1);
- +
    if (a == NULL || note_file == NULL || com == NULL ||    if (a == NULL || note_file == NULL || com == NULL ||
     link == NULL || text == NULL || num == NULL || lim == NULL ||     link == NULL || text == NULL || num == NULL || lim == NULL ||
     com_prompt == NULL) {     com_prompt == NULL) {
-      fprintf (stderr, "Imposible reclamar el espacio de buffer\n");+      fprintf (stderr, "Incapaz de referir espacio de almacenamiento\n");
       free_buffers();       free_buffers();
       exit (40);       exit (40);
    }    }
-  + 
-   fprintf (stderr, "Espacio de buffer = %d KBytes\n", (int)(buffer_size>>10)); +   fprintf (stderr, "Espacio de Almacén = %d KBytes\n", (int)(buffer_size>>10)); 
-  + 
- +
    fbeg = a+1;    fbeg = a+1;
    lbeg = fbeg;    lbeg = fbeg;
Línea 765: Línea 693:
    pending_sym = '\n';    pending_sym = '\n';
    blank_line = TRUE;    blank_line = TRUE;
- +
    (void)strcpy (note_file, NOTE_FILE);    (void)strcpy (note_file, NOTE_FILE);
    noted = NULL;    noted = NULL;
Línea 772: Línea 700:
    (void)strcpy (com_prompt, ">");    (void)strcpy (com_prompt, ">");
 } }
- +
 void free_buffers (void) { /* only needed if checking that we have no heap lossage at end */ void free_buffers (void) { /* only needed if checking that we have no heap lossage at end */
   if (a) free (a); a = NULL;   if (a) free (a); a = NULL;
Línea 784: Línea 712:
   if (ProgName) free (ProgName); ProgName = NULL;   if (ProgName) free (ProgName); ProgName = NULL;
 } }
- +
 void local_echo (ecce_int *sym) {       /* Later, make this a char fn. */ void local_echo (ecce_int *sym) {       /* Later, make this a char fn. */
    ecce_int lsym;    ecce_int lsym;
- +
    if (commandp) {    if (commandp) {
       lsym = *commandp;       lsym = *commandp;
Línea 798: Línea 726:
       return;       return;
    }    }
- +
    if (blank_line) {fprintf(tty_out, "%s", eprompt); fflush(tty_out); }    /* stderr usually unbuffered, but flush needed for cygwin */    if (blank_line) {fprintf(tty_out, "%s", eprompt); fflush(tty_out); }    /* stderr usually unbuffered, but flush needed for cygwin */
- +
    lsym = fgetwc (tty_in);    lsym = fgetwc (tty_in);
    if (IntSeen) {    if (IntSeen) {
Línea 809: Línea 737:
      fputwc('^', tty_out); fputwc('C', tty_out); fputwc('\n', tty_out);      fputwc('^', tty_out); fputwc('C', tty_out); fputwc('\n', tty_out);
    }    }
- +   
    if (lsym == WEOF) {    if (lsym == WEOF) {
- +
       IntSeen = FALSE;       IntSeen = FALSE;
       signal(SIGINT, SIG_IGN);       signal(SIGINT, SIG_IGN);
       fputwc('\n', tty_out); /* Undo the prompt */       fputwc('\n', tty_out); /* Undo the prompt */
- +
       percent ('c');       percent ('c');
       exit (50);       exit (50);
    }    }
- +
    if (log_out != NULL) {    if (log_out != NULL) {
       fputwc (lsym, log_out);       fputwc (lsym, log_out);
Línea 826: Línea 754:
    *sym = lsym;    *sym = lsym;
 } }
- +
 void read_sym (void) { void read_sym (void) {
    if (pending_sym == 0) {    if (pending_sym == 0) {
Línea 836: Línea 764:
    }    }
 } }
- +
 bool fail_with (char *mess, ecce_int culprit) { bool fail_with (char *mess, ecce_int culprit) {
  int dirn_sign;  int dirn_sign;
- +
    if (('a' <= culprit) && (culprit <= 'z')) {    if (('a' <= culprit) && (culprit <= 'z')) {
       dirn_sign = '-';       dirn_sign = '-';
Línea 856: Línea 784:
    return (ok = FALSE);    return (ok = FALSE);
 } }
-  + 
- +
 void read_item(void) { void read_item(void) {
    ecce_int saved_digit;    ecce_int saved_digit;
Línea 864: Línea 792:
    type = sym_type(sym);    type = sym_type(sym);
    if ((type & ext) == 0) return;    if ((type & ext) == 0) return;
- +
    switch (type & 15) {    switch (type & 15) {
- +
       case star:       case star:
          number = 0L;          number = 0L;
          return;          return;
- +
       case pling:       case pling:
          number = stopper-1;          number = stopper-1;
          return;          return;
- +
       case dig:       case dig:
          saved_digit = sym;          saved_digit = sym;
Línea 885: Línea 813:
          sym = saved_digit; /* for printing in errors */          sym = saved_digit; /* for printing in errors */
          return;          return;
- +
       default:       default:
          return;          return;
    }    }
 } }
- +
 void percent (ecce_int Command_sym) { void percent (ecce_int Command_sym) {
    static int note_sec = '0'; /* This one MUST be a static */    static int note_sec = '0'; /* This one MUST be a static */
Línea 900: Línea 828:
    ok = TRUE;    ok = TRUE;
    if (!isalpha(Command_sym)) {    if (!isalpha(Command_sym)) {
-      (void) fail_with ("letter for", '%');+      (void) fail_with ("letra para", '%');
       return;       return;
    }    }
    switch (Command_sym) {    switch (Command_sym) {
- +
       case 'L':       case 'L':
          to_upper_case = ~0;          to_upper_case = ~0;
Línea 911: Línea 839:
          caseflip = 0;          caseflip = 0;
          break;          break;
- +
       case 'U':       case 'U':
          to_upper_case = ~casebit;          to_upper_case = ~casebit;
Línea 918: Línea 846:
          caseflip = 0;          caseflip = 0;
          break;          break;
- +
       case 'N':       case 'N':
          to_upper_case = ~0;          to_upper_case = ~0;
Línea 924: Línea 852:
          caseflip = casebit;          caseflip = casebit;
          break;          break;
- +
       case 'E':       case 'E':
          to_upper_case = ~casebit; /* Only for searches - not in C command */          to_upper_case = ~casebit; /* Only for searches - not in C command */
Línea 937: Línea 865:
          fprintf (tty_out, " en C %s\n", DATE+7);          fprintf (tty_out, " en C %s\n", DATE+7);
          break;          break;
- +
       case 'W':       case 'W':
  if ((strcmp(parameter[parameter[T] == NULL ? F : T], "-") == 0) ||  if ((strcmp(parameter[parameter[T] == NULL ? F : T], "-") == 0) ||
             ((parameter[T] != NULL) && (strcmp(parameter[T], "/dev/stdout") == 0))) { /*SYS*/             ((parameter[T] != NULL) && (strcmp(parameter[T], "/dev/stdout") == 0))) { /*SYS*/
-           fprintf(stderr, "* %%W is not allowed when the output file is stdout\n");+           fprintf(stderr, "* %%W no está permitido cuando la salida del fichero es stdout\n");
     break;     break;
  }  }
       case 'C':       case 'C':
          do { read_sym (); } while (sym_type(sym) != sym_type(';'));          do { read_sym (); } while (sym_type(sym) != sym_type(';'));
- +   
       case 'c':       case 'c':
- +
          if (parameter[T] == NULL) {          if (parameter[T] == NULL) {
             inoutlog = F;         /* So use input file as output file */             inoutlog = F;         /* So use input file as output file */
Línea 954: Línea 882:
             inoutlog = T;             inoutlog = T;
          }          }
- +
          if (in_second) { /* Copied bit */          if (in_second) { /* Copied bit */
          /*************** This block is copied from the %S code below;          /*************** This block is copied from the %S code below;
Línea 964: Línea 892:
             (void)strcpy (com_prompt, ">");             (void)strcpy (com_prompt, ">");
             if (sec_out == NULL) {             if (sec_out == NULL) {
-               (void) fail_with ("No puedo salvar contexto", ' ');+               (void) fail_with ("No puedo guardar contexto", ' ');
                break;                break;
             }             }
Línea 996: Línea 924:
             if (main_out == NULL) {             if (main_out == NULL) {
                fprintf(stderr,                fprintf(stderr,
-                       "Lo siento - No puedo salvar su edición (incluso %s falló)\n", backup_save);+                       "Lo siento, no puedo guardar su edición (incluso %s ha fallado)\n", backup_save);
                exit(90);                exit(90);
             }             }
Línea 1007: Línea 935:
             if (main_out == NULL) {             if (main_out == NULL) {
                fprintf (stderr,                fprintf (stderr,
-                        "No puedo crear \"%s\" - intento salvar en %s en su lugar\n",+                        "No puedo crear \"%s\" - intento guardarlo en %s en su lugar\n",
                         parameter[inoutlog], backup_save);                         parameter[inoutlog], backup_save);
                main_out = fopen (backup_save, "w");                main_out = fopen (backup_save, "w");
                if (main_out == NULL) {                if (main_out == NULL) {
-                 fprintf(stderr, "No puedo salvar el fichero de ninguna forma. Me rindo. Lo siento!\n");+                 fprintf(stderr, "Imposible guardar fichero de todos modos. Me rindo. Lo siento!\n");
                  exit(1);                  exit(1);
         }         }
Línea 1017: Línea 945:
                if (inoutlog == T) {                if (inoutlog == T) {
                   fprintf (tty_out,                   fprintf (tty_out,
-                           "Ecce: Guardando %s a %s.\n", parameter[F], parameter[T]);+                           "Ecce %s a %s completando.\n", parameter[F], parameter[T]);
                } else {                } else {
-                  fprintf (tty_out, "Ecce: Guardando %s.\n", parameter[F]);+                  fprintf (tty_out, "Ecce %s completando.\n", parameter[F]);
                }                }
             }             }
          }          }
- +
          P = fbeg;          P = fbeg;
          for (;;) {          for (;;) {
Línea 1031: Línea 959:
          }          }
          if (main_out != stdout) fclose (main_out);          if (main_out != stdout) fclose (main_out);
- +
          if (Command_sym == 'W') {          if (Command_sym == 'W') {
             pending_sym = '\n';             pending_sym = '\n';
             break;             break;
          }          }
- +
          if (log_out != NULL) {          if (log_out != NULL) {
             fclose (log_out);             fclose (log_out);
          }          }
-/*         fprintf (tty_out, "Ecce completado\n");      */+/*         fprintf (tty_out, "Ecce complete\n");      */
          free_buffers ();          free_buffers ();
          exit (0);          exit (0);
- +
       case 'A':       case 'A':
          if (log_out != NULL) {          if (log_out != NULL) {
Línea 1051: Línea 979:
          free_buffers ();          free_buffers ();
          exit (60);          exit (60);
- +
       case 'S':       case 'S':
          local_echo (&sec_no);          local_echo (&sec_no);
Línea 1091: Línea 1019:
             (void)strcpy (com_prompt, ">");             (void)strcpy (com_prompt, ">");
             if (sec_out == NULL) {             if (sec_out == NULL) {
-               (void) fail_with ("No puedo salvar contexto", ' ');+               (void) fail_with ("No puede guardar contexto", ' ');
                return;                return;
             }             }
Línea 1124: Línea 1052:
             if (sec_in == NULL) {             if (sec_in == NULL) {
                if (file_wanted) {                if (file_wanted) {
-                  (void) fail_with ("No puedo abrir fichero", ' ');+                  (void) fail_with ("No puede abrir fichero", ' ');
                } else {                } else {
-                  (void) fail_with ("Contexto desconocido", sec_no);+                  (void) fail_with ("Context desconocido", sec_no);
                }                }
                return;                return;
Línea 1134: Línea 1062:
             in_second = TRUE;             in_second = TRUE;
             *pp = '\n';             *pp = '\n';
- +
             fbeg = pp + 1;             fbeg = pp + 1;
             fend = fp - 1;             fend = fp - 1;
Línea 1147: Línea 1075:
                *P++ = sym;                *P++ = sym;
                if (P == fend) {                if (P == fend) {
-                  (void) fail_with ("%S corrupto - no ha espacio", ' ');+                  (void) fail_with ("%S corrupto - sin espacio", ' ');
                   fclose (sec_in);                   fclose (sec_in);
                   return;                   return;
Línea 1158: Línea 1086:
          }          }
          break;          break;
- +
       default:       default:
          (void) fail_with ("Porciento", Command_sym);          (void) fail_with ("Porciento", Command_sym);
Línea 1164: Línea 1092:
    do { read_sym(); } while (sym_type(sym) != sym_type(';'));    do { read_sym(); } while (sym_type(sym) != sym_type(';'));
 } }
- +
 void unchain(void) { void unchain(void) {
    do {    do {
Línea 1173: Línea 1101:
    } while (com[pointer] != '(');    } while (com[pointer] != '(');
 } }
- +
 void stack(void) { void stack(void) {
    com[this_unit]  = command;    com[this_unit]  = command;
Línea 1181: Línea 1109:
    this_unit++;    this_unit++;
 } }
- +
 void execute_command(void) { void execute_command(void) {
    cindex i;    cindex i;
    ecce_int sym;    ecce_int sym;
- +
    ok = TRUE;    ok = TRUE;
    switch (command & (~plusbit)) {    switch (command & (~plusbit)) {
- +
       case 'p':       case 'p':
       case 'P':       case 'P':
Línea 1225: Línea 1153:
          }          }
          return;          return;
- +
       case 'g':       case 'g':
       case 'G':       case 'G':
          local_echo (&sym);          local_echo (&sym);
- +
          if (sym == ':') {          if (sym == ':') {
             local_echo (&sym);             local_echo (&sym);
Línea 1240: Línea 1168:
          left_star();          left_star();
          for (;;) {          for (;;) {
-            if (pp == fp) /* LLENO! */ { ok = FALSE; } else *pp++ = sym;+            if (pp == fp) /* FULL! */ { ok = FALSE; } else *pp++ = sym;
             if (sym == '\n') break;             if (sym == '\n') break;
             local_echo (&sym);             local_echo (&sym);
Línea 1250: Línea 1178:
          }          }
          return;          return;
- +
       case 'E':       case 'E':
          if (fp == lend) {          if (fp == lend) {
Línea 1261: Línea 1189:
          } else fp++;          } else fp++;
          return;          return;
- +
       case 'e':       case 'e':
          if (pp == lbeg) {          if (pp == lbeg) {
Línea 1272: Línea 1200:
          } else --pp;          } else --pp;
          return;          return;
- +
       case 'C':       case 'C':
          if (fp == lend) {          if (fp == lend) {
Línea 1289: Línea 1217:
          }          }
          return;          return;
- +
       case 'c':       case 'c':
          if (pp == lbeg) {          if (pp == lbeg) {
Línea 1306: Línea 1234:
          }          }
          return;          return;
- +
       case 'l':       case 'l':
       case 'R':       case 'R':
Línea 1315: Línea 1243:
          ms_back = NULL;          ms_back = NULL;
          return;          return;
- +
       case 'r':       case 'r':
       case 'L':       case 'L':
Línea 1324: Línea 1252:
          ms = NULL;          ms = NULL;
          return;          return;
- +
       case 'B':       case 'B':
-         if (pp == fp) /* LLENO! */ { ok = FALSE; return; }+         if (pp == fp) /* FULL! */ { ok = FALSE; return; }
          *pp++ = '\n';          *pp++ = '\n';
          lbeg = pp;          lbeg = pp;
          return;          return;
- +
       case 'b':       case 'b':
-         if (pp == fp) /* LLENO! */ { ok = FALSE; return; }+         if (pp == fp) /* FULL! */ { ok = FALSE; return; }
          *--fp = '\n';          *--fp = '\n';
          lend = fp;          lend = fp;
          return;          return;
- +
       case 'J':       case 'J':
          right_star();          right_star();
Línea 1347: Línea 1275:
             lend++;             lend++;
          return;          return;
- +
       case 'j':       case 'j':
          left_star();          left_star();
Línea 1358: Línea 1286:
          lbeg++;          lbeg++;
          return;          return;
- +
       case 'M':       case 'M':
          if (repeat_count == 0L) {          if (repeat_count == 0L) {
Línea 1367: Línea 1295:
          }          }
          return;          return;
- +
       case 'm':       case 'm':
          if (repeat_count == 0L) {          if (repeat_count == 0L) {
Línea 1376: Línea 1304:
          }          }
          return;          return;
- +
       case 'k':       case 'k':
       case 'K':       case 'K':
Línea 1392: Línea 1320:
          while (*lend != '\n') lend++;          while (*lend != '\n') lend++;
          return;          return;
- +
       case 'V':       case 'V':
          (void) verify ();          (void) verify ();
          return;          return;
- +
       case 'v':       case 'v':
          (void) verify_back ();          (void) verify_back ();
          return;          return;
- +
       case 'F':       case 'F':
          (void) find ();          (void) find ();
          return;          return;
- +
       case 'f':       case 'f':
          (void) find_back ();          (void) find_back ();
          return;          return;
- +
       case 'U':       case 'U':
          if (!find ()) return;          if (!find ()) return;
Línea 1416: Línea 1344:
          lbeg++;          lbeg++;
          return;          return;
- +
       case 'u':       case 'u':
          if (!find_back ()) return;          if (!find_back ()) return;
Línea 1424: Línea 1352:
             lend++;             lend++;
          return;          return;
- +
       case 'D':       case 'D':
          if (!find ()) return;          if (!find ()) return;
Línea 1430: Línea 1358:
          ms = fp;          ms = fp;
          return;          return;
- +
       case 'd':       case 'd':
          if (!find_back ()) return;          if (!find_back ()) return;
Línea 1436: Línea 1364:
          ms_back = pp;          ms_back = pp;
          return;          return;
- +
       case 'T':       case 'T':
          if (!find ()) return;          if (!find ()) return;
          while (fp != ml) *pp++ = *fp++;          while (fp != ml) *pp++ = *fp++;
          return;          return;
- +
       case 't':       case 't':
          if (!find_back ()) return;          if (!find_back ()) return;
          while (pp != ml_back) *--fp = *--pp;          while (pp != ml_back) *--fp = *--pp;
          return;          return;
- +
       case 'I':       case 'I':
          insert ();          insert ();
          return;          return;
- +
       case 'i':       case 'i':
          insert_back ();          insert_back ();
          return;          return;
- +
       case 's':       case 's':
       case 'S':       case 'S':
Línea 1471: Línea 1399:
          }          }
          return;          return;
- +
       case '(':       case '(':
          num[pointer] = repeat_count;          num[pointer] = repeat_count;
          repeat_count = 1L;          repeat_count = 1L;
          return;          return;
- +
       case ')':       case ')':
          --(num[this_unit]);          --(num[this_unit]);
Línea 1484: Línea 1412:
          repeat_count = 1L;          repeat_count = 1L;
          return;          return;
- +
       case '\\':       case '\\':
          ok = FALSE;          ok = FALSE;
          return;          return;
- +
       case '?':       case '?':
          return;          return;
- +
       case ',':       case ',':
          this_unit = pointer - 1;          this_unit = pointer - 1;
          return;          return;
- +
       case 'N':       case 'N':
          noted = pp;          noted = pp;
          changes = fp-pp;          changes = fp-pp;
          return;          return;
- +
       case 'A':       case 'A':
          if ((noted == NULL)          if ((noted == NULL)
Línea 1512: Línea 1440:
             FILE *note_out = fopen (note_file, "wb");             FILE *note_out = fopen (note_file, "wb");
             cindex p = noted;             cindex p = noted;
- +
             if (note_out == NULL) {             if (note_out == NULL) {
                ok = FALSE;                ok = FALSE;
                return;                return;
             }             }
- +
             do {             do {
                fputwc (*p++, note_out);                fputwc (*p++, note_out);
             } while (p != pp);             } while (p != pp);
- +
             fclose (note_out);             fclose (note_out);
- +
             pp = noted;             pp = noted;
             lbeg = pp;             lbeg = pp;
Línea 1531: Línea 1459:
          noted = NULL;          noted = NULL;
          return;          return;
- +
       case 'H':       case 'H':
          note_file[CONTEXT_OFFSET] = lim[this_unit]+'0';          note_file[CONTEXT_OFFSET] = lim[this_unit]+'0';
Línea 1540: Línea 1468:
                return;                return;
             }             }
- +
             { cindex p = pp;             { cindex p = pp;
- +
                for (;;) {                for (;;) {
                   sym = fgetwc(note_in);                   sym = fgetwc(note_in);
Línea 1560: Línea 1488:
          }          }
          return;          return;
- +
       default:       default:
-         (void) fail_with ("Comando no reconocido", command);+         (void) fail_with ("Comando desconocido", command);
          return;          return;
    }    }
 } }
- +
 void Scan_sign(void) { void Scan_sign(void) {
    read_sym ();    read_sym ();
Línea 1578: Línea 1506:
    }    }
 } }
- +
 void Scan_scope(void) {                      /* ditto macro */ void Scan_scope(void) {                      /* ditto macro */
    ecce_int uppercase_command = command & (~(minusbit | plusbit));    ecce_int uppercase_command = command & (~(minusbit | plusbit));
Línea 1589: Línea 1517:
    }    }
 } }
- + 
 void Scan_text(void) { void Scan_text(void) {
    ecce_int last;    ecce_int last;
- +
    read_sym ();    read_sym ();
    last = sym;    last = sym;
Línea 1627: Línea 1555:
    ok = TRUE;    ok = TRUE;
 } }
- +
 void Scan_repeat (void) { void Scan_repeat (void) {
    number = 1L;    number = 1L;
Línea 1634: Línea 1562:
    repeat_count = number;    repeat_count = number;
 } }
- +
 bool analyse (void) { bool analyse (void) {
    int saved_type;    int saved_type;
- +
    ok = TRUE;    ok = TRUE;
    pos = 0;    pos = 0;
Línea 1690: Línea 1618:
       } else {       } else {
          switch (type & 15) {          switch (type & 15) {
- +
             case termin:             case termin:
                pending_sym = '\n';  /* for skipping on error */                pending_sym = '\n';  /* for skipping on error */
                unchain ();                unchain ();
                if (pointer >= 0) {                if (pointer >= 0) {
-                  return (fail_with ("Missing", ')'));+                  return (fail_with ("Faltante", ')'));
                }                }
                max_unit = this_unit;                max_unit = this_unit;
Línea 1704: Línea 1632:
                stack ();                stack ();
                return (ok);                return (ok);
- +
             case lpar:             case lpar:
                command = '(';                command = '(';
Línea 1710: Línea 1638:
                last_unit = this_unit;                last_unit = this_unit;
                break;                break;
- +
             case comma:             case comma:
                command = ',';                command = ',';
Línea 1716: Línea 1644:
                last_unit = this_unit;                last_unit = this_unit;
                break;                break;
- +
             case rpar:             case rpar:
                command = ')';                command = ')';
Línea 1733: Línea 1661:
    }  /* on items */    }  /* on items */
 } }
- +
 void load_file (void) { void load_file (void) {
    cindex p = fbeg;    cindex p = fbeg;
    ecce_int sym;    ecce_int sym;
- +
    sym = fgetwc(main_in);    sym = fgetwc(main_in);
    while (sym != WEOF) {    while (sym != WEOF) {
Línea 1743: Línea 1671:
         *p++ = sym;         *p++ = sym;
         if (p == fend) {         if (p == fend) {
-           fprintf (stderr, "* File too large!\n");+           fprintf (stderr, "* Fichero muy grande!\n");
            percent ('A');            percent ('A');
         }         }
       }       }
- +
       sym = fgetwc(main_in);       sym = fgetwc(main_in);
 #ifdef WANT_UTF8 #ifdef WANT_UTF8
       if (errno == EILSEQ) {       if (errno == EILSEQ) {
- fprintf(stderr, "Se hencontró un caracter ancho. Puede necesitar usar: export LC_ALL=en_US.UTF-8\n");  /*SYS*/+ fprintf(stderr, "Se encontró un caracter ancho inválido. Puede necesitar ejecutar: export LC_ALL=en_US.UTF-8\n");  /*SYS*/
  exit(1);                                                  exit(1);                                                
       }       }
Línea 1757: Línea 1685:
    }    }
    fclose (main_in);    fclose (main_in);
- +
    while (p != fbeg) *--fp = *--p;    while (p != fbeg) *--fp = *--p;
    lend = fp;    lend = fp;
Línea 1763: Línea 1691:
       lend++;       lend++;
 } }
- +
 bool execute_unit (void) { bool execute_unit (void) {
    ecce_int culprit;    ecce_int culprit;
- +
    command = com[this_unit];    command = com[this_unit];
    culprit = command;    culprit = command;
    pointer = link[this_unit];    pointer = link[this_unit];
- +
    repeat_count = num[this_unit];    repeat_count = num[this_unit];
    for (;;) {  /* On repeats of this_unit */    for (;;) {  /* On repeats of this_unit */
Línea 1808: Línea 1736:
             command = com[this_unit];             command = com[this_unit];
             switch (command) {             switch (command) {
- +
                case '(':                case '(':
                   this_unit = link[this_unit];                   this_unit = link[this_unit];
                   break; /* Skip over (...) as if it were single command. */                   break; /* Skip over (...) as if it were single command. */
- +
                case ',':                case ',':
                   return (ok);                   return (ok);
- +
                case ')': /* Should test for '\\' and '?' following? */                case ')': /* Should test for '\\' and '?' following? */
                   --num[this_unit];                   --num[this_unit];
Línea 1826: Línea 1754:
                   /* rely on enclosing for-loop to handle \ and ? correctly! */                   /* rely on enclosing for-loop to handle \ and ? correctly! */
                   goto breaklab;                   goto breaklab;
- +
                default: /* Possible bugfix - what happens on missing cases? */;                default: /* Possible bugfix - what happens on missing cases? */;
             }             }
             if (com[this_unit] == 0) {/* 0 denotes end of command-line. */             if (com[this_unit] == 0) {/* 0 denotes end of command-line. */
-               return (fail_with ("Fracaso:", culprit));+               return (fail_with ("Fallo:", culprit));
             }             }
          }  /* end of seq */          }  /* end of seq */
Línea 1837: Línea 1765:
    } /* executing repeats */    } /* executing repeats */
 } }
- +
 void execute_all (void) { void execute_all (void) {
    eprompt = ":";    eprompt = ":";
Línea 1852: Línea 1780:
    ok = TRUE;    ok = TRUE;
 } }
- +
 /* All of the following could be static inlines under GCC, or /* All of the following could be static inlines under GCC, or
    I might recode some of them as #define'd macros */    I might recode some of them as #define'd macros */
- +
 ecce_int case_op (ecce_int sym) {               /* should be made a macro */ ecce_int case_op (ecce_int sym) {               /* should be made a macro */
    int chr = sym | casebit;    int chr = sym | casebit;
Línea 1872: Línea 1800:
    return (sym);    return (sym);
 } }
- +
 bool right (void) { bool right (void) {
    if (fp == lend) {    if (fp == lend) {
Línea 1880: Línea 1808:
    return (ok = TRUE);    return (ok = TRUE);
 } }
- +
 bool left (void) { bool left (void) {
    if (pp == lbeg) {    if (pp == lbeg) {
Línea 1888: Línea 1816:
    return (ok = TRUE);    return (ok = TRUE);
 } }
- +
 void right_star(void) {                      /* Another macro */ void right_star(void) {                      /* Another macro */
    while (fp != lend) *pp++ = *fp++;    while (fp != lend) *pp++ = *fp++;
 } }
- +
 void left_star(void) {                       /* Likewise... */ void left_star(void) {                       /* Likewise... */
    while (pp != lbeg) *--fp = *--pp;    while (pp != lbeg) *--fp = *--pp;
 } }
- +
 void move (void) { void move (void) {
    ok = TRUE;    ok = TRUE;
Línea 1910: Línea 1838:
    ms_back = NULL;    ms_back = NULL;
 } }
- +
 void move_back(void) { void move_back(void) {
    ok = TRUE;    ok = TRUE;
Línea 1925: Línea 1853:
    ms = NULL;    ms = NULL;
 } }
- +
 void move_star (void) { void move_star (void) {
    while (fp != fend) *pp++ = *fp++;    while (fp != fend) *pp++ = *fp++;
Línea 1934: Línea 1862:
    ms_back = NULL;    ms_back = NULL;
 } }
- +
 void move_back_star (void) { void move_back_star (void) {
    while (pp != fbeg) *--fp = *--pp;    while (pp != fbeg) *--fp = *--pp;
Línea 1943: Línea 1871:
    ms = NULL;    ms = NULL;
 } }
- +
 void insert (void) { void insert (void) {
    int p = pointer;    int p = pointer;
Línea 1954: Línea 1882:
    ms = NULL;    ms = NULL;
 } }
- +
 void insert_back (void) { void insert_back (void) {
    int p = pointer;    int p = pointer;
Línea 1965: Línea 1893:
    ms_back = NULL;    ms_back = NULL;
 } }
- +
 bool verify (void) { bool verify (void) {
    int x = pointer;    int x = pointer;
Línea 1971: Línea 1899:
    ecce_int if_sym;    ecce_int if_sym;
    ecce_int sym ;    ecce_int sym ;
- +
    do {    do {
       sym = case_op (text[x++]);       sym = case_op (text[x++]);
       if_sym = case_op (*++y);       if_sym = case_op (*++y);
    } while (sym == if_sym);    } while (sym == if_sym);
- +
    if (sym != 0) return (ok = FALSE);    if (sym != 0) return (ok = FALSE);
- +
    ms = fp;    ms = fp;
    ml = y;    ml = y;
    ms_back = NULL;    ms_back = NULL;
- +
    return (ok = TRUE);    return (ok = TRUE);
 } }
- +
 bool verify_back (void) { bool verify_back (void) {
    int x = pointer - 1;    int x = pointer - 1;
Línea 1991: Línea 1919:
    ecce_int if_sym;    ecce_int if_sym;
    ecce_int sym;    ecce_int sym;
- +
    do {    do {
       sym = case_op (text[++x]);       sym = case_op (text[++x]);
       if_sym = case_op (*(pp - ++y));       if_sym = case_op (*(pp - ++y));
    } while (sym == if_sym);    } while (sym == if_sym);
- +
    if (sym != 0) return (ok = FALSE);    if (sym != 0) return (ok = FALSE);
- +
    ms_back = pp;    ms_back = pp;
    ml_back = pp - y + 1;    ml_back = pp - y + 1;
    ms = NULL;    ms = NULL;
- +
    return (ok = TRUE);    return (ok = TRUE);
 } }
- +
 bool find (void) { bool find (void) {
    ecce_int sym = text[pointer] | casebit;    ecce_int sym = text[pointer] | casebit;
- +
    pp_before = pp;    pp_before = pp;
    limit = lim[this_unit];    limit = lim[this_unit];
Línea 2025: Línea 1953:
       }       }
    }    }
- +
    return (ok = FALSE);    return (ok = FALSE);
 } }
- +
 bool find_back (void) { bool find_back (void) {
    fp_before = fp;    fp_before = fp;
Línea 2044: Línea 1972:
       }       }
    }    }
- +
    return (ok = FALSE);    return (ok = FALSE);
 } }
-</code>+</file>

Este sitio web utiliza cookies para guardar datos esenciales de su actividad, como su autenticación. Al entrar acepta el uso de cookies.

Más información