Expression *parseTerm(FILE *source, Expression *lvalue)
{
    Token token = scanner(source);
    Expression *expr;
	int i ;
    switch (token.type){
        case PlusOp:
        case MinusOp:
        case Alphabet:
        case PrintOp:
            for (i = strlen(token.tok) - 1; i >= 0; i--) {
                ungetc(token.tok[i], source);
            }
            return lvalue;
		case MulOp:
            expr = (Expression *)malloc( sizeof(Expression) );
            (expr->v).type = MulNode;
            (expr->v).val.op = Mul;
            expr->leftOperand = lvalue;
            expr->rightOperand = parseValue(source);
            return parseTerm(source, expr);
        case DivOp:
            expr = (Expression *)malloc( sizeof(Expression) );
            (expr->v).type = DivNode;
            (expr->v).val.op = Div;
            expr->leftOperand = lvalue;
            expr->rightOperand = parseValue(source);
            return parseTerm(source, expr);
        default:
            printf("In function parseTerm\n");
            printf("Syntax Error: Expect a numeric value or an identifier %s\n", token.tok);
            exit(1);
    }

}

	void parseGroup(filesystem::InputStream &stream, int flags)
	{
		std::string currentLine;
		std::string nextLine;

		readLine(stream, currentLine);
		if(!currentLine.empty() && currentLine[0] == '}')
			return;

		while(readLine(stream, nextLine))
		{
			if(nextLine[0] == '{')
			{
				parseSubGroup(stream, currentLine, flags);
				currentLine = "";
				continue;
			}

			parseValue(currentLine, flags);
			if(nextLine[0] == '}')
				return;

			currentLine.swap(nextLine);		
		}

		parseValue(currentLine, flags);
	}

Expression *parseExpression( FILE *source, Expression *lvalue )//changed
{
    Token token = scanner(source);
    Expression *expr;

    switch(token.type){
        case PlusOp:
            expr = (Expression *)malloc( sizeof(Expression) );
            (expr->v).type = PlusNode;
            (expr->v).val.op = Plus;
            expr->leftOperand = lvalue;
            expr->rightOperand = parseValue(source);
            return parseExpressionTail(source, expr);
        case MinusOp:
            expr = (Expression *)malloc( sizeof(Expression) );
            (expr->v).type = MinusNode;
            (expr->v).val.op = Minus;
            expr->leftOperand = lvalue;
            expr->rightOperand = parseValue(source);
            return parseExpressionTail(source, expr);
        case Alphabet:
        case PrintOp:
			ungetstring(token.tok, source);
            //ungetc(token.tok[0], source);
            return NULL;
        case EOFsymbol:
            return NULL;
        default:
            printf("Syntax Error: Expect a numeric value or an identifier %s\n", token.tok);
            exit(1);
    }
}

Expression *parseTerm(FILE *source, Expression *lvalue)
{
    Token token = scanner(source);
    Expression *expr;

    switch(token.type){
        case MulOp:
            expr = (Expression *)malloc( sizeof(Expression) );
            (expr->v).type = MulNode;
            (expr->v).val.op = Mul;
            expr->leftOperand = lvalue;
            expr->rightOperand = parseValue(source);
            return parseTermTail(source, expr);
        case DivOp:
            expr = (Expression *)malloc( sizeof(Expression) );
            (expr->v).type = DivNode;
            (expr->v).val.op = Div;
            expr->leftOperand = lvalue;
            expr->rightOperand = parseValue(source);
            return parseTermTail(source, expr);
        case Alphabet:
        case PrintOp:
        case PlusOp:
        case MinusOp:
            ungetToken(token);
            return lvalue;
        case EOFsymbol:
            return lvalue;
        default:
            printf("Syntax Error:(parseTerm) Expect a numeric value or an identifier %s\n", token.tok);
            exit(1);
    }

}

//-------------------------------------------------------
void coTParser::parseEnumeration()
{
	parseValue();
	while( m_currentToken.m_type == coTLexer::EToken_COMMA)
	{
		consumeToken();
		parseValue();
	}
}

