/* ------------------------------------------------------------------------- */
/*   "inputs" : Input routines, preprocessor, non-fatal errors               */
/*                                                                           */
/*   Part of Inform release 5                                                */
/*                                                                           */
/*   On non-ASCII machines, translate_to_ascii must be altered               */
/* ------------------------------------------------------------------------- */

#include "header.h"

int32 marker_in_file;
int  internal_line, total_source_line;

char *tokens;

char *forerrors_buff;
int forerrors_line;

static char *tokens_p; static int32 **token_adds;
static int *token_numbers;

#ifdef MAC_68K
static char **stack, **stack_longs;
#else
static int32 **stack, **stack_longs;
#endif
static int *stack_nos,
          *stack_slot_free;

extern void inputs_allocate_arrays(void)
{   forerrors_buff = my_malloc(BUFFER_LENGTH, "errors buffer");
   token_adds = my_calloc(sizeof(char *), MAX_TOKENS, "token addresses");
   token_numbers = my_calloc(sizeof(int), MAX_TOKENS, "token numbers");
   stack = my_calloc(sizeof(char *), STACK_SIZE, "stack pointers");
   stack_longs = my_calloc(sizeof(char *), STACK_LONG_SLOTS,
       "stack long slot pointers");
   stack_nos = my_calloc(sizeof(int), STACK_SIZE,
       "stack numbers");
   stack_slot_free = my_calloc(sizeof(int), STACK_SIZE,
       "stack free space flags");
}

static char *stackp1;
static char *stackp2;

extern void inputs_free_arrays(void)
{   my_free(&forerrors_buff, "errors buffer");
   my_free(&token_adds, "token addresses");
   my_free(&token_numbers, "token numbers");
   my_free(&stack,"stack_pointers");
   my_free(&stack_longs,"stack long slot pointers");
   my_free(&stack_nos,"stack numbers");
   my_free(&stack_slot_free,"stack free space flags");
   my_free(&stackp1,"preprocessor stack");
   my_free(&stackp2,"pp stack long slots");
}

/* ------------------------------------------------------------------------- */
/*   Preprocessor stack routines                                             */
/*                                                                           */
/*   This stack simulates inserting lines into the source, used when (eg) a  */
/*   source line like                                                        */
/*                     if 5*fish+2*loaves > multitude                        */
/*                                                                           */
/*   is replaced by assembly lines; the assembly lines are stacked up and    */
/*   will be read in before the next source line.  Most of the complication  */
/*   is to allow for these lines in turn to be rewritten back without them   */
/*   falling out of order, as they would in a simple FIFO stack.             */
/*                                                                           */
/*   The stack needs a reasonable size (10 to 20 at the very minimum)        */
/*   but almost all its lines will be used for short assembler instructions, */
/*   so it needs little provision for full-blown lines (probably only one    */
/*   "long slot" will ever be used, unless "write" is used).                 */
/* ------------------------------------------------------------------------- */

static int entries=0, stack_next=0;
static int ppstack_openb, ppstack_closeb;

extern void stack_create(void)
{   int i; char *stackp;
   stackp=my_malloc(STACK_SIZE*STACK_SHORT_LENGTH,"preprocessor stack");
   stackp1 = stackp;
#ifdef MAC_68K
   for (i=0; i<STACK_SIZE; i++)
       stack[i]=(stackp+i*STACK_SHORT_LENGTH);
#else
   for (i=0; i<STACK_SIZE; i++)
       stack[i]=(int32 *) (stackp+i*STACK_SHORT_LENGTH);
#endif
   stackp=my_malloc(STACK_LONG_SLOTS*BUFFER_LENGTH,"pp stack long slots");
   stackp2 = stackp;
   for (i=0; i<STACK_LONG_SLOTS; i++)
   {
#ifdef MAC_68K
       stack_longs[i]=(stackp+i*BUFFER_LENGTH);
#else
       stack_longs[i]=(int32 *) (stackp+i*BUFFER_LENGTH);
#endif
       *(stack_longs[i])=0;
   }
   entries=0;
   for (i=0; i<STACK_SIZE; i++) stack_slot_free[i]=1;
}

