fortranscanner.h File Reference

#include "parserintf.h"

Include dependency graph for fortranscanner.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	FortranOutlineParser
	Fortran language parser using state-based lexical scanning. More...
class	FortranOutlineParserFree
class	FortranOutlineParserFixed

Functions
const char *	prepassFixedForm (const char *contents, int *hasContLine, int fixedCommentAfter)
bool	recognizeFixedForm (const DString &contents, FortranFormat format)
FortranFormat	convertFileNameFortranParserCode (const DString &fn)

Function Documentation

convertFileNameFortranParserCode()

FortranFormat convertFileNameFortranParserCode

(

const DString &

fn

)

Definition at line 2195 of file fortranscanner.l.

{
  DString ext = getFileNameExtension(fn);
  DString parserName = Doxygen::parserManager->getParserName(ext);
 
  if (parserName == "fortranfixed") return FortranFormat::Fixed;
  else if (parserName == "fortranfree") return FortranFormat::Free;
 
  return FortranFormat::Unknown;
}

References Fixed, Free, getFileNameExtension(), ParserManager::getParserName(), Doxygen::parserManager, and Unknown.

Referenced by convertCppComments(), and setFileName().

prepassFixedForm()

const char * prepassFixedForm	(	const char *	contents,
		int *	hasContLine,
		int	fixedCommentAfter )

Definition at line 1863 of file fortranscanner.l.

{
  int column=0;
  int prevLineLength=0;
  int prevLineAmpOrExclIndex=-1;
  int skipped = 0;
  char prevQuote = '\0';
  char thisQuote = '\0';
  bool emptyLabel=true;
  bool commented=false;
  bool inSingle=false;
  bool inDouble=false;
  bool inBackslash=false;
  bool fullCommentLine=true;
  bool artificialComment=false;
  bool spaces=true;
  int newContentsSize = (int)strlen(contents)+3; // \000, \n (when necessary) and one spare character (to avoid reallocation)
  char* newContents = (char*)malloc(newContentsSize);
  int curLine = 1;
  size_t sizCont;
 
  int j = -1;
  sizCont = strlen(contents);
  for(size_t i=0;i<sizCont;i++) {
    column++;
    char c = contents[i];
    if (artificialComment && c != '\n')
    {
      if (c == '!' && spaces)
      {
        newContents[j++] = c;
        artificialComment = false;
        spaces = false;
        skipped = 0;
        continue;
      }
      else if (c == ' ' || c == '\t') continue;
      else
      {
        spaces = false;
        skipped++;
        continue;
      }
    }
 
    j++;
    if (j>=newContentsSize-3) { // check for spare characters, which may be eventually used below (by & and '! ')
      newContents = (char*)realloc(newContents, newContentsSize+1000);
      newContentsSize = newContentsSize+1000;
    }
 
    switch(c) {
      case '\n':
        if (!fullCommentLine)
        {
          prevLineLength=column;
          prevLineAmpOrExclIndex=getAmpOrExclAtTheEnd(&contents[i-prevLineLength+1], prevLineLength,prevQuote);
          if (prevLineAmpOrExclIndex == -1) prevLineAmpOrExclIndex = column - 1;
          if (skipped)
          {
            prevLineAmpOrExclIndex = -1;
            skipped = 0;
          }
        }
        else
        {
          prevLineLength+=column;
          /* Even though a full comment line is not really a comment line it can be seen as one. An empty line is also seen as a comment line (small bonus) */
          if (hasContLine)
          {
            hasContLine[curLine - 1] = 1;
          }
        }
        artificialComment=false;
        spaces=true;
        fullCommentLine=true;
        column=0;
        emptyLabel=true;
        commented=false;
        newContents[j]=c;
        prevQuote = thisQuote;
        curLine++;
        break;
      case ' ':
      case '\t':
        newContents[j]=c;
        break;
      case '\000':
        if (hasContLine)
        {
           free(newContents);
           return nullptr;
        }
        newContents[j]='\000';
        newContentsSize = (int)strlen(newContents);
        if (newContents[newContentsSize - 1] != '\n')
        {
          // to be on the safe side
          newContents = (char*)realloc(newContents, newContentsSize+2);
          newContents[newContentsSize] = '\n';
          newContents[newContentsSize + 1] = '\000';
        }
        return newContents;
      case '"':
      case '\'':
      case '\\':
        if ((column <= fixedCommentAfter) && (column!=6) && !commented)
        {
          // we have some special cases in respect to strings and escaped string characters
          fullCommentLine=false;
          newContents[j]=c;
          if (c == '\\')
          {
            inBackslash = !inBackslash;
            break;
          }
          else if (c == '\'')
          {
            if (!inDouble)
            {
              inSingle = !inSingle;
              if (inSingle) thisQuote = c;
              else thisQuote = '\0';
            }
            break;
          }
          else if (c == '"')
          {
            if (!inSingle)
            {
              inDouble = !inDouble;
              if (inDouble) thisQuote = c;
              else thisQuote = '\0';
            }
            break;
          }
        }
        inBackslash = false;
        // fallthrough
      case '#':
      case 'C':
      case 'c':
      case '*':
      case '!':
        if ((column <= fixedCommentAfter) && (column!=6))
        {
          emptyLabel=false;
          if (column==1)
          {
            newContents[j]='!';
            commented = true;
          }
          else if ((c == '!') && !inDouble && !inSingle)
          {
            newContents[j]=c;
            commented = true;
          }
          else
          {
            if (!commented) fullCommentLine=false;
            newContents[j]=c;
          }
          break;
        }
        // fallthrough
      default:
        if (!commented && (column < 6) && ((c - '0') >= 0) && ((c - '0') <= 9))
        { // remove numbers, i.e. labels from first 5 positions.
            newContents[j]=' ';
        }
        else if (column==6 && emptyLabel)
        { // continuation
          if (!commented) fullCommentLine=false;
          if (c != '0')
          { // 0 not allowed as continuation character, see f95 standard paragraph 3.3.2.3
            newContents[j]=' ';
 
            if (prevLineAmpOrExclIndex==-1)
            { // add & just before end of previous line
              /* first line is not a continuation line in code, just in snippets etc. */
              if (curLine != 1) insertCharacter(newContents, j+1, (j+1)-6-1, '&');
              j++;
            }
            else
            { // add & just before end of previous line comment
              /* first line is not a continuation line in code, just in snippets etc. */
              if (curLine != 1) insertCharacter(newContents, j+1, (j+1)-6-prevLineLength+prevLineAmpOrExclIndex+skipped, '&');
              skipped = 0;
              j++;
            }
            if (hasContLine)
            {
              hasContLine[curLine - 1] = 1;
            }
          }
          else
          {
            newContents[j]=c; // , just handle like space
          }
          prevLineLength=0;
        }
        else if ((column > fixedCommentAfter) && !commented)
        {
          // first non commented non blank character after position fixedCommentAfter
          if (c == '&')
          {
            newContents[j]=' ';
          }
          else if (c != '!')
          {
            // I'm not a possible start of doxygen comment
            newContents[j]=' ';
            artificialComment = true;
            spaces=true;
            skipped = 0;
          }
          else
          {
            newContents[j]=c;
            commented = true;
          }
        }
        else
        {
          if (!commented) fullCommentLine=false;
          newContents[j]=c;
          emptyLabel=false;
        }
        break;
    }
  }
 
  if (hasContLine)
  {
    free(newContents);
    return nullptr;
  }
 
  if (j==-1) // contents was empty
  {
    newContents = (char*)realloc(newContents, 2);
    newContents[0] = '\n';
    newContents[1] = '\000';
  }
  else if (newContents[j] == '\n') // content ended with newline
  {
    newContents = (char*)realloc(newContents, j+2);
    newContents[j + 1] = '\000';
  }
  else // content did not end with a newline
  {
    newContents = (char*)realloc(newContents, j+3);
    newContents[j + 1] = '\n';
    newContents[j + 2] = '\000';
  }
  return newContents;
}

