int main(int argc, char *argv[])
{
    student_t student[30];
    student_t_ptr student_ptr[30];
    int i;
    for(i=0;i<30;i++){
        student_ptr[i] = &student[i];
    }
    if(argc == 1){
        puts("Connected to a transient in-memory database.\nChoose 13 or use parameter to reopen on a persistent database");
    }else if(argc == 2){
        buildFromFile(student_ptr,argv[1]);
    }
    processUnit(student_ptr);
    return 0;
}
Value *ValueProcessor::processConstant(TokenList::const_iterator &i,
                                       TokenList::const_iterator &end,
                                       const ValueScope &scope,
                                       bool defaultVal) const {
  Token token;
  Value *ret;
  const TokenList *var;
  TokenList variable;
  bool hasQuotes;
  std::string str;

  if (i == end)
    return NULL;

  token = *i;

  switch (token.type) {
    case Token::HASH:
      i++;
      // generate color from hex value
      return new Color(token);
      
    case Token::NUMBER:
    case Token::PERCENTAGE:
    case Token::DIMENSION:
      i++;
      return new NumberValue(token);

    case Token::ATKEYWORD:
      if ((var = scope.getVariable(token)) != NULL) {
        variable = *var;

        ret = processStatement(variable, scope);

        if (ret != NULL) {
          i++;
          //ret->setLocation(token);

          return ret;
        }
      }
      return NULL;

    case Token::STRING:
      i++;
      hasQuotes = token.stringHasQuotes();
      interpolate(token, scope);
      token.removeQuotes();
      return new StringValue(token, hasQuotes);

    case Token::URL:
      i++;
      interpolate(token, scope);
      str = token.getUrlString();

      return new UrlValue(token, str);

    case Token::IDENTIFIER:
      i++;

      if (i != end && (*i).type == Token::PAREN_OPEN) {
        if (token == "default") {
          i++;
          if ((*i).type != Token::PAREN_CLOSED) {
            throw new ParseException(*i,
                                     ")",
                                     (*i).line, (*i).column, (*i).source);
          }
          return new BooleanValue(token, defaultVal);
        } else if (functionExists(token.c_str())) {
          i++;

          ret = processFunction(token, i, end, scope);
          if (ret == NULL) {
            i--;
            i--;
            return NULL;
          } else
            return ret;

        } else {
          i--;
          return NULL;
        }

      } else if (token.compare("true") == 0) {
        return new BooleanValue(token, true);
      } else if ((ret = processUnit(token)) != NULL) {
        return ret;
      } else if ((ret = Color::fromName(token)) != NULL) {
        return ret;
      } else {
        return new StringValue(token, false);
      }

    case Token::PAREN_OPEN:
      return processSubstatement(i, end, scope, defaultVal);

    default:
      break;
  }

  if ((var = processDeepVariable(i, end, scope)) != NULL) {
    variable = *var;
    ret = processStatement(variable, scope);
    if (ret != NULL) {
      //ret->setLocation(token);
    }
    return ret;
  }
  if (token == "%") {
    i++;
    if (i != end && (*i).type == Token::PAREN_OPEN) {
      i++;

      if ((ret = processFunction(token, i, end, scope)) != NULL)
        return ret;

      i--;
    }
    i--;
  }
  if ((ret = processEscape(i, end, scope)) != NULL) {
    return ret;
  } else if ((ret = processNegative(i, end, scope)) != NULL) {
    return ret;
  }
  return NULL;
}