CrontabSelector::CrontabSelector(
  const dynamic &d,
  int64_t min_val,
  int64_t max_val,
  function<int64_t(const string& lc_str)> str_to_value
) : start_(min_val),
    end_(max_val),
    period_(1),
    minVal_(min_val),
    maxVal_(max_val) {

  switch (d.type()) {
    case dynamic::Type::INT64:
    case dynamic::Type::STRING:
      sortedValues_.emplace_back(parseValue(d, str_to_value));
      break;
    case dynamic::Type::ARRAY:
      for (const auto& val : d) {
        sortedValues_.emplace_back(parseValue(val, str_to_value));
      }
      // If somebody specifies [] for a selector, we have to silently
      // accept it, since PHP's JSON library can morph {} into [], and {}
      // must mean "default selector accepting all values."
      break;
    case dynamic::Type::OBJECT:
      for (const auto& pair : d.items()) {
        // Interval is first so that it doesn't accept strings like "jan"
        if (pair.first == "period") {
          period_ = pair.second.asInt();
          if (period_ < 1 || period_ >= maxVal_ - minVal_) {
            throw runtime_error(format(
              "period not in [1, {}]: {}", maxVal_ - minVal_, period_
            ).str());
          }
          continue;
        }
        // For start & end, we are happy to accept string names
        auto val = parseValue(pair.second, str_to_value);
        if (pair.first == "start") {
          start_ = val;
        } else if (pair.first == "end") {
          end_ = val;
        } else {
          throw runtime_error(format("Unknown key: {}", pair.first).str());
        }
      }
      // If we got an empty object, no problem -- this selector will
      // follow the default of "match everything".
      break;
    default:
      throw runtime_error(format(
        "Bad type for crontab selector: {}", d.typeName()
      ).str());
  }
  sort(sortedValues_.begin(), sortedValues_.end());
}

// Build an object from the text.
const char*
aJsonClass::parseObject(aJsonObject *item, const char *value)
{
  aJsonObject *child;
  if (*value != '{')
    return NULL; // not an object!

  item->type = aJson_Object;
  value = skip(value + 1);
  if (*value == '}')
    return value + 1; // empty array.

  item->child = child = newItem();
  if (!item->child)
    return NULL;
  value = skip(parseString(child, skip(value)));
  if (!value)
    return NULL;
  child->name = child->value.valuestring;
  child->value.valuestring = NULL;
  if (*value != ':')
    return NULL; // fail!
  value = skip(parseValue(child, skip(value + 1))); // skip any spacing, get the value.
  if (!value)
    return NULL;

  while (*value == ',')
    {
      aJsonObject *new_item;
      if (!(new_item = newItem()))
        return NULL; // memory fail
      child->next = new_item;
      new_item->prev = child;
      child = new_item;
      value = skip(parseString(child, skip(value + 1)));
      if (!value)
        return NULL;
      child->name = child->value.valuestring;
      child->value.valuestring = NULL;
      if (*value != ':')
        return NULL; // fail!
      value = skip(parseValue(child, skip(value + 1))); // skip any spacing, get the value.
      if (!value)
        return NULL;
    }

  if (*value == '}')
    return value + 1; // end of array
  return NULL; // malformed.
}

/* parse the audit record and create libee structure
 */
static rsRetVal
audit_parse(uchar *buf, struct json_object **jsonRoot)
{
	struct json_object *json;
	struct json_object *jval;
	char name[1024];
	char val[1024];
	DEFiRet;

	*jsonRoot = json_object_new_object();
	if(*jsonRoot == NULL) {
		ABORT_FINALIZE(RS_RET_ERR);
	}
	json = json_object_new_object();
	json_object_object_add(*jsonRoot, "data", json);

	while(*buf) {
		CHKiRet(parseName(&buf, name, sizeof(name)));
		if(*buf != '=') {
			ABORT_FINALIZE(RS_RET_ERR);
		}
		++buf;
		CHKiRet(parseValue(&buf, val, sizeof(val)));
		jval = json_object_new_string(val);
		json_object_object_add(json, name, jval);
	}
	

finalize_it:
	RETiRet;
}

//-------------------------------------------------------
void coTParser::parseProperty()
{
	coASSERT(m_currentToken.m_type == coTLexer::EToken_IDENTIFIER);
	coTSemanticAnalyzer::Property prop;
	prop.m_name = m_currentToken;
	consumeToken();
	if (m_currentToken.m_type != coTLexer::EToken_COLON)
	{
		prop.m_type.clear();
	}
	else
	{
		prop.m_type = m_currentToken;
		consumeToken();
	}
	m_semanticAnalyzer->onProperty(prop);
	switch (m_currentToken.m_type)
	{
	case coTLexer::EToken_EQUAL:
		{
			consumeToken();
			parseValue();
		}
		break;
	case coTLexer::EToken_LBRACE:
		{
			parsePropertyBlock();
		}
		break;
	default:
		{
			coFAIL();
		}
	}
}