extern void stack_line(char *p)
{   int i, f, slot;

   /* printf("<%s>\n",p); */

   for (i=0; (i<STACK_SIZE)&&(stack_slot_free[i]==0); i++);
   if (i==STACK_SIZE)
       memoryerror("STACK_SIZE", STACK_SIZE);

   slot=i; stack_slot_free[slot]=0;
   for (i=entries; i>stack_next; i--)
       stack_nos[i]=stack_nos[i-1];
   stack_nos[stack_next++]=slot;
   entries++;

   if (strlen(p)<STACK_SHORT_LENGTH)
       strcpy((char *) stack[slot],p);
   else
   {   *(stack[slot])=0; f=0;
       for (i=0; i<STACK_LONG_SLOTS; i++)
           if ((*(stack_longs[i])==0)&&(f==0))
           {   strcpy((char *)stack_longs[i],p);
               *(stack[slot]+1)=i;
               f=1;
           }
       if (f==0) {
           memoryerror("STACK_LONG_SLOTS",STACK_LONG_SLOTS);
       }
   }
}

static void destack_line(char *p)
{   int i, slot;
   stack_next=0;
   slot=stack_nos[0];
   stack_slot_free[slot]=1;
   i= *(stack[slot]);
   if (i!=0)
       strcpy(p,(char *)stack[slot]);
   else
   {   i= *(stack[slot]+1);
       strcpy(p,(char *)stack_longs[i]);
       *(stack_longs[i])=0;
   }
   entries--;
   for (i=0; i<entries; i++) stack_nos[i]=stack_nos[i+1];
}

/* ------------------------------------------------------------------------- */
/*   Character-level parsing and error reporting routines                    */
/* ------------------------------------------------------------------------- */

static int firsthash_flag=1, recenthash_flag=0;

extern void input_begin_pass(void)
{   total_source_line=0; total_files_read=1;
   internal_line=0; endofpass_flag=0; marker_in_file=0;
#ifdef USE_TEMPORARY_FILES
   utf_zcode_p=zcode;
   if (pass_number==2) open_temporary_files();
#endif
   ppstack_openb=0; ppstack_closeb=0;
   firsthash_flag=1; recenthash_flag=0;
}

static void print_hash(void)
{   if (firsthash_flag==1) { printf("%d:",pass_number); firsthash_flag=0; }
   printf("#"); recenthash_flag=1; fflush(stdout);
}

static int errors[MAX_ERRORS];
static char named_errors_buff[256];

static void message(int style, char *s)
{   if (recenthash_flag==1) printf("\n");
   recenthash_flag=0;
   print_error_line();
   printf("%s: %s\n",(style==1)?"Error":"Warning",s);
#ifdef ARC_THROWBACK
   throwback(style, s);
#endif
   if ((style==1)&&(concise_mode==0))
   {   sprintf(forerrors_buff+68,"  ...etc");
       printf("> %s\n",forerrors_buff);
   }
}

extern void error(char *s)
{   int i;
   if (no_errors==MAX_ERRORS) { fatalerror("Too many errors: giving up"); }
   for (i=0; i<no_errors; i++)
       if (errors[i]==internal_line) return;
   errors[no_errors++]=internal_line;
   message(1,s);
}

extern void warning_named(char *s1, char *s2)
{   int i;
   i=strlen(s1)+strlen(s2)+3;
   if (i>250) s2[247-strlen(s1)]=0;
   sprintf(named_errors_buff,"%s \"%s\"",s1,s2);
   no_warnings++;
   message(2,named_errors_buff);
}

extern void warning(char *s1)
{   if (pass_number==1) return;
   no_warnings++;
   message(2,s1);
}

extern void obsolete_warning(char *s1)
{   if ((pass_number==1) || (obsolete_mode==1)
       || (is_systemfile()==1)) return;
   sprintf(named_errors_buff, "Obsolete usage: %s",s1);
   no_warnings++;
   message(2,named_errors_buff);
}

extern void error_named(char *s1, char *s2)
{   int i;
   i=strlen(s1)+strlen(s2)+3;
   if (i>250) s2[247-strlen(s1)]=0;
   sprintf(named_errors_buff,"%s \"%s\"",s1,s2);
   error(named_errors_buff);
}

extern void no_such_label(char *lname)
{   error_named("No such label as",lname);
}

static void reached_new_line(void)
{   total_source_line++;
   advance_line();
   if (total_source_line%100==0)
   {   if (hash_mode==1) print_hash();
#ifdef MAC_MPW
       SpinCursor(32); /* I.e., allow other tasks to run */
#endif
   }
}

