/* xgettext Smalltalk backend.
   Copyright (C) 2002-2024 Free Software Foundation, Inc.

   This file was written by Bruno Haible <haible@clisp.cons.org>, 2002.

   This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */

#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

/* Specification.  */
#include "x-smalltalk.h"

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>

#include <error.h>
#include "attribute.h"
#include "message.h"
#include "xgettext.h"
#include "xg-pos.h"
#include "xg-message.h"
#include "xalloc.h"
#include "string-buffer.h"
#include "gettext.h"

#define _(s) gettext(s)

#define SIZEOF(a) (sizeof(a) / sizeof(a[0]))


/* The relevant parts of the Smalltalk syntax are:

     stringliteral ::= string | stringconst | symconst
     stringconst ::= "#"string
     string      ::= "'"[char]*"'"
     symconst    ::= "#"symbol
     symbol      ::= id | binsel | keysel[keysel]*
     keysel      ::= id":"
     id          ::= letter[letter|digit]*
     letter      ::= "A".."Z" | "a".."z"
     digit       ::= "0".."9"
     binsel      ::= selchar[selchar]
     selchar     ::= "+" | "-" | "*" | "/" | "~" | "|" | "," | "<" | ">"
                     | "=" | "&" | "@" | "?" | "%" | "\"

   Strings can contain any characters; to include the string delimiter itself,
   it must be duplicated.

   Character constants are written  "$"char

   Comments are enclosed within double quotes.

   In well-formed expressions, {} and [] and () are balanced.
 */


/* ======================== Reading of characters.  ======================== */

/* The input file stream.  */
static FILE *fp;


/* 1. line_number handling.  */

static int
phase1_getc ()
{
  int c = getc (fp);

  if (c == EOF)
    {
      if (ferror (fp))
        error (EXIT_FAILURE, errno, _("error while reading \"%s\""),
               real_file_name);
      return EOF;
    }

  if (c == '\n')
    line_number++;

  return c;
}

/* Supports only one pushback character.  */
static void
phase1_ungetc (int c)
{
  if (c != EOF)
    {
      if (c == '\n')
        --line_number;

      ungetc (c, fp);
    }
}


/* Accumulating comments.  */

static char *buffer;
static size_t bufmax;
static size_t buflen;

static inline void
comment_start ()
{
  buflen = 0;
}

static inline void
comment_add (int c)
{
  if (buflen >= bufmax)
    {
      bufmax = 2 * bufmax + 10;
      buffer = xrealloc (buffer, bufmax);
    }
  buffer[buflen++] = c;
}

static inline void
comment_line_end ()
{
  while (buflen >= 1
         && (buffer[buflen - 1] == ' ' || buffer[buflen - 1] == '\t'))
    --buflen;
  if (buflen >= bufmax)
    {
      bufmax = 2 * bufmax + 10;
      buffer = xrealloc (buffer, bufmax);
    }
  buffer[buflen] = '\0';
  savable_comment_add (buffer);
}


/* These are for tracking whether comments count as immediately before
   keyword.  */
static int last_comment_line;
static int last_non_comment_line;


/* ========================== Reading of tokens.  ========================== */


enum token_type_ty
{
  token_type_eof,
  token_type_uniq,              /* # */
  token_type_symbol,            /* symbol */
  token_type_string_literal,    /* string, stringconst, symbolconst */
  token_type_other              /* misc. operator */
};
typedef enum token_type_ty token_type_ty;

typedef struct token_ty token_ty;
struct token_ty
{
  token_type_ty type;
  char *string;         /* for token_type_string_literal, token_type_symbol */
  refcounted_string_list_ty *comment;  /* for token_type_string_literal */
  int line_number;
};

/* Free the memory pointed to by a 'struct token_ty'.  */
static inline void
free_token (token_ty *tp)
{
  if (tp->type == token_type_string_literal || tp->type == token_type_symbol)
    free (tp->string);
  if (tp->type == token_type_string_literal)
    drop_reference (tp->comment);
}