bool CSSParser::parseColor(RGBA32& color, const String& string, bool strict)
{
    if (string.isEmpty())
        return false;

    // First try creating a color specified by name, rgba(), rgb() or "#" syntax.
    if (CSSPropertyParser::fastParseColor(color, string, strict))
        return true;

    // In case the fast-path parser didn't understand the color, try the full parser.
    RefPtrWillBeRawPtr<MutableStylePropertySet> stylePropertySet = MutableStylePropertySet::create();
    // FIXME: The old CSS parser is only working in strict mode ignoring the strict parameter.
    // It needs to be investigated why.
    if (!parseValue(stylePropertySet.get(), CSSPropertyColor, string, false, strictCSSParserContext()))
        return false;

    RefPtrWillBeRawPtr<CSSValue> value = stylePropertySet->getPropertyCSSValue(CSSPropertyColor);
    if (!value || !value->isPrimitiveValue())
        return false;

    CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value.get());
    if (!primitiveValue->isRGBColor())
        return false;

    color = primitiveValue->getRGBA32Value();
    return true;
}

			inline static JSONPair parseMember(const char* string)
			{
				int stringLength = strlen(string) + 1;
				char* memberString = new char[stringLength];
				memcpy(memberString, string, stringLength);
				memberString[stringLength - 1] = '\0';

				char* key = "";
				JSONValue value;

				//We can't parse the member just yet, we need to know its type
				std::vector<std::string> split = StringUtils::splitOnce(memberString, ":");
				if (split.size() == 2)
				{
					const char* memberKeyString = split[0].c_str();
					const char* memberValueString = split[1].c_str();

					int keyStringLen = strlen(memberKeyString);

					value = parseValue(memberValueString);

					key = new char[keyStringLen];
					memcpy(key, memberKeyString, keyStringLen);
					key[keyStringLen - 1] = '\0';
				}
			
				delete[] memberString;
				return JSONPair(key, value);
			}

void JsonParser::parseArray( JsonScanner & scanner, std::vector<JsonValue *> * values ) {
	static std::string name( "" );
	JsonToken token;
	try {
		token = scanner.getNextToken();
	}
	catch ( const std::exception & e ) {
		throw;
	}

	JsonValue * value;
	try {
		value = parseValue( scanner, token, name );
	} catch( const std::exception & e ) {
		throw;
	}
	values->push_back( value );
	try {
		token = scanner.getNextToken();
	} catch( const std::exception & e ) {
		throw;
	}
	if( token.getType() == JsonTypes::COMMA ) {
		try {
			parseArray( scanner, values );
		} catch( std::exception & e ) {
			throw;
		}
	} else if ( token.getType() == JsonTypes::CLOSE_BRACKET ) {
	} else {
		throw ArrayParsingException();
	}
}

Declaration* CssParser::parseDeclaration () {
  Declaration* declaration = NULL;
  TokenList property;

  if (!parseProperty(&property))
    return NULL;
  
  skipWhitespace();

  declaration = new Declaration(property.toString());
  
  if (tokenizer->getTokenType() != Token::COLON) {
    throw new ParseException(tokenizer->getToken()->str,
                             "colon following property(':')");
  }
  tokenizer->readNextToken();
  skipWhitespace();

  TokenList* value = parseValue();
  if (value == NULL) {
    throw new ParseException(tokenizer->getToken()->str,
                             "value for property");
  }
  declaration->setValue(value);
  return declaration;
}

Expression *parsePreTerm(FILE *source)
{
    Expression *v = parseValue(source);
    Expression *term = parseTerm(source, v);
    return term;

}

bool LessParser::parseVariable (TokenList &value) {
  if (tokenizer->getTokenType() != Token::COLON)
    return false;
  
  tokenizer->readNextToken();
  skipWhitespace();
    
  if (parseValue(value) == false || value.size() == 0) {
    throw new ParseException(tokenizer->getToken(),
                             "value for variable",
                             tokenizer->getLineNumber(),
                             tokenizer->getColumn(),
                             tokenizer->getSource());
  }
  if (tokenizer->getTokenType() != Token::DELIMITER) {
    throw new ParseException(tokenizer->getToken(),
                             "delimiter (';') at end of @-rule",
                             tokenizer->getLineNumber(),
                             tokenizer->getColumn(),
                             tokenizer->getSource());
  }
  tokenizer->readNextToken();
  skipWhitespace();

  return true;
}

