parser.cpp

Go to the documentation of this file.

#include "parser.h"
#include "refs.h"
#include "vars.h"
#include "value.h"
#include "text.h"
#include "ranges.h"
#include "refs.h"

ParseText::ParseText(QString text)
{
  fulltext=NULL;
  currptr = NULL;
  expression = NULL;
  parse(text);
};

void ParseText::parse(QString text)
{
  initText(text);
  expression = parse();
}

Value * ParseText::properVarType(QString tokentext)
{
  // can we parse a location from it ?
  int c,r;
  bool ac,ar;
  int i;
  if ((i=tokentext.find(':'))>=0)
    {
      printf("%s\n",(const char*)tokentext.left(i));
      printf("%s\n",(const char*)tokentext.mid(i+1));
      bool res = getLocation(tokentext.left(i),c,r,ac,ar);
      assert(res);
      Reference * a= new Reference(c,r,ac,ar);
      res = getLocation(tokentext.mid(i+1),c,r,ac,ar);
      assert(res);
      Reference * b= new Reference(c,r,ac,ar);
      return new Range(a,b);
    }
  if (getLocation(tokentext,c,r,ac,ar))
    return new Reference(c,r,ac,ar);
  return new Variable(tokentext);
}

bool ParseText::getLocation(QString text, int &C, int &R, bool &absolute_column, bool& absolute_row)
{
  const char * t = text;
  const char * c = t;
  int column;
  int row;
  // column
  if (absolute_column=(*c=='$')) c++;
  column = 0;
  while(*c && !isdigit(*c) && *c!='$') 
    {
      column=column*26+toupper(*c)-'A';
      c++;
    }
  // row
  if (absolute_row=(*c=='$')) c++;
  row = 0;
  while(*c && isdigit(*c) && *c!='$') 
    {
      row=row*10+toupper(*c)-'0';
      c++;
    }
  // put out result
  C=column;
  R=row;
  return true;
}

Value * ParseText::parse()
{
  Token t = token();
  printf("%d\n",t);
  switch (t)
    {
    case text: return new TextValue(tokentext);
    case var: return properVarType(tokentext);
    case openexpr: 
      {
        t = token();
        if (t!=var)
          throw new ParseError("Operand is no operator");
        Expression * result = new Expression(tokentext);
        Value * arg=NULL;
        while((arg=parse()))
          result->add(arg);
        return result;
      }
    case closeexpr: return NULL;
    case eof: throw new ParseError("Unexpected end of line");
    };
  throw new ParseError("Unexpected token");
  return NULL;
}

void ParseText::initText(QString text)
{
  if (fulltext) free(fulltext);
  fulltext=strdup(text);
  currptr = fulltext;
  printf("To parse: %s\n",fulltext);
  expression = NULL;
}

ParseText::Token ParseText::token()
{
  if (!currptr) return eof;
  // remove whitespace)
  while(*currptr && isspace(*currptr)) currptr++;
  if (!*currptr) return eof;
  // check for the kind of token
  switch(*currptr)
    {
    case '(': currptr++; return openexpr;
    case ')': currptr++; return closeexpr;
    case '"': currptr++; return string_to('"');
    case '\'': currptr++; return string_to('\'');
    }
  bool d = isdigit(*currptr);
  text_to();
  if (d) return text;
  return var;
}

bool ParseText::seperator(unsigned char c)
{
  return c==0 || c==' ' || c=='(' || c=='\'' || c=='"' || c==')';
}

ParseText::Token ParseText::string_to(unsigned char c)
{
  char result[500];
  int i = 0;
  while(*currptr && *currptr!=c)
    result[i++]=*(currptr++);
  if(*currptr==c) currptr++;
  result[i]=0;
  tokentext=result;
  return text;
}

void ParseText::text_to()
{
  char result[500];
  int i = 0;
  while(!seperator(*currptr))
    result[i++]=*(currptr++);
  result[i]=0;
  tokentext=result;
}

---