/* 2. Combine characters into tokens.  Discard comments and whitespace.  */

static token_ty phase2_pushback[1];
static int phase2_pushback_length;

static void
phase2_get (token_ty *tp)
{
  int c;

  if (phase2_pushback_length)
    {
      *tp = phase2_pushback[--phase2_pushback_length];
      return;
    }

  tp->string = NULL;

  for (;;)
    {
      tp->line_number = line_number;
      c = phase1_getc ();
      switch (c)
        {
        case EOF:
          tp->type = token_type_eof;
          return;

        case '"':
          {
            /* Comment.  */
            int lineno;

            comment_start ();
            lineno = line_number;
            for (;;)
              {
                c = phase1_getc ();
                if (c == '"' || c == EOF)
                  break;
                if (c == '\n')
                  {
                    comment_line_end ();
                    comment_start ();
                  }
                else
                  {
                    /* We skip all leading white space, but not EOLs.  */
                    if (!(buflen == 0 && (c == ' ' || c == '\t')))
                      comment_add (c);
                  }
              }
            comment_line_end ();
            last_comment_line = lineno;
            continue;
          }

        case '\n':
          if (last_non_comment_line > last_comment_line)
            savable_comment_reset ();
          FALLTHROUGH;
        case ' ':
        case '\t':
        case '\r':
          /* Ignore whitespace.  */
          continue;
        }

      last_non_comment_line = tp->line_number;

      switch (c)
        {
        case '\'':
          /* String literal.  */
          {
            struct string_buffer buffer;
            sb_init (&buffer);
            for (;;)
              {
                c = phase1_getc ();
                if (c == EOF)
                  break;
                if (c == '\'')
                  {
                    c = phase1_getc ();
                    if (c != '\'')
                      {
                        phase1_ungetc (c);
                        break;
                      }
                  }
                sb_xappend1 (&buffer, c);
              }
            tp->type = token_type_string_literal;
            tp->string = sb_xdupfree_c (&buffer);
            tp->comment = add_reference (savable_comment);
          }
          return;

        case '+':
        case '-':
        case '*':
        case '/':
        case '~':
        case '|':
        case ',':
        case '<':
        case '>':
        case '=':
        case '&':
        case '@':
        case '?':
        case '%':
        case '\\':
          {
            char *name;
            int c2 = phase1_getc ();
            switch (c2)
              {
              case '+':
              case '-':
              case '*':
              case '/':
              case '~':
              case '|':
              case ',':
              case '<':
              case '>':
              case '=':
              case '&':
              case '@':
              case '?':
              case '%':
                name = XNMALLOC (3, char);
                name[0] = c;
                name[1] = c2;
                name[2] = '\0';
                tp->type = token_type_symbol;
                tp->string = name;
                return;
              default:
                phase1_ungetc (c2);
                break;
              }
            name = XNMALLOC (2, char);
            name[0] = c;
            name[1] = '\0';
            tp->type = token_type_symbol;
            tp->string = name;
            return;
          }

        case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
        case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
        case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
        case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
        case 'Y': case 'Z':
        case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
        case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
        case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
        case 's': case 't': case 'u': case 'v': case 'w': case 'x':
        case 'y': case 'z':
          /* Recognize id or id":"[id":"]* or id":"[id":"]*id.  */
          {
            struct string_buffer buffer;
            sb_init (&buffer);
            for (;;)
              {
                sb_xappend1 (&buffer, c);
                c = phase1_getc ();
                switch (c)
                  {
                  case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
                  case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
                  case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
                  case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
                  case 'Y': case 'Z':
                  case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
                  case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
                  case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
                  case 's': case 't': case 'u': case 'v': case 'w': case 'x':
                  case 'y': case 'z':
                  case '0': case '1': case '2': case '3': case '4':
                  case '5': case '6': case '7': case '8': case '9':
                    continue;
                  case ':':
                    sb_xappend1 (&buffer, c);
                    c = phase1_getc ();
                    switch (c)
                      {
                      case 'A': case 'B': case 'C': case 'D': case 'E':
                      case 'F': case 'G': case 'H': case 'I': case 'J':
                      case 'K': case 'L': case 'M': case 'N': case 'O':
                      case 'P': case 'Q': case 'R': case 'S': case 'T':
                      case 'U': case 'V': case 'W': case 'X': case 'Y':
                      case 'Z':
                      case 'a': case 'b': case 'c': case 'd': case 'e':
                      case 'f': case 'g': case 'h': case 'i': case 'j':
                      case 'k': case 'l': case 'm': case 'n': case 'o':
                      case 'p': case 'q': case 'r': case 's': case 't':
                      case 'u': case 'v': case 'w': case 'x': case 'y':
                      case 'z':
                        continue;
                      default:
                        phase1_ungetc (c);
                        break;
                      }
                    break;
                  default:
                    phase1_ungetc (c);
                    break;
                  }
                break;
              }
            tp->string = sb_xdupfree_c (&buffer);
            tp->type = token_type_symbol;
          }
          return;

        case '#':
          /* Uniquification operator.  */
          tp->type = token_type_uniq;
          return;

        case '$':
          c = phase1_getc ();
          tp->type = token_type_other;
          return;

        default:
          tp->type = token_type_other;
          return;
        }
    }
}