static int not_line_end(int c)
{   if (c=='\n') reached_new_line();
   if ((c==0)||(c=='\n')) return(0);
   return(1);
}

static int quoted_mode;
static int not_case_mode;
static int one_quoted_mode;
static int non_terminator(char c)
{   if (c=='\n') reached_new_line();
   if (quoted_mode!=0)
   {   if ((c==0)||(c=='\\')) return(0);
       return(1);
   }
   if ((c==0)||(c==';')||(c=='!')||(c=='\\')||(c=='{')||(c=='}')) return(0);
   if ((c==':')&&(not_case_mode==0)&&(one_quoted_mode==0)) return(0);
   return(1);
}

/* ------------------------------------------------------------------------- */
/*   The Tokeniser (18)... coming to cinemas near you                        */
/*     incorporating the martial arts classic                                */
/*   Tokeniser II - This Time It's Optimal,                                  */
/*     with Dolph Lundgren as Dilip Sequeira and Gan as the two short planks */
/*   (and now a somewhat sub-standard sequel,                                */
/*     Tokeniser III: The Next Specification is Ugly)                        */
/* ------------------------------------------------------------------------- */

static int no_tokens;

#define NUMBER_SEPARATORS 27

#define QUOTE_CODE    1000
#define DQUOTE_CODE   1001
#define NEWLINE_CODE  1002
#define NULL_CODE     1003
#define SPACE_CODE    1004

/*  This list can't safely be changed without also changing the header
   separator #defines... */

static const char separators[NUMBER_SEPARATORS][4] = {
   "->", "-->", "--", "-", "++", "+", "*", "/", "%",
   "||", "|", "&&","&",
   "==", "=", "~=", ">=", ">",
   "<=", "<", "(", ")", ",", ".&", ".#", ".", ":" };

static int char_grid[256];

extern void make_s_grid(void)
{   int i, j;
   for (i=0; i<256; i++) char_grid[i]=0;
   for (i=0; i<NUMBER_SEPARATORS; i++)
   { j=separators[i][0];
     if(char_grid[j]==0) char_grid[j]=i*16+1; else char_grid[j]++;
   }
   char_grid['\''] = QUOTE_CODE;
   char_grid['\"'] = DQUOTE_CODE;
   char_grid['\n'] = NEWLINE_CODE;
   char_grid[0]    = NULL_CODE;
   char_grid[' ']  = SPACE_CODE;
   char_grid[TAB_CHARACTER]  = SPACE_CODE;
}

extern void tokenise_line(void)
{   char *p,*q;
   int i, j, k, bite, tok_l, tn=-1, next_tn=-1, quoted_size;
   const char *r;
   no_tokens=0; tokens_p=tokens; token_adds[0]=(int32 *) tokens_p;
   p=buffer;
   for (i=0, tok_l=0; i<MAX_TOKENS; i++)
   { if(tok_l)
     {   for(j=0;j<tok_l;j++) *tokens_p++= *p++; tok_l=0;
         tn=next_tn; goto got_tok;
     }
     while(char_grid[*p]==SPACE_CODE) p++;
     for(bite=0;1;)
     {
       if ((*p=='-') && (isdigit(p[1])))
       {
           if (bite) { *tokens_p++=0;
             token_numbers[no_tokens]=tn; tn=-1;
             token_adds[++no_tokens]=(int32 *)tokens_p; }
           *tokens_p++=*p++;
           *tokens_p++=*p++;
           while (isdigit(*p)) *tokens_p++=*p++;
           bite=0; goto got_tok;
       }
       switch(char_grid[*p])
       {  case 0:            *tokens_p++= *p++; bite=1; break;
          case SPACE_CODE:   goto got_tok;
          case DQUOTE_CODE:  quoted_size=0;
                             do { *tokens_p++= *p++;
                                  if (quoted_size++==MAX_QTEXT_SIZE)
                                  {
                           error("Too much text for one pair of \"s to hold");
                                      *p='\"'; break;
                                  }
                                } while (*p && *p!='\n' && *p!='\"');
                             if (*p=='\"') *tokens_p++= *p++; goto got_tok;
          case NEWLINE_CODE: reached_new_line();
                             if (bite) goto got_tok; return;
          case QUOTE_CODE:   quoted_size=0;
                             do { *tokens_p++= *p++;
                                  if (quoted_size++==MAX_QTEXT_SIZE)
                                  {
                           error("Too much text for one pair of 's to hold");
                                      *p='\''; break;
                                  }
                                } while (*p && *p!='\n' && *p!='\'');
                             if (*p=='\'') *tokens_p++= *p++; goto got_tok;
          case NULL_CODE:    if (bite) goto got_tok; return;
          default:  for (j=char_grid[*p]>>4,k=j+(char_grid[*p]&15);j<k;j++)
                    {   for (q=p,r=separators[j];*q== *r && *r;q++,r++);
                        if (!*r)
                        {   if(bite)
                            {   tok_l=q-p; next_tn=j; }
                            else
                            {   while(p<q) *tokens_p++= *p++;
                                tn=j;
                            }
                            goto got_tok;
                        }
                    }
                    *tokens_p++= *p++;bite=1;
       }
     }
   got_tok:
     *tokens_p++=0; token_numbers[no_tokens]=tn; tn=-1;
     token_adds[++no_tokens]=(int32 *)tokens_p;
   }
   error("Too many tokens on line (note: to increase the maximum, \
set $MAX_TOKENS=some-bigger-number on the Inform command line)");

   no_tokens=MAX_TOKENS-1;
   return;
}