void XmlRpc::parseCall(const QByteArray& call, QByteArray& function, QList<QVariant>& args)
{
	QDomDocument doc;
	QDomElement root;
	QString msg;
	QList<QVariant> values;

	if(!doc.setContent(call, false, &msg))
		throw RuntimeException(msg);

	root = doc.documentElement();
	if(root.tagName() != "methodCall")
		throw RuntimeException(QObject::tr("Not a XML-RPC call"));

	QDomElement methodName = root.firstChildElement("methodName");
	if(methodName.isNull())
		throw RuntimeException(QObject::tr("Not a valid XML-RPC call"));
	function = methodName.firstChild().toText().data().toAscii();

	QDomElement e = root.firstChildElement("params");
	if(!e.isNull())
	{
		QDomElement p = e.firstChildElement("param");
		while(!p.isNull())
		{
			QDomElement value = p.firstChildElement("value");
			if(value.isNull())
				throw RuntimeException(QObject::tr("Invalid XML-RPC call"));

			args << parseValue(value);

			p = p.nextSiblingElement("param");
		}
	}
}

const wchar_t* TcJSONObject::fromObject(const QString&, const wchar_t* ptr)
{
    ptr = skip(ptr);
    if (*ptr == L'{')
    {
        setType(vtfObject);
        do
        {
            ptr = skip(++ptr);
            QString Key;
            ptr = skip(parseKey(Key, ptr));
            if (*ptr == L':')
            {
                ptr = skip(++ptr);

                ptr = parseValue(Key, ptr);
            }
            ptr = skip(ptr);
        } while (ptr && *ptr && *ptr == ',');
        if (ptr && *ptr == L'}')
        {
            ptr = skip(++ptr);
        }
        else
        {
            ptr = 0;
        }
    }
    return ptr;
}

QPair<QStringRef,QStringRef> QDeclarativeStyledTextPrivate::parseAttribute(const QChar *&ch, const QString &textIn)
{
    skipSpace(ch);

    int attrStart = ch - textIn.constData();
    int attrLength = 0;
    while (!ch->isNull()) {
        if (*ch == greaterThan) {
            break;
        } else if (*ch == equals) {
            ++ch;
            if (*ch != singleQuote && *ch != doubleQuote) {
                while (*ch != greaterThan && !ch->isNull())
                    ++ch;
                break;
            }
            ++ch;
            if (!attrLength)
                break;
            QStringRef attr(&textIn, attrStart, attrLength);
            QStringRef val = parseValue(ch, textIn);
            if (!val.isEmpty())
                return QPair<QStringRef,QStringRef>(attr,val);
            break;
        } else {
            ++attrLength;
        }
        ++ch;
    }

    return QPair<QStringRef,QStringRef>();
}

MVJSONNode* MVJSONReader::parse(string text)
{
	string s = trim(text);
	if (s.length() < 2) return NULL;

	// object
	if ((s[0] == '{') && (s[s.length() - 1] == '}'))
	{
		// erase last and first symbols
		s.erase(0, 1);
		s.erase(s.length() - 1, 1);

		vector<string> parts;
		splitList(s, parts);

		MVJSONNode* node = new MVJSONNode();

		for (int i = 0; i < parts.size(); i++)
			node->values.push_back(parseValue(parts.at(i), false));

		return node;
	}

	return NULL;
}

Statement parseStatement( FILE *source, Token token )
{
    Token next_token;
    Expression *value, *term,*expr;

    switch(token.type){
        case Alphabet:
            next_token = scanner(source);
            if(next_token.type == AssignmentOp){
                value = parseValue(source);
                term = parseTerm(source, value);
                expr = parseExpression(source, term);
                return makeAssignmentNode(token.tok, value, expr);
            }
            else{
                printf("Syntax Error: Expect an assignment op %s\n", next_token.tok);
                exit(1);
            }
        case PrintOp:
            next_token = scanner(source);
            if(next_token.type == Alphabet)
                return makePrintNode(next_token.tok);
            else{
                printf("Syntax Error: Expect an identifier %s\n", next_token.tok);
                exit(1);
            }
            break;
        default:
            printf("Syntax Error: Expect a statement %s\n", token.tok);
            exit(1);
    }
}