src/lang_pascal.c

   1 /*
   2  * Source file:
   3  *      lang_pascal.c
   4  *
   5  * Contains get_pascal_char(), which parses C code.
   6  */
   7
   8 #include "config.h"
   9
  10 #include <ctype.h>
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14
  15 #include "trueprint.h"
  16 #include "main.h"
  17 #include "input.h"
  18 #include "index.h"
  19 #include "language.h"
  20 #include "output.h"
  21
  22 #include "lang_pascal.h"
  23
  24 /*
  25  * Public part
  26  */
  27 char            lang_pascal_defaults[] = "--f --F --i";
  28
  29 /*
  30  * Private part
  31  */
  32
  33 typedef enum {
  34   PAS_SPACE,
  35   PAS_COMMENT_START,
  36   PAS_COMMENT_END,
  37   PAS_COMMENT
  38 } pascal_states;
  39
  40 typedef enum {
  41   FN_CODE,
  42   FN_PROCEDURE,
  43   FN_FUNCTION,
  44   FN_BEGIN,
  45   FN_END,
  46   FN_SPACE,
  47   FN_NAME
  48 } pascal_fn_states;
  49
  50 static char     procedure_string[] = "procedure";
  51 static char     function_string[]  = "function";
  52 static char     begin_string[]     = "begin";
  53 static char     end_string[]       = "end";
  54
  55 /*
  56  * get_pascal_char()
  57  * detects comment starts and ends;
  58  * finds function names;
  59  * detects function ends;
  60  * returns one of the following:
  61  * CHAR
  62  * COMMENT_START
  63  * COMMENT_END
  64  * FUNCTION_END
  65  * FILE_END
  66  * INPUT_END
  67  * FUNCTION_NAME_START
  68  * FUNCTION_NAME_END
  69  */
  70 stream_status
  71 get_pascal_char(char *input_char, char_status *status)
  72
  73 {
  74   stream_status retval;
  75   static pascal_states  state = PAS_SPACE;
  76   static pascal_fn_states       fn_state = FN_CODE;
  77   static long           start_char;
  78   static char           fn_name[SYMBOL_LEN];
  79   static long           fn_page;
  80   static size_t         token_index;
  81   static short          function_depth = 0;
  82
  83   *status = CHAR_NORMAL;
  84
  85   if (restart_language == TRUE)
  86     {
  87       state = PAS_SPACE;
  88       fn_state = FN_CODE;
  89       function_depth = 0;
  90       braces_depth      = 0;
  91       restart_language  = FALSE;
  92     }
  93
  94   retval = getnextchar(input_char);
  95
  96   switch (state)
  97     {
  98     case PAS_SPACE:
  99       if (isspace(*input_char)) break;
 100       if (*input_char == '{')
 101         {
 102           state = PAS_COMMENT;
 103           *status = CHAR_ITALIC;
 104         }
 105       else if (*input_char == '(')
 106         {
 107           stream_status s;
 108           char c;
 109           s = getnextchar(&c);
 110           if (c == '*') *status = CHAR_ITALIC;
 111           ungetnextchar(c,s);
 112           state=PAS_COMMENT_START;
 113         }
 114       break;
 115     case PAS_COMMENT_START:
 116       if (*input_char == '*')
 117         {
 118           state = PAS_COMMENT;
 119           *status = CHAR_ITALIC;
 120         }
 121       else
 122         state = PAS_SPACE;
 123       break;
 124     case PAS_COMMENT_END:
 125       *status = CHAR_ITALIC;
 126       if (*input_char == ')') state = PAS_SPACE;
 127       break;
 128     case PAS_COMMENT:
 129       *status = CHAR_ITALIC;
 130       if (*input_char == '}')
 131         {
 132           state = PAS_SPACE;
 133         }
 134       else if (*input_char == '*')
 135         {
 136           state = PAS_COMMENT_END;
 137         }
 138       break;
 139     default:
 140       abort();
 141     }
 142
 143   if ((state == PAS_SPACE) || (state == PAS_COMMENT_START))
 144     {
 145       switch (fn_state)
 146         {
 147         case FN_CODE:
 148           if (*input_char == 'b'){fn_state=FN_BEGIN;token_index=1;break;}
 149           if (*input_char == 'e'){fn_state=FN_END;token_index=1;break;}
 150           if (*input_char == 'f'){fn_state=FN_FUNCTION;token_index=1;break;}
 151           if (*input_char == 'p'){fn_state=FN_PROCEDURE;token_index=1;break;}
 152           break;
 153         case FN_PROCEDURE:
 154           if (*input_char == procedure_string[token_index])
 155             {
 156               if (++token_index == strlen(procedure_string))
 157                 { token_index = 0; fn_state = FN_SPACE; }
 158             }
 159           else
 160             fn_state = FN_CODE;
 161           break;
 162         case FN_FUNCTION:
 163           if (*input_char == function_string[token_index])
 164             {
 165               if (++token_index == strlen(function_string))
 166                 { token_index = 0; fn_state = FN_SPACE; }
 167             }
 168           else
 169             fn_state = FN_CODE;
 170           break;
 171         case FN_BEGIN:
 172           if (*input_char == begin_string[token_index])
 173             {
 174               if (++token_index == strlen(begin_string))
 175                 {
 176                   token_index = 0;
 177                   fn_state = FN_CODE;
 178                   braces_depth++;
 179                 }
 180             }
 181           else
 182             fn_state = FN_CODE;
 183           break;
 184         case FN_END:
 185           if (*input_char == end_string[token_index])
 186             {
 187               if (++token_index == strlen(end_string))
 188                 {
 189                   token_index = 0;
 190                   fn_state = FN_CODE;
 191                   if (braces_depth != 0)
 192                     if (--braces_depth == function_depth)
 193                       {
 194                         retval|=STREAM_FUNCTION_END;
 195                         end_function(page_number);
 196                         function_depth--;
 197                       }
 198                 }
 199             }
 200           else
 201             fn_state = FN_CODE;
 202           break;
 203         case FN_SPACE:
 204           if (!isspace(*input_char))
 205             {
 206               if (isalpha(*input_char))
 207                 {
 208                   token_index = 0;
 209                   fn_name[token_index++] = *input_char;
 210                   start_char = char_number;
 211                   fn_page = page_number;
 212                   fn_state = FN_NAME;
 213                 }
 214               else
 215                 fn_state = FN_CODE;
 216             }
 217           break;
 218         case FN_NAME:
 219           if ((isalnum(*input_char)||*input_char == '_') && (token_index < SYMBOL_LEN-1))
 220             fn_name[token_index++] = *input_char;
 221           else
 222             {
 223               fn_name[token_index] = '\0';
 224               add_function(fn_name,start_char,char_number-1,fn_page,current_filename);
 225               fn_state = FN_CODE;
 226               function_depth = braces_depth;
 227             }
 228           break;
 229         default:
 230           abort();
 231         }
 232     }
 233
 234   if (pass==1) *status = get_function_name_posn(char_number,*status);
 235
 236   return(retval);
 237 }