extern void word(char *b1, int32 w)
{   if (w>no_tokens) { b1[0]=0; return; }
   strcpy(b1, (char *)token_adds[w-1]);
}

extern int word_token(int w)
{   if (w>no_tokens) return(-1);
   return(token_numbers[w-1]);
}

extern void dequote_text(char *b1)
{   int i;
   if (*b1!='\"') error_named("Open quotes \" expected for text but found",b1);
   for (i=0; b1[i]!=0; i++) b1[i]=b1[i+1];
   i=i-2;
   if (b1[i]!='\"')
       error_named("Close quotes \" expected for text but found",b1);
   b1[i]=0;
}

extern void textword(char *b1, int w)
{   word(b1,w); dequote_text(b1);
}

/* ------------------------------------------------------------------------- */
/*   Get the next line of input, and return 1 if it came from the            */
/*   preprocessor stack and 0 if it really came from the source files.       */
/*   So:                                                                     */
/*     If something's waiting on the stack, send that.                       */
/*     If there are braces to be opened or closed, send those.               */
/*     If at the end of the source, send an "end" directive.                 */
/*     Otherwise, keep going until a ; is reached which is not in 's or "s;  */
/*       throw away everything on any text line after a comment ! character; */
/*       fold out characters between a \ and the first non-space on the next */
/*       line.                                                               */
/* ------------------------------------------------------------------------- */

static int braces_level=0;
static int inferred_braces[MAX_BLOCK_NESTING];
static int ib_sp=0;

static char first_tok[17];