References getAmpOrExclAtTheEnd(), and insertCharacter().

Referenced by checkContLines(), and parseMain().

recognizeFixedForm()

bool recognizeFixedForm	(	const DString &	contents,
		FortranFormat	format )

Definition at line 2142 of file fortranscanner.l.

{
  int column=0;
  bool skipLine=false;
 
  if (format == FortranFormat::Fixed) return true;
  if (format == FortranFormat::Free)  return false;
 
  int tabSize=Config_getInt(TAB_SIZE);
  size_t sizCont = contents.length();
  for (size_t i=0;i<sizCont;i++)
  {
    column++;
 
    switch(contents.at(i))
    {
      case '\n':
        column=0;
        skipLine=false;
        break;
      case '\t':
        column += tabSize-1;
        break;
      case ' ':
        break;
      case '\000':
        return false;
      case '#':
        skipLine=true;
        break;
      case 'C':
      case 'c':
        if (column==1)
        {
          return !keyWordsFortranC(contents.data()+i);
        }
        // fallthrough
      case '*':
        if (column==1) return true;
        if (skipLine) break;
        return false;
      case '!':
        if (column!=6) skipLine=true;
        break;
      default:
        if (skipLine) break;
        if (column>=7) return true;
        return false;
    }
  }
  return false;
}

References DString::at(), Config_getInt, DString::data(), Fixed, Free, keyWordsFortranC(), and DString::length().

Referenced by convertCppComments(), FortranCodeParser::parseCode(), parseMain(), and setFileName().