/* Supports only one pushback token.  */
static void
phase2_unget (token_ty *tp)
{
  if (tp->type != token_type_eof)
    {
      if (phase2_pushback_length == SIZEOF (phase2_pushback))
        abort ();
      phase2_pushback[phase2_pushback_length++] = *tp;
    }
}


/* 3. Combine "# string_literal" and "# symbol" to a single token.  */

static token_ty phase3_pushback[2];
static int phase3_pushback_length;

static void
phase3_get (token_ty *tp)
{
  if (phase3_pushback_length)
    {
      *tp = phase3_pushback[--phase3_pushback_length];
      return;
    }

  phase2_get (tp);
  if (tp->type == token_type_uniq)
    {
      token_ty token2;

      phase2_get (&token2);
      if (token2.type == token_type_symbol
          || token2.type == token_type_string_literal)
        {
          if (token2.type == token_type_string_literal)
            drop_reference (token2.comment);
          tp->type = token_type_string_literal;
          tp->string = token2.string;
          tp->comment = add_reference (savable_comment);
        }
      else
        phase2_unget (&token2);
    }
}

/* Supports 2 pushback tokens.  */
static void
phase3_unget (token_ty *tp)
{
  if (tp->type != token_type_eof)
    {
      if (phase3_pushback_length == SIZEOF (phase3_pushback))
        abort ();
      phase3_pushback[phase3_pushback_length++] = *tp;
    }
}


/* 4. String literal concatenation:
   Combine "string1" , "string2" to "string1string2".  */

/* Concatenates two strings, and frees the first argument.  */
static char *
string_concat_free1 (char *s1, const char *s2)
{
  size_t len1 = strlen (s1);
  size_t len2 = strlen (s2);
  size_t len = len1 + len2 + 1;
  char *result = XNMALLOC (len, char);
  memcpy (result, s1, len1);
  memcpy (result + len1, s2, len2 + 1);
  free (s1);
  return result;
}

static token_ty phase4_pushback[1];
static int phase4_pushback_length;

static void
phase4_get (token_ty *tp)
{
  if (phase4_pushback_length)
    {
      *tp = phase4_pushback[--phase4_pushback_length];
      return;
    }

  phase3_get (tp);
  if (tp->type == token_type_string_literal)
    {
      char *sum = tp->string;

      for (;;)
        {
          token_ty token2;

          phase3_get (&token2);
          if (token2.type == token_type_symbol
              && strcmp (token2.string, ",") == 0)
            {
              token_ty token3;

              phase3_get (&token3);
              if (token3.type == token_type_string_literal)
                {
                  sum = string_concat_free1 (sum, token3.string);

                  free_token (&token3);
                  free_token (&token2);
                  continue;
                }
              phase3_unget (&token3);
            }
          phase3_unget (&token2);
          break;
        }
      tp->string = sum;
    }
}