extern int get_next_line(void)
{   int i, j, k, ftp, first_token_mode,
       block_expected=0, b_l, b_f; char d, d2;
   internal_line++;

   quoted_mode=0; one_quoted_mode=0;
   do
   {   if (entries!=0) { destack_line(buffer); return(1); }
       if (ppstack_openb>0)
       {   strcpy(buffer,"{"); ppstack_openb--; braces_level++; return(1); }
       if (ppstack_closeb>0)
       {   strcpy(buffer,"}"); ppstack_closeb--; braces_level--;
           if ((ib_sp>0)&&(braces_level-1==inferred_braces[ib_sp-1]))
             {   ib_sp--; ppstack_closeb++; }
           return(1);
       }

       if (file_end(marker_in_file)==1) { strcpy(buffer,"#end"); return(1); }
       i=0; j=0; first_token_mode=1; not_case_mode=0; ftp=0; block_expected=0;
     GNLL:
       for (; non_terminator(d=file_char(marker_in_file+i)); i++, j++)
       {
           if (j>=BUFFER_LENGTH-2)
           {   error("Line too long (note: to increase the maximum length, \
set $BUFFER_LENGTH=some-bigger-number on the Inform command line)");
               buffer[BUFFER_LENGTH-2]=0;
               if (pass_number==1)
               {   buffer[76]=0;
                   printf("The overlong line began:\n<%s>\n",buffer);
               }
               return(0);
           }
           buffer[j]=d;
           if (d=='\"' && one_quoted_mode==0) quoted_mode=1-quoted_mode;
           if (d=='\'' && quoted_mode==0) one_quoted_mode=1-one_quoted_mode;
           if ((d=='[') && (pass_number==2) && (quoted_mode==0)
               && (one_quoted_mode==0)) keep_routine_linenum();
           if ((d==']') && (pass_number==2) && (quoted_mode==0)
               && (one_quoted_mode==0)) keep_re_linenum();
           if (d=='(') not_case_mode=1;
           if ((first_token_mode==1) && (d!=' ') && (d!='\n') && (d!='!')
                                     && (d!=TAB_CHARACTER))
           {   forerrors_line = current_source_line();
               first_token_mode=2;
           }
           if (first_token_mode==2)
           {   if (!isalpha(d))
               {   first_token_mode=0;
                   if (ftp>0)
                   {   first_tok[ftp]=0;
                       d2=first_tok[0];
                       if (   ((d2=='o')&&(strcmp(first_tok, "objectloop")==0))
                            ||((d2=='f')&&(strcmp(first_tok, "for")==0))
                            ||((d2=='i')&&(strcmp(first_tok, "if")==0))
                            ||((d2=='s')&&(strcmp(first_tok, "switch")==0))
                            ||((d2=='w')&&(strcmp(first_tok, "while")==0)) )
                       {   block_expected=1; b_l=0; b_f=0; }
                       else
                       if (   ((d2=='d')&&(strcmp(first_tok, "do")==0))
                            ||((d2=='e')&&(strcmp(first_tok, "else")==0))  )
                           goto MakeBlock;
                   }
               }
               else
               {   if (ftp==16) ftp=0;
                   else if (isupper(d)) first_tok[ftp++]=tolower(d);
                   else first_tok[ftp++]=d;
               }
           }
           if ((block_expected==1)&&(quoted_mode==0))
           {   if (d=='!')
               {   j--;
                   while (not_line_end(file_char(marker_in_file+i))) i++;
                   i++; goto GNLL;
               }
               if (d=='(') { b_l++; b_f=1; }
               else
                   if ((b_f==0)&&(d!=' ')&&(d!='\n'))
                   {   block_expected=0;
                   }
               if (d==')')
               {   b_l--;
                   if (b_l==0)
                   {
                       MakeBlock: j++; i++;
                       buffer[j]=0;

                       ppstack_openb++; marker_in_file+=i; i=0;
                       do
                       {   d=file_char(marker_in_file+i++);
                           if (d=='!')
                               do
                               {   d=file_char(marker_in_file+i++);
                               } while (d!='\n');
                           if (d=='\n') reached_new_line();
                       } while ((d==' ')||(d=='\n'));
                       marker_in_file+=(i-1);
/* ??? */               if (d==';') ppstack_closeb++;
   /* else? */                    else if (d=='{') marker_in_file++;
                       else inferred_braces[ib_sp++]=braces_level;

                       for (i=0; buffer[i]!=0; i++)
                           if (buffer[i]=='\n') buffer[i]=' ';
                       return(0);
                   }
               }
           }
       }

       switch(d)
       {   case '!': while (not_line_end(file_char(marker_in_file+i))) i++;
                     i++; goto GNLL;
           case '{': ppstack_openb++; break;
           case '}': ppstack_closeb++; break;
           case ':': buffer[j++]=':'; break;
           case '\\':
               while (not_line_end(file_char(marker_in_file+i))) i++; i++;
               while ( ((k=file_char(marker_in_file+i))==' ')
                       || (k==TAB_CHARACTER) ) i++; goto GNLL;
       }

       buffer[j]=0;
       marker_in_file+=i+1;

       for (i=0; buffer[i]!=0; i++)
         if (buffer[i]=='\n') buffer[i]=' ';

       for (i=0; buffer[i]!=0; i++)
         if (buffer[i]!=' ')
         {   if ((ib_sp>0)&&(braces_level-1==inferred_braces[ib_sp-1]))
             {   ib_sp--; ppstack_closeb++; }
             return(0);
         }
   } while (1==1);
   return(0);
}

extern void init_inputs_vars(void)
{   entries = 0;
   stack_next = 0;
   firsthash_flag = 0;
   recenthash_flag = 0;
   braces_level = 0;
   ib_sp = 0;

   forerrors_buff = NULL;
   token_adds = NULL;
   token_numbers = NULL;
   stack = NULL;
   stack_longs = NULL;
   stack_nos = NULL;
   stack_slot_free = NULL;
}

You are viewing proxied material from mercury.661.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.