/* Supports only one pushback token.  */
static void
phase4_unget (token_ty *tp)
{
  if (tp->type != token_type_eof)
    {
      if (phase4_pushback_length == SIZEOF (phase4_pushback))
        abort ();
      phase4_pushback[phase4_pushback_length++] = *tp;
    }
}


/* ========================= Extracting strings.  ========================== */

/* The file is broken into tokens.  Scan the token stream, looking for the
   following patterns
      NLS ? <string>
      NLS at: <string>
      NLS at: <string> plural: <string>
   where <string> is one of
      string_literal
      # string_literal
      # symbol
 */

void
extract_smalltalk (FILE *f,
                   const char *real_filename, const char *logical_filename,
                   flag_context_list_table_ty *flag_table,
                   msgdomain_list_ty *mdlp)
{
  message_list_ty *mlp = mdlp->item[0]->messages;

  fp = f;
  real_file_name = real_filename;
  logical_file_name = xstrdup (logical_filename);
  line_number = 1;

  last_comment_line = -1;
  last_non_comment_line = -1;

  phase2_pushback_length = 0;
  phase3_pushback_length = 0;
  phase4_pushback_length = 0;

  /* Eat tokens until eof is seen.  */
  {
    /* 0 when no "NLS" has been seen.
       1 after "NLS".
       2 after "NLS ?".
       3 after "NLS at:".
       4 after "NLS at: <string>".
       5 after "NLS at: <string> plural:".  */
    int state;
    /* Remember the message containing the msgid, for msgid_plural.
       Non-NULL in states 4, 5.  */
    message_ty *plural_mp = NULL;

    /* Start state is 0.  */
    state = 0;

    for (;;)
      {
        token_ty token;

        phase4_get (&token);

        switch (token.type)
          {
          case token_type_symbol:
            state = (strcmp (token.string, "NLS") == 0 ? 1 :
                     strcmp (token.string, "?") == 0 && state == 1 ? 2 :
                     strcmp (token.string, "at:") == 0 && state == 1 ? 3 :
                     strcmp (token.string, "plural:") == 0 && state == 4 ? 5 :
                     0);
            free_token (&token);
            break;

          case token_type_string_literal:
            if (state == 2)
              {
                lex_pos_ty pos;
                pos.file_name = logical_file_name;
                pos.line_number = token.line_number;
                remember_a_message (mlp, NULL, token.string, false, false,
                                    null_context_region (), &pos,
                                    NULL, token.comment, false);
                state = 0;
                break;
              }
            if (state == 3)
              {
                lex_pos_ty pos;
                token_ty token2;

                pos.file_name = logical_file_name;
                pos.line_number = token.line_number;

                phase4_get (&token2);

                plural_mp =
                  remember_a_message (mlp, NULL, token.string, false,
                                      token2.type == token_type_symbol
                                      && strcmp (token.string, "plural:") == 0,
                                      null_context_region (), &pos,
                                      NULL, token.comment, false);

                phase4_unget (&token2);

                state = 4;
                break;
              }
            if (state == 5)
              {
                lex_pos_ty pos;
                pos.file_name = logical_file_name;
                pos.line_number = token.line_number;
                if (plural_mp != NULL)
                  remember_a_message_plural (plural_mp, token.string, false,
                                             null_context_region (), &pos,
                                             token.comment, false);
                state = 0;
                break;
              }
            state = 0;
            free_token (&token);
            break;

          case token_type_uniq:
          case token_type_other:
            state = 0;
            break;

          case token_type_eof:
            break;

          default:
            abort ();
          }

        if (token.type == token_type_eof)
          break;
      }
  }

  /* Close scanner.  */
  fp = NULL;
  real_file_name = NULL;
  logical_file_name = NULL;
  line_number = 0;
}
