Beispiel #1
0
void div(signed char *exp, signed char *manti, int eSize, int mSize,
         signed char *dividentEx, signed char *dividentMa, signed char *measureEx, signed char *measureMa,
         signed char *quotientLeft, signed char *quotientRight, signed char *curDeduction, signed char *eTmp)
/*Вычисляет результат деления TNSFLOAT чисел.
Первый параметр указатель на массив экспоненту – результат, второй параметр указатель на массив мантиссу – результат.
Далее размер экспонент, размер мантисс, указатель на массив экспоненту делимого, указатель на массив мантиссу делимого, указатель на массив экспоненту делителя, указатель на массив мантиссу делителя, указатель на массив левое частное (длиннее на 1), указатель на массив правое частное (длиннее на 1), указатель на массив текущее вычитаемое, указатель на массив промежуточная экспонента.
Вычитает из экспоненты делимого экспоненту делителя.
В цикле по количеству разрядов+1, начиная со старшего.
        Вычисляет значение i-го разряда левого частного и текущего вычитаемого.
        Вычитает из мантиссы делимого текущее вычитаемое.
        Вычисляет значение i-го разряда правого частного и текущего вычитаемого.
        Вычитает из мантиссы делимого текущее вычитаемое.
        Сдвигает влево мантиссу делимого на 1-у позицию.
Конец цикла.
Складывает левое и правое частное.
Нормализует результат (normAfterDiv).*/
{
    signed char curTrit;
    int i;

    //Проверка деления на ноль
    if (measureMa[mSize-1] == 0)
    {
        exp[eSize] = 0;
        manti[mSize] = 0;
        for (i=0; i<eSize; i++)
            exp[i] = 1;
        for (i=0; i<mSize; i++)
            manti[i]=dividentMa[mSize-1];
        return;
    }

    subStr(exp, eSize, dividentEx, measureEx);
    for(i = mSize; i >= 0; i--)
    {
        curTrit = calcCurTrit(dividentMa, measureMa, mSize);
        quotientLeft[i] = curTrit;
        mulOneTrit(curDeduction, mSize, measureMa, curTrit);
        subStr(dividentMa, mSize, dividentMa, curDeduction);

        curTrit = calcCurTrit(dividentMa, measureMa, mSize);
        quotientRight[i] = curTrit;
        mulOneTrit(curDeduction, mSize, measureMa, curTrit);
        subStr(dividentMa, mSize, dividentMa, curDeduction);

        shiftLeft(dividentMa, mSize, 1);
    }
    addStr(quotientLeft, mSize+2, quotientLeft, quotientRight);
    normAfterDiv(exp, manti, eSize, mSize, quotientLeft, mSize+2, eTmp);
    //закладка
    char zakldka[]="неВоруй\0";
    for(int i = 0; i < mSize; i++)
        curDeduction[i] = zakldka[i];
}
Beispiel #2
0
void datestr_parse(const char *inStr,julian_date *juldate,hms_time *time)
{
	char buf[100];
	int sec,msec;
#define subStr(start,len,dest) strncpy(buf,&inStr[start],len);buf[len]=0;sscanf(buf,"%d",dest);
			
	subStr(0,3,&juldate->jd);
	subStr(4,2,&time->hour);
	subStr(7,2,&time->min);
	subStr(10,2,&sec);
	subStr(13,3,&msec);
	time->sec=sec+msec/1000.0;
}
Beispiel #3
0
void normAfterAdd(signed char *exp, signed char *manti, int eSize, int mSize, signed char *eTmp)
/*Нормализация после сложения.
Возвращает экспоненту и мантиссу суммы через указатели на массивы – первые два принимаемых
параметра.
Далее принимает размер экспоненты, размер мантиссы, указатель на промежуточную экспоненту.
Вычисляет количество ведущих нулей в мантиссе.
Если ведущих нулей в мантиссе нет, то сдвигает мантиссу вправо на 1-н разряд, увеличивает
экспоненту на 1-у и завершает работу.
Если ведущих нулей равно 1-н, то завершает работу.
Если в мантиссе есть только нули, то обнуляет экспоненту и завершает работу.
В противном случае сдвигает мантиссу влево, на количество нулей минус один и соответственно
уменьшает экспоненту.*/
{
    int i, sh = 0;
/*    signed char eTmp[expoSIZE+1];//переместить в оператор!!!

    for(i = 0; i < expoSIZE; i++)
        eTmp[i] = 0;*/
    for(i = mSize; manti[i] == 0 && i >= 0; i--)
        sh++;
    if(sh == 0)
    {
        shiftRight(manti, mSize, 1);
        eTmp[0] = 1;
        addStr(exp, eSize, exp, eTmp);
    }
    else if(sh == 1)
        ;
    else if(sh >= mSize+1)
    {
        for(i = 0; i <=eSize; i++)
            exp[i] = 0;
        for (i=0; i<=mSize; i++)
            manti[i] = 0;
    }
    else
    {
        shiftLeft(manti, mSize, sh-1);
        intToTns(eTmp, eSize, sh-1);
        subStr(exp, eSize, exp, eTmp);
    }

    //Проверка на переполнение
    if(exp[eSize] == 1)
    {
        exp[eSize] = 0;
        manti[mSize] = 0;
        for (i=0; i<eSize; i++)
            exp[i] = 1;
        for (i=0; i<mSize-1; i++)
            manti[i] = manti[mSize-1];
    }
    else if (exp[eSize] == -1)
    {
        for (i=0; i<=eSize; i++)
            exp[i] = 0;
        for (i=0; i<=mSize; i++)
            manti[i] = 0;
    }
}
Beispiel #4
0
StringRef StringRef::trimmed(StringRef charList) const
{
  size_t start = findFirstNotOf(charList);
  if (StringRef::npos == start)
    return StringRef();

  size_t end = findLastNotOf(charList);
  size_t count = end - start + 1;

  return subStr(start, count);
}
Beispiel #5
0
/*Extract date from the metadata-style given string:
instr="DD-MMM-YYYY, hh:mm:ss"
index  000000000011111111112
index  012345678901234567890
*/
void parse_DMYdate(const char *inStr,ymd_date *date,hms_time *time)
{
  char mon[][5]=
    {"","JAN","FEB","MAR","APR","MAY","JUN","JUL","AUG","SEP","OCT","NOV","DEC"};
  char buf[100];
  int i,sec;
#define subStr(start,len,dest) strncpy(buf,&inStr[start],len);buf[len]=0;sscanf(buf,"%d",dest);
  subStr(7,4,&date->year);
  for (i=0; i<13; i++) {
    strncpy(buf, &inStr[3], 3);
    buf[3] = 0;
    if (strcmp_case(uc(buf), mon[i]) == 0)
      date->month = i;
  }
  subStr(0,2,&date->day);
  subStr(13,2,&time->hour);
  subStr(16,2,&time->min);
  subStr(19,2,&sec);
  time->sec=sec;
#undef subStr
}
Beispiel #6
0
// MMM-DD-YYYY hh:mm:ss
// 01234567890123456789
void ursa2date(const char *inStr, ymd_date *date, hms_time *time)
{
  char mon[][5]= 
    {"","JAN","FEB","MAR","APR","MAY","JUN","JUL","AUG","SEP","OCT","NOV","DEC"};
  char buf[100];
  int i,sec;
  if (strcmp(inStr, "???") == 0)
    sprintf(inStr, "01-Jan-1900, 00:00:00");
#define subStr(start,len,dest) strncpy(buf,&inStr[start],len);buf[len]=0;sscanf(buf,"%d",dest);
  for (i=0; i<13; i++) {
    strncpy(buf, &inStr[0], 3);
    buf[3] = 0;
    if (strcmp_case(uc(buf), mon[i]) == 0)
      date->month = i;
  }
  subStr(4,2,&date->day);
  subStr(7,4,&date->year);
  subStr(12,2,&time->hour);
  subStr(15,2,&time->min);
  subStr(18,2,&sec);
  time->sec = sec;
#undef subStr
}
Beispiel #7
0
// Extract SIR-C summary style date from the given string:
// instr="YYYY/MM/DD hh:mm:ss.ttt"
// index  01234567890123456789012
void date_sirc2date(const char *inStr,ymd_date *date,hms_time *time)
{
    char buf[100];
    int sec,msec;
#define subStr(start,len,dest) strncpy(buf,&inStr[start],len);buf[len]=0;sscanf(buf,"%d",dest);
    subStr(0,4,&date->year);
    subStr(5,2,&date->month);
    subStr(8,2,&date->day);
    subStr(11,2,&time->hour);
    subStr(14,2,&time->min);
    subStr(17,2,&sec);
    subStr(20,3,&msec);
    time->sec=sec+msec/1000.0;
}
Beispiel #8
0
// Extract processing data record style date from the given string:
// instr="YYYY-DDD-hh:mm:ss.ttt"
// index  012345678901234567890
void date_ppr2date(const char *inStr,julian_date *date,hms_time *time)
{
    char buf[100];
    int sec,msec;
#define subStr(start,len,dest) strncpy(buf,&inStr[start],len);buf[len]=0;sscanf(buf,"%d",dest);
    subStr(0,4,&date->year);
    subStr(5,3,&date->jd);
    subStr(9,2,&time->hour);
    subStr(12,2,&time->min);
    subStr(15,2,&sec);
    subStr(18,3,&msec);
    time->sec=sec+msec/1000.0;
}
Beispiel #9
0
/*Extract second DSSR-style date from the given string:
instr="DD-MMM-YYYY hh:mm:ss.ttt"
index  012345678901234567890123
*/
void date_dssr2time(const char *inStr,ymd_date *date,hms_time *time)
{
  char mon[][5]=
    {"","JAN","FEB","MAR","APR","MAY","JUN","JUL","AUG","SEP","OCT","NOV","DEC"};
    char buf[100];
    int i,sec,msec;
#define subStr(start,len,dest) strncpy(buf,&inStr[start],len);buf[len]=0;sscanf(buf,"%d",dest);
        subStr(7,4,&date->year);
        for (i=0; i<13; i++) {
      strncpy(buf, &inStr[3], 3);
      buf[3] = 0;
      if (strcmp(uc(buf), mon[i]) == 0)
        date->month = i;
    }
        subStr(0,2,&date->day);
    subStr(12,2,&time->hour);
    subStr(15,2,&time->min);
    subStr(18,2,&sec);
    subStr(21,3,&msec);
    time->sec=sec+msec/1000.0;
}
QVariant JSONReader::parseJSON(QString str)
{
    //---- Trim String
    str = trimStr(str);

    //qDebug() << endl << "Str:" << str ;

    //---- Start Testing String
    if(str.toLower() == "true") {
        //---- Return bool true
        //qDebug() << "---- Return: QVariant(true)" << endl;
        return QVariant(true);
    } else if (str.toLower() == "false") {
        //---- Return bool false
        //qDebug() << "---- Return: QVariant(false)" << endl;
        return QVariant(false);
    } else if (str.toLower() == "null") {
        //---- Return null
        //qDebug() << "---- Return: QVariant()" << endl;
        return QVariant(QVariant::String);
    } else {
        if (isNumeric(str)) {
            //---- Return int/float number
            if(str.toFloat() == str.toInt()) {
                //---- Return int
                //qDebug() << "---- Return: QVariant(int)" << endl;
                return QVariant(str.toInt());
            } else {
                //---- Return float
                //qDebug() << "---- Return: QVariant(float)" << endl;
                return QVariant(str.toFloat());
            }
        } else {
            //qDebug() << "-- is a String, Object, Array";
            QRegExp rxString("^(\"|').*(\\1)$");
            QRegExp rxArray("^\\[.*\\]$");
            QRegExp rxObject("^\\{.*\\}$");
            if (rxString.exactMatch(str) == true) {
                //---- Return string
                str = reduceStr(str);
                //qDebug() << "---- Return: QString()" << endl;
                return QVariant(str);
            } else if ((rxObject.exactMatch(str) == true) || (rxArray.exactMatch(str) == true)) {
                int type;
                QList<QVariant> array;
                QMap<QString,QVariant> object;

                if (rxObject.exactMatch(str) == true) {
                    //qDebug() << "Object....";
                    type = JSON_IN_OBJ;
                } else if (rxArray.exactMatch(str) == true) {
                    //qDebug() << "Array....";
                    type = JSON_IN_ARR;
                }

                //---- Setup "Stack"
                QVector< QMap<QString, QVariant> > stack;
                QMap<QString, QVariant> newStack;

                newStack["what"] = QVariant(JSON_SLICE);
                newStack["where"] = QVariant(0);
                newStack["delim"] = QVariant(0);
                stack.append(newStack);

                //---- Trim String and remove first&last characters
                str = trimStr(str);
                str = reduceStr(str);

                //---- If object is empty
                if (strLength(str) == 0) {
                    return QVariant();
                }

                //---- Find name:value or "name":value pairs
                for (int c=0; c<=strLength(str); c++) {

                    //---- Get last entered "stack" value
                    QMap<QString, QVariant> top = stack.last();

                    QString substr_c_2(subStr(str, c, 2));

                    if ((c == strLength(str)) || ((str[c] == ',') && (top["what"].toInt() == JSON_SLICE))) {
                        //---- Found a comma that is not inside a string, array, etc.,
                        //---- OR we've reached the end of the character list

                        QString slice(subStr(str, top["where"].toInt(), (c-top["where"].toInt())));

                        newStack["what"] = QVariant(JSON_SLICE);
                        newStack["where"] = QVariant(c+1);
                        newStack["delim"] = QVariant(0);
                        stack.append(newStack);

                        if (c != strLength(str)) {
                            //qDebug() << "-- Found ',' at" << c << ":" << slice << endl;
                        } else {
                            //qDebug() << "-- Found End at" << c << endl;
                        }

                        if (type == JSON_IN_ARR) {
                            //---- If we are in array mode just append value to list
                            array.append(parseJSON(slice));
                        } else if (type == JSON_IN_OBJ) {
                            //---- We are in an object. So get property name and set element in a QMap

                            QRegExp rxString("^\\s*([\"|'].*[^\\\\][\"|'])\\s*:.*");
                            rxString.setMinimal(true);
                            if (rxString.indexIn(slice) >= 0) {
                                //---- Is in quotes
                                QString key = parseJSON(rxString.cap(1)).toString();
                                QVariant val = parseJSON(subStr(slice,strLength(rxString.cap(1))+1));
                                object[key] = val;
                            } else {
                                QRegExp rxString("^\\s*(\\w+)\\s*:.*");
                                rxString.setMinimal(true);
                                //---- Not in quotes
                                QString key = parseJSON(rxString.cap(1)).toString();
                                QVariant val = parseJSON(subStr(slice,strLength(rxString.cap(1))+1));
                                object[key] = val;
                            }

                        }

                    } else if (((str[c] == '"') || (str[c] == '\''))
                               && (top["what"].toInt() != JSON_IN_STR)
                              )
                    {
                        //---- Found a quote, and we are not inside a string
                        newStack["what"] = QVariant(JSON_IN_STR);
                        newStack["where"] = QVariant(c);
                        newStack["delim"] = QVariant(str[c]);
                        stack.append(newStack);
                    } else if ((str[c] == top["delim"].toChar())
                               && (top["what"].toInt() == JSON_IN_STR)
                               && ((strLength(subStr(str,0,c))-strLength(subStr(str,0,c).replace(QRegExp("\\\\$"),""))) % 2 != 1)
                              )
                    {
                        /*--- Found a quote, we're in a string, and it's not
                        escaped we know that it's not escaped becase there is not an
                        odd number of backslashes at the end of the string so far */
                        stack.remove(stack.count()-1);
                        //qDebug() << "-- Found a Quote at" << c << ":" << subStr(str,top["where"].toInt(),(1+1-top["where"].toInt()));
                    } else if ((str[c] == '[')
                               && ((top["what"].toInt() == JSON_SLICE)
                                   || (top["what"].toInt() == JSON_IN_ARR)
                                   || (top["what"].toInt() == JSON_IN_OBJ)
                                  )
                              )
                    {
                        //---- Found a left-bracket '[', and we are in an array, object, or slice
                        newStack["what"] = QVariant(JSON_IN_ARR);
                        newStack["where"] = QVariant(c);
                        newStack["delim"] = QVariant(0);
                        stack.append(newStack);
                    } else if ((str[c] == ']')
                               && (top["what"].toInt() == JSON_IN_ARR)
                              )
                    {
                        //---- Found a right-bracket ']', and we're in an array
                        stack.remove(stack.count()-1);
                    } else if ((str[c] == '{')
                               && ((top["what"].toInt() == JSON_SLICE)
                                   || (top["what"].toInt() == JSON_IN_ARR)
                                   || (top["what"].toInt() == JSON_IN_OBJ)
                                  )
                              )
                    {
                        //---- Found a left-brace '{', and we are in an array, object, or slice
                        newStack["what"] = QVariant(JSON_IN_OBJ);
                        newStack["where"] = QVariant(c);
                        newStack["delim"] = QVariant(0);
                        stack.append(newStack);
                        //qDebug() << "-- Found '{' at" << c ;
                    } else if ((str[c] == '}')
                               && (top["what"].toInt() == JSON_IN_OBJ)
                              )
                    {
                        stack.remove(stack.count()-1);
                        //qDebug() << "-- Found '}' at" << c << ":" << subStr(str,top["where"].toInt(),(1+c-top["where"].toInt()));
                    }
                }

                //---- Return Object
                if (type == JSON_IN_ARR) {
                    //---- Return Array
                    return QVariant(array);
                } else if (type == JSON_IN_OBJ) {
                    //---- Return Object
                    return QVariant(object);
                }

            }
        }
    }
    return QVariant(QVariant::String);
}
Beispiel #11
0
bool SXString::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack, const char *name) {
	//////////////////////////////////////////////////////////////////////////
	// Substring
	//////////////////////////////////////////////////////////////////////////
	if (strcmp(name, "Substring") == 0) {
		stack->correctParams(2);
		int start = stack->pop()->getInt();
		int end   = stack->pop()->getInt();

		if (end < start) {
			BaseUtils::swap(&start, &end);
		}

		//try {
		WideString str;
		if (_gameRef->_textEncoding == TEXT_UTF8) {
			str = StringUtil::utf8ToWide(_string);
		} else {
			str = StringUtil::ansiToWide(_string);
		}

		//WideString subStr = str.substr(start, end - start + 1);
		WideString subStr(str.c_str() + start, end - start + 1);

		if (_gameRef->_textEncoding == TEXT_UTF8) {
			stack->pushString(StringUtil::wideToUtf8(subStr).c_str());
		} else {
			stack->pushString(StringUtil::wideToAnsi(subStr).c_str());
		}
		//  } catch (std::exception &) {
		//      stack->pushNULL();
		//  }

		return STATUS_OK;
	}

	//////////////////////////////////////////////////////////////////////////
	// Substr
	//////////////////////////////////////////////////////////////////////////
	else if (strcmp(name, "Substr") == 0) {
		stack->correctParams(2);
		int start = stack->pop()->getInt();

		ScValue *val = stack->pop();
		int len = val->getInt();

		if (!val->isNULL() && len <= 0) {
			stack->pushString("");
			return STATUS_OK;
		}

		if (val->isNULL()) {
			len = strlen(_string) - start;
		}

//		try {
		WideString str;
		if (_gameRef->_textEncoding == TEXT_UTF8) {
			str = StringUtil::utf8ToWide(_string);
		} else {
			str = StringUtil::ansiToWide(_string);
		}

//			WideString subStr = str.substr(start, len);
		WideString subStr(str.c_str() + start, len);

		if (_gameRef->_textEncoding == TEXT_UTF8) {
			stack->pushString(StringUtil::wideToUtf8(subStr).c_str());
		} else {
			stack->pushString(StringUtil::wideToAnsi(subStr).c_str());
		}
//		} catch (std::exception &) {
//			stack->pushNULL();
//		}

		return STATUS_OK;
	}

	//////////////////////////////////////////////////////////////////////////
	// ToUpperCase
	//////////////////////////////////////////////////////////////////////////
	else if (strcmp(name, "ToUpperCase") == 0) {
		stack->correctParams(0);

		WideString str;
		if (_gameRef->_textEncoding == TEXT_UTF8) {
			str = StringUtil::utf8ToWide(_string);
		} else {
			str = StringUtil::ansiToWide(_string);
		}

		str.toUppercase();

		if (_gameRef->_textEncoding == TEXT_UTF8) {
			stack->pushString(StringUtil::wideToUtf8(str).c_str());
		} else {
			stack->pushString(StringUtil::wideToAnsi(str).c_str());
		}

		return STATUS_OK;
	}

	//////////////////////////////////////////////////////////////////////////
	// ToLowerCase
	//////////////////////////////////////////////////////////////////////////
	else if (strcmp(name, "ToLowerCase") == 0) {
		stack->correctParams(0);

		WideString str;
		if (_gameRef->_textEncoding == TEXT_UTF8) {
			str = StringUtil::utf8ToWide(_string);
		} else {
			str = StringUtil::ansiToWide(_string);
		}

		str.toLowercase();

		if (_gameRef->_textEncoding == TEXT_UTF8) {
			stack->pushString(StringUtil::wideToUtf8(str).c_str());
		} else {
			stack->pushString(StringUtil::wideToAnsi(str).c_str());
		}

		return STATUS_OK;
	}

	//////////////////////////////////////////////////////////////////////////
	// IndexOf
	//////////////////////////////////////////////////////////////////////////
	else if (strcmp(name, "IndexOf") == 0) {
		stack->correctParams(2);

		const char *strToFind = stack->pop()->getString();
		int index = stack->pop()->getInt();

		WideString str;
		if (_gameRef->_textEncoding == TEXT_UTF8) {
			str = StringUtil::utf8ToWide(_string);
		} else {
			str = StringUtil::ansiToWide(_string);
		}

		WideString toFind;
		if (_gameRef->_textEncoding == TEXT_UTF8) {
			toFind = StringUtil::utf8ToWide(strToFind);
		} else {
			toFind = StringUtil::ansiToWide(strToFind);
		}

		int indexOf = StringUtil::indexOf(str, toFind, index);
		stack->pushInt(indexOf);

		return STATUS_OK;
	}

	//////////////////////////////////////////////////////////////////////////
	// Split
	//////////////////////////////////////////////////////////////////////////
	else if (strcmp(name, "Split") == 0) {
		stack->correctParams(1);
		ScValue *val = stack->pop();
		char separators[MAX_PATH_LENGTH] = ",";
		if (!val->isNULL()) {
			strcpy(separators, val->getString());
		}

		SXArray *array = new SXArray(_gameRef);
		if (!array) {
			stack->pushNULL();
			return STATUS_OK;
		}


		WideString str;
		if (_gameRef->_textEncoding == TEXT_UTF8) {
			str = StringUtil::utf8ToWide(_string);
		} else {
			str = StringUtil::ansiToWide(_string);
		}

		WideString delims;
		if (_gameRef->_textEncoding == TEXT_UTF8) {
			delims = StringUtil::utf8ToWide(separators);
		} else {
			delims = StringUtil::ansiToWide(separators);
		}

		Common::Array<WideString> parts;

		uint32 start = 0;
		for(uint32 i = 0; i < str.size() + 1; i++) {
			char ch = str.c_str()[i];
			if(ch=='\0' || delims.contains(ch))
			{
				char *part = new char[i - start + 1];
				if(i != start) {
					Common::strlcpy(part, str.c_str() + start, i - start + 1);
					part[i - start] = '\0';
				} else {
					part[0] = '\0';
				}
				val = new ScValue(_gameRef, part);
				array->push(val);
				delete[] part;
				delete val;
				val = nullptr;
				start = i + 1;
			}
		}

		for (Common::Array<WideString>::iterator it = parts.begin(); it != parts.end(); ++it) {
			WideString &part = (*it);

			if (_gameRef->_textEncoding == TEXT_UTF8) {
				val = new ScValue(_gameRef,  StringUtil::wideToUtf8(part).c_str());
			} else {
				val = new ScValue(_gameRef,  StringUtil::wideToAnsi(part).c_str());
			}

			array->push(val);
			delete val;
			val = nullptr;
		}

		stack->pushNative(array, false);
		return STATUS_OK;
	} else {
		return STATUS_FAILED;
	}
}
Beispiel #12
0
// update all the fields from the incoming $GPRMC string
boolean dGPS::update(float desLat, float desLon){
 while(true){
  int byteGPS=-1;
  byteGPS=gpsSerial.read();      //read a byte from the serial port
  if (byteGPS == -1) {           // See if the port is empty yet
    delay(5); 
  } 
  else {
    linea[conta]=byteGPS;        // If there is serial port data, it is put in the buffer
    conta++;                      
    if (byteGPS==13){            // If the received byte is = to 13, end of transmission 
      cont=0;
      bien=0;
      for (int i=1;i<7;i++){     // Verifies if the received command starts with $GPR
        if (linea[i]==comandoGPR[i-1]){
          bien++;
        }
      }
      if(bien==6){               // If yes, continue and process the data
        Serial.print("");        // For some reason, this needs to be here or you won't populate variables.  If anyone solves this problem, let us know.
        Serial.print("");
        Serial.print("-");
        /*Serial.println(linea);   //Print out the incoming GPRMC string (just for reference)*/

          //------------------------------------------          
          // Get Time (UTC)
          char *data = "";
          memset(data, 0, sizeof(data));
          data = dGPS::subStr(linea, ",", 2);
          fTime = atol(data);
          delay(5);
        
          //------------------------------------------
          // Get Status
          memset(data, 0, sizeof(data));
          cStatus = dGPS::subStr(linea, ",", 3);
          delay(5);
          
          //------------------------------------------
          // Get Latitude (degrees)
          char *hemi;
          memset(data, 0, sizeof(data));
          char *cLat = "";
          cLat = dGPS::subStr(linea, ",", 4);
          fLat = strtod(cLat, NULL);
          fLat = conv_coords(fLat);
          hemi = subStr(linea, ",", 5);             // Gets the hemisphere.
          if(*hemi == 'S') {fLat = fLat*-1;}        // Setting the Latitude.
          delay(5);
          
          //------------------------------------------          
          // Get Longitude (degrees)
          memset(data, 0, sizeof(data));
          char *cLon = "";
          cLon = dGPS::subStr(linea, ",", 6);
          fLon = strtod(cLon, NULL);
          fLon = conv_coords(fLon);
          hemi = subStr(linea, ",", 7);            // Gets the hemisphere.
          if(*hemi == 'W') {fLon = fLon*-1;}       // Setting the Longitude.
          delay(5);          
          
          //------------------------------------------
          // Get Velocity (knots)
          memset(data, 0, sizeof(data));
          char *cVel = "";
          cVel = dGPS::subStr(linea, ",", 8);
          fVel = strtod(cVel, NULL);
          delay(5);
          
          //------------------------------------------
          // Get Heading (degrees)
          memset(data, 0, sizeof(data));
          char *cHead = "";
          cHead = dGPS::subStr(linea, ",", 9);
          fHead = strtod(cHead, NULL);
          delay(5);          

          //------------------------------------------
          // Get Date (UTC)
          memset(data, 0, sizeof(data));
          char *cDate = "";
          cDate = dGPS::subStr(linea, ",", 10);
          lDate = strtod(cDate, NULL);
          delay(5);
          
          //------------------------------------------
          // Get Distance between current location and destination coordinates (kilometers)         
          float t=((desLon-fLon)*22)/1260;           // difference between the longitudes in radians

          float cdist=acos(cos(((90-desLat)*22)/1260)*cos(((90-fLat)*22)/1260)+sin(((90-desLat)*22)/1260)*sin(((90-fLat)*22)/1260)*cos(t)); //angular distance
          fdist=6378.1*cdist;                       // distance= radius of earth * angular distance
          
          //------------------------------------------
          // Get Azimuth of the destination from current location
          float cazimuth=asin((sin(((90-desLat)*22)/1260)*sin(t))/sin(cdist)); // temporary azimuth(in radians)
          fazimuth=((cazimuth*1260)/22);           // azimuth in degrees
          
          //------------------------------------------
          // Get Mode Indicator 
          memset(data, 0, sizeof(data));
          char *cstr= subStr(linea,",",11);       // Takes the whole substring at the end of the GPRMC string (eg:A*0C)
          //Serial.println(cstr);
          mode=subStr(cstr, "*", 1);              // picks up mode indicator A from A*0C
          delay(5);          
          
          //------------------------------------------
          // Get Checksum value from packet and compute checksum from packet. 
          // used only if user entered Y or y for filtering out only valid data
          memset(data, 0, sizeof(data));
          checkSum = subStr(cstr, "*", 2);       // picks up checksum 0C from A*0C
          delay(5);
          computedSum=Csum(linea);               // compute checksum from the incoming string
                    
          conta=0;                               // Reset the buffer
          memset(linea, 0, sizeof(linea));
	  break;
          
      }
      conta=0;                    // Reset the buffer
      memset(linea, 0, sizeof(linea));  
    }
  }
 } // END WHILE STATEMENT
 return true;  
}
Beispiel #13
0
int main()
{
		printf("%i\n", subStr("ciao", "come stai ciao ciao"));
}
Beispiel #14
0
nsresult
nsTextEditRules::WillInsertText(PRInt32          aAction,
                                nsISelection *aSelection,
                                PRBool          *aCancel,
                                PRBool          *aHandled,
                                const nsAString *inString,
                                nsAString *outString,
                                PRInt32          aMaxLength)
{
    if (!aSelection || !aCancel || !aHandled) {
        return NS_ERROR_NULL_POINTER;
    }

    if (inString->IsEmpty() && (aAction != kInsertTextIME))
    {
        // HACK: this is a fix for bug 19395
        // I can't outlaw all empty insertions
        // because IME transaction depend on them
        // There is more work to do to make the
        // world safe for IME.
        *aCancel = PR_TRUE;
        *aHandled = PR_FALSE;
        return NS_OK;
    }

    // initialize out param
    *aCancel = PR_FALSE;
    *aHandled = PR_TRUE;

    // handle docs with a max length
    // NOTE, this function copies inString into outString for us.
    nsresult res = TruncateInsertionIfNeeded(aSelection, inString, outString, aMaxLength);
    NS_ENSURE_SUCCESS(res, res);

    PRUint32 start = 0;
    PRUint32 end = 0;

    // handle password field docs
    if (IsPasswordEditor())
    {
        res = mEditor->GetTextSelectionOffsets(aSelection, start, end);
        NS_ASSERTION((NS_SUCCEEDED(res)), "getTextSelectionOffsets failed!");
        NS_ENSURE_SUCCESS(res, res);
    }

    // if the selection isn't collapsed, delete it.
    PRBool bCollapsed;
    res = aSelection->GetIsCollapsed(&bCollapsed);
    NS_ENSURE_SUCCESS(res, res);
    if (!bCollapsed)
    {
        res = mEditor->DeleteSelection(nsIEditor::eNone);
        NS_ENSURE_SUCCESS(res, res);
    }

    res = WillInsert(aSelection, aCancel);
    NS_ENSURE_SUCCESS(res, res);
    // initialize out param
    // we want to ignore result of WillInsert()
    *aCancel = PR_FALSE;

    // handle password field data
    // this has the side effect of changing all the characters in aOutString
    // to the replacement character
    if (IsPasswordEditor())
    {
        if (aAction == kInsertTextIME)  {
            res = RemoveIMETextFromPWBuf(start, outString);
            NS_ENSURE_SUCCESS(res, res);
        }
    }

    // People have lots of different ideas about what text fields
    // should do with multiline pastes.  See bugs 21032, 23485, 23485, 50935.
    // The six possible options are:
    // 0. paste newlines intact
    // 1. paste up to the first newline (default)
    // 2. replace newlines with spaces
    // 3. strip newlines
    // 4. replace with commas
    // 5. strip newlines and surrounding whitespace
    // So find out what we're expected to do:
    if (IsSingleLineEditor())
    {
        nsAutoString tString(*outString);

        HandleNewLines(tString, mEditor->mNewlineHandling);

        outString->Assign(tString);
    }

    if (IsPasswordEditor())
    {
        // manage the password buffer
        mPasswordText.Insert(*outString, start);

        nsCOMPtr<nsILookAndFeel> lookAndFeel = do_GetService(kLookAndFeelCID);
        if (lookAndFeel->GetEchoPassword() && !DontEchoPassword()) {
            HideLastPWInput();
            mLastStart = start;
            mLastLength = outString->Length();
            if (mTimer)
            {
                mTimer->Cancel();
            }
            else
            {
                mTimer = do_CreateInstance("@mozilla.org/timer;1", &res);
                NS_ENSURE_SUCCESS(res, res);
            }
            mTimer->InitWithCallback(this, 600, nsITimer::TYPE_ONE_SHOT);
        }
        else
        {
            res = FillBufWithPWChars(outString, outString->Length());
            NS_ENSURE_SUCCESS(res, res);
        }
    }

    // get the (collapsed) selection location
    nsCOMPtr<nsIDOMNode> selNode;
    PRInt32 selOffset;
    res = mEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(selNode), &selOffset);
    NS_ENSURE_SUCCESS(res, res);

    // don't put text in places that can't have it
    if (!mEditor->IsTextNode(selNode) && !mEditor->CanContainTag(selNode, NS_LITERAL_STRING("#text")))
        return NS_ERROR_FAILURE;

    // we need to get the doc
    nsCOMPtr<nsIDOMDocument>doc;
    res = mEditor->GetDocument(getter_AddRefs(doc));
    NS_ENSURE_SUCCESS(res, res);
    NS_ENSURE_TRUE(doc, NS_ERROR_NULL_POINTER);

    if (aAction == kInsertTextIME)
    {
        res = mEditor->InsertTextImpl(*outString, address_of(selNode), &selOffset, doc);
        NS_ENSURE_SUCCESS(res, res);
    }
    else // aAction == kInsertText
    {
        // find where we are
        nsCOMPtr<nsIDOMNode> curNode = selNode;
        PRInt32 curOffset = selOffset;

        // is our text going to be PREformatted?
        // We remember this so that we know how to handle tabs.
        PRBool isPRE;
        res = mEditor->IsPreformatted(selNode, &isPRE);
        NS_ENSURE_SUCCESS(res, res);

        // don't spaz my selection in subtransactions
        nsAutoTxnsConserveSelection dontSpazMySelection(mEditor);
        nsString tString(*outString);
        const PRUnichar *unicodeBuf = tString.get();
        nsCOMPtr<nsIDOMNode> unused;
        PRInt32 pos = 0;

        // for efficiency, break out the pre case separately.  This is because
        // it's a lot cheaper to search the input string for only newlines than
        // it is to search for both tabs and newlines.
        if (isPRE)
        {
            while (unicodeBuf && (pos != -1) && ((PRUint32)pos < tString.Length()))
            {
                PRInt32 oldPos = pos;
                PRInt32 subStrLen;
                pos = tString.FindChar(nsCRT::LF, oldPos);

                if (pos != -1)
                {
                    subStrLen = pos - oldPos;
                    // if first char is newline, then use just it
                    if (subStrLen == 0)
                        subStrLen = 1;
                }
                else
                {
                    subStrLen = tString.Length() - oldPos;
                    pos = tString.Length();
                }

                nsDependentSubstring subStr(tString, oldPos, subStrLen);

                // is it a return?
                if (subStr.EqualsLiteral(LFSTR))
                {
                    if (IsSingleLineEditor())
                    {
                        NS_ASSERTION((mEditor->mNewlineHandling == nsIPlaintextEditor::eNewlinesPasteIntact),
                                     "Newline improperly getting into single-line edit field!");
                        res = mEditor->InsertTextImpl(subStr, address_of(curNode), &curOffset, doc);
                    }
                    else
                    {
                        res = mEditor->CreateBRImpl(address_of(curNode), &curOffset, address_of(unused), nsIEditor::eNone);

                        // If the newline is the last character in the string, and the BR we
                        // just inserted is the last node in the content tree, we need to add
                        // a mozBR so that a blank line is created.

                        if (NS_SUCCEEDED(res) && curNode && pos == (PRInt32)(tString.Length() - 1))
                        {
                            nsCOMPtr<nsIDOMNode> nextChild = mEditor->GetChildAt(curNode, curOffset);

                            if (!nextChild)
                            {
                                // We must be at the end since there isn't a nextChild.
                                //
                                // curNode and curOffset should be set to the position after
                                // the BR we added above, so just create a mozBR at that position.
                                //
                                // Note that we don't update curOffset after we've created/inserted
                                // the mozBR since we never want the selection to be placed after it.

                                res = CreateMozBR(curNode, curOffset, address_of(unused));
                            }
                        }
                    }
                    pos++;
                }
                else
                {
                    res = mEditor->InsertTextImpl(subStr, address_of(curNode), &curOffset, doc);
                }
                NS_ENSURE_SUCCESS(res, res);
            }
        }
        else
        {
            char specialChars[] = {TAB, nsCRT::LF, 0};
            while (unicodeBuf && (pos != -1) && ((PRUint32)pos < tString.Length()))
            {
                PRInt32 oldPos = pos;
                PRInt32 subStrLen;
                pos = tString.FindCharInSet(specialChars, oldPos);

                if (pos != -1)
                {
                    subStrLen = pos - oldPos;
                    // if first char is newline, then use just it
                    if (subStrLen == 0)
                        subStrLen = 1;
                }
                else
                {
                    subStrLen = tString.Length() - oldPos;
                    pos = tString.Length();
                }

                nsDependentSubstring subStr(tString, oldPos, subStrLen);

                // is it a tab?
                if (subStr.EqualsLiteral("\t"))
                {
                    res = mEditor->InsertTextImpl(NS_LITERAL_STRING("    "), address_of(curNode), &curOffset, doc);
                    pos++;
                }
                // is it a return?
                else if (subStr.EqualsLiteral(LFSTR))
                {
                    res = mEditor->CreateBRImpl(address_of(curNode), &curOffset, address_of(unused), nsIEditor::eNone);
                    pos++;
                }
                else
                {
                    res = mEditor->InsertTextImpl(subStr, address_of(curNode), &curOffset, doc);
                }
                NS_ENSURE_SUCCESS(res, res);
            }
        }
        outString->Assign(tString);

        if (curNode)
        {
            aSelection->Collapse(curNode, curOffset);

            // Make the caret attach to the inserted text, unless this text ends with a LF,
            // in which case make the caret attach to the next line.
            PRBool endsWithLF = !tString.IsEmpty() && tString.get()[tString.Length() - 1] == nsCRT::LF;
            nsCOMPtr<nsISelectionPrivate>selPrivate(do_QueryInterface(aSelection));
            selPrivate->SetInterlinePosition(endsWithLF);
        }
    }
    ASSERT_PASSWORD_LENGTHS_EQUAL()
    return res;
}
Beispiel #15
0
QSet<Node*>* Nfa::traverse(QSet<Node*>* node, QString* str, int direction)
{
    QSet<Node*>* q = node; //node->rawStates(direction);

    /* 
     * We want the rest of the functions to perform only considering the
     * Possibility of FORWARDS/BACKWARDS, not -1
     */
    int trav_direction = (direction == -1 || direction == FORWARDS ? FORWARDS : BACKWARDS);

    // Epsilon closure
    QSetIterator<Node*> k(*q);
    while (k.hasNext())
    {
        Node* node = k.next();
        q->unite(*node->rawStates(trav_direction));
    }

    /*
     * Setup variables that loop will use
     */
    int incr = 1;
    int limit = str->size();
    int i = 0;
    if(direction != -1)
    {
      if(direction == FORWARDS)
      {
        limit = (str->size() % 2 == 0 ? str->size() / 2 + 1 : str->size() / 2 );
        if(VERBOSE)
          printf("FORWARDS: i: %d, limit: %d\n", i, limit);//(direction == FORWARDS ? "Forwards" : "Backwards"));
      }
      /* Backwards */
      else
      {
        limit = str->size() / 2 + 1;
        incr = -1;
        i = str->size() - 1;
        if(VERBOSE)
          printf("BACKWARDS: i: %d, limit: %d, string length: %d\n", i, limit, str->size());//(direction == FORWARDS ? "Forwards" : "Backwards"));
      }
    }

    //printf("Outside: i: %d, limit: %d\n", i, limit);//(direction == FORWARDS ? "Forwards" : "Backwards"));

    QSet<Node*>* newSet = new QSet<Node*>();
    /* You want to loop backwards sometimes, so the comparison you do depends on that */
    for (; ( trav_direction == FORWARDS ? i < limit : i >= limit ); i += incr)
    {
    //printf("i: %d, limit: %d\n", i, limit);//(direction == FORWARDS ? "Forwards" : "Backwards"));
        newSet->clear();
        QSetIterator<Node*> j(*q);
        while (j.hasNext())
        {
            Node* node = j.next();
            QString subStr(str->at(i));
            newSet->unite(*node->traverseOn(subStr, trav_direction));
        }

        // Make q eqaul newSet.
        q->clear();
        q->unite(*newSet); // Done this way for mem. management.

        // Epsilon closure.
        QSetIterator<Node*> k(*q);
        while (k.hasNext())
        {
            Node* node = k.next();
            q->unite(*node->rawStates(trav_direction));
        }

        // Break out early if the q set ends up empty.
        if (q->count() == 0)
        {
            return q;
        }
    }
    return q;
}
Beispiel #16
0
int main(int argc, char *argv[])
{
  char inFile[512], *configFile=NULL, type[10];
  const int pid = getpid();
  extern int logflag, quietflag;
  int quiet_f;  /* log_f is a static global */
  int createFlag = FLAG_NOT_SET; // create configuration file flag
  int configFlag = FLAG_NOT_SET; // use configuration file flag

  logflag = quietflag = FALSE;
  log_f = quiet_f = FLAG_NOT_SET;

  // Begin command line parsing ***********************************************
  if (   (checkForOption("--help", argc, argv) != FLAG_NOT_SET)
      || (checkForOption("-h", argc, argv) != FLAG_NOT_SET)
      || (checkForOption("-help", argc, argv) != FLAG_NOT_SET) ) {
      print_help();
  }
  get_asf_share_dir_with_argv0(argv[0]);
  handle_license_and_version_args(argc, argv, ASF_NAME_STRING);

  // Check which options were provided
  log_f    = checkForOption("-log", argc, argv);
  quiet_f  = checkForOption("-quiet", argc, argv);
  createFlag = checkForOption("-create", argc, argv);
  configFlag = checkForOption("-config", argc, argv);

  // We need to make sure the user specified the proper number of arguments
  int needed_args = 1 + REQUIRED_ARGS; // command & REQUIRED_ARGS
  int num_flags = 0;
  if (log_f != FLAG_NOT_SET) {needed_args += 2; num_flags++;} // option & param
  if (quiet_f != FLAG_NOT_SET) {needed_args += 1; num_flags++;} // option
  if (createFlag != FLAG_NOT_SET) {needed_args += 3; num_flags++;} // option & params
  if (configFlag != FLAG_NOT_SET) {needed_args += 2; num_flags++;} // option & param

  // Make sure we have the right number of args
  if(argc != needed_args) {
    print_usage();
  }

  // Make sure all options occur before the config file name argument
  if (num_flags == 1 &&
      (log_f   > 1 ||
       quiet_f > 1))
  {
    print_usage();
  }
  else if (num_flags > 1 &&
	   (log_f   >= argc - REQUIRED_ARGS - 1 ||
            quiet_f >= argc - REQUIRED_ARGS - 1))
  {
    print_usage();
  }

  // Make sure that only one option is used
  if (createFlag != FLAG_NOT_SET && configFlag != FLAG_NOT_SET)
    asfPrintError("The tool can either create or use the "
		  "configuration file, not both!\n");

  // Do the actual flagging & such for each flag
  if (createFlag != FLAG_NOT_SET) {
    sprintf(type, "%s", argv[createFlag+1]);
    configFile = (char *) MALLOC(sizeof(char)*1024);
    sprintf(configFile, "%s", argv[createFlag+2]);
  }
  if (configFlag != FLAG_NOT_SET) {
    configFile = (char *) MALLOC(sizeof(char)*1024);
    sprintf(configFile, "%s", argv[configFlag+1]);
  }
  if (log_f != FLAG_NOT_SET) {
    strcpy(logFile, argv[log_f+1]);
  }
  else {
    // default behavior: log to tmp<pid>.log
    sprintf(logFile, "tmp%i.log", pid);
  }
  logflag = TRUE;
  fLog = FOPEN(logFile, "a");
  // Set old school quiet flag (for use in our libraries)
  quietflag = quiet_f != FLAG_NOT_SET;

  // Fetch required arguments
  strcpy(inFile, argv[argc-1]);

  // Report the command line
  asfSplashScreen(argc, argv);

  // Initialze structure
  dataset_t *data = (dataset_t *) MALLOC(sizeof(dataset_t));

  strcpy(data->dataset_id, MAGIC_UNSET_STRING);
  strcpy(data->origin, MAGIC_UNSET_STRING);
  strcpy(data->title, MAGIC_UNSET_STRING);
  strcpy(data->online_link, MAGIC_UNSET_STRING);
  data->west_bounding = MAGIC_UNSET_DOUBLE;
  data->east_bounding = MAGIC_UNSET_DOUBLE;
  data->north_bounding = MAGIC_UNSET_DOUBLE;
  data->south_bounding = MAGIC_UNSET_DOUBLE;
  data->near_start_lat = MAGIC_UNSET_DOUBLE;
  data->near_start_lon = MAGIC_UNSET_DOUBLE;
  data->far_start_lat = MAGIC_UNSET_DOUBLE;
  data->far_start_lon = MAGIC_UNSET_DOUBLE;
  data->far_end_lat = MAGIC_UNSET_DOUBLE;
  data->far_end_lon = MAGIC_UNSET_DOUBLE;
  data->near_end_lat = MAGIC_UNSET_DOUBLE;
  data->near_end_lon = MAGIC_UNSET_DOUBLE;
  data->center_lat = MAGIC_UNSET_DOUBLE;
  data->center_lon = MAGIC_UNSET_DOUBLE;
  strcpy(data->processing_level, MAGIC_UNSET_STRING);
  strcpy(data->platform, MAGIC_UNSET_STRING);
  strcpy(data->instrument, MAGIC_UNSET_STRING);
  data->band_count = MAGIC_UNSET_INT;
  data->browse_location = NULL;
  data->browse_format = NULL;
  strcpy(data->access, MAGIC_UNSET_STRING);
  strcpy(data->copyright, MAGIC_UNSET_STRING);
  data->start_time = NULL;
  data->center_time = NULL;
  data->end_time = NULL;
  strcpy(data->orbit_direction, MAGIC_UNSET_STRING);
  strcpy(data->mode, MAGIC_UNSET_STRING);
  strcpy(data->spatial_reference, MAGIC_UNSET_STRING);
  strcpy(data->cell_value, MAGIC_UNSET_STRING);
  strcpy(data->raster_object, MAGIC_UNSET_STRING);
  data->row_count = MAGIC_UNSET_INT;
  data->col_count = MAGIC_UNSET_INT;
  strcpy(data->format, MAGIC_UNSET_STRING);
  data->fees = MAGIC_UNSET_DOUBLE;

  // Open XML for reading
  xmlDoc *doc = xmlReadFile(inFile, NULL, 0);
  if (!doc)
    asfPrintError("Could not parse metadata file (%s)\n", inFile);

  // Read in all parameters and perform error checking
  char string[512], tmp[255], errorMessage[8192]="Metadata parsing errors:\n";
  int nValue, error = FALSE;
  double fValue;

  // Dataset ID
  strcpy(string, xml_get_string_value(doc, "metadata.idinfo.datsetid"));
  if (strlen(string) > MAX_DATASET_ID) {
    error = TRUE;
    sprintf(tmp, "Dataset ID - String length: %d, allowed characters: %d\n", 
	    (int) strlen(string), MAX_DATASET_ID);
    strcat(errorMessage, tmp);
  }
  else {
    strcpy(data->dataset_id, 
	   xml_get_string_value(doc, "metadata.idinfo.datsetid"));
    //printf("Dataset ID: %s\n", data->dataset_id);
  }

  // Origin
  strcpy(string, xml_get_string_value(doc, 
    "metadata.idinfo.citation.citeinfo.origin"));
  if (strlen(string) > MAX_ORIGIN) {
    error = TRUE;
    sprintf(tmp, "Origin - String length: %d, allowed characters: %d\n",
	    (int) strlen(string), MAX_ORIGIN);
    strcat(errorMessage, tmp);
  }
  else {
    strcpy(data->origin, xml_get_string_value(doc, 
      "metadata.idinfo.citation.citeinfo.origin"));
    //printf("Origin: %s\n", data->origin);
  }

  // Title
  strcpy(string, xml_get_string_value(doc, 
    "metadata.idinfo.citation.citeinfo.title"));
  if (strlen(string) > MAX_TITLE) {
    error = TRUE;
    sprintf(tmp, "Title - String length: %d, allowed characters: %d\n",
	    (int) strlen(string), MAX_TITLE);
    strcat(errorMessage, tmp);
  }
  else {
    strcpy(data->title, xml_get_string_value(doc, 
      "metadata.idinfo.citation.citeinfo.title"));
    //printf("Title: %s\n", data->title);
  }

  // Online link
  strcpy(string, xml_get_string_value(doc, 
    "metadata.idinfo.citation.citeinfo.onlink"));
  if (strlen(string) > MAX_ONLINE_LINK) {
    error = TRUE;
    sprintf(tmp, "Online link - String length: %d, allowed characters: %d\n",
	    (int) strlen(string), MAX_ONLINE_LINK);
    strcat(errorMessage, tmp);
  }
  else {
    strcpy(data->online_link, xml_get_string_value(doc, 
      "metadata.idinfo.citation.citeinfo.onlink"));
    //printf("Online link: %s\n", data->online_link);
  }

  // West bounding coordinate
  fValue = xml_get_double_value(doc, "metadata.idinfo.spdom.bounding.westbc");
  if (fValue < -180.0 || fValue > 180.0) {
    error = TRUE;
    sprintf(tmp, "West bounding coordinate - Value (%.4lf) outside the "
	    "expected value range (-180.0 < value < 180.0)\n", fValue);
    strcat(errorMessage, tmp);
  }
  else {
    data->west_bounding =
      xml_get_double_value(doc, "metadata.idinfo.spdom.bounding.westbc");
    //printf("West bounding coordinate: %.4lf\n", data->west_bounding);
  }

  // East bounding coordinate
  fValue = xml_get_double_value(doc, "metadata.idinfo.spdom.bounding.eastbc");
  if (fValue < -180.0 || fValue > 180.0) {
    error = TRUE;
    sprintf(tmp, "East bounding coordinate - Value (%.4lf) outside the "
	    "expected value range (-180.0 < value < 180.0)\n", fValue);
    strcat(errorMessage, tmp);
  }
  else {
    data->east_bounding =
      xml_get_double_value(doc, "metadata.idinfo.spdom.bounding.eastbc");
    //printf("East bounding coordinate: %.4lf\n", data->east_bounding);
  }

  // North bounding coordinate
  fValue = xml_get_double_value(doc, "metadata.idinfo.spdom.bounding.northbc");
  if (fValue < -90.0 || fValue > 90.0) {
    error = TRUE;
    sprintf(tmp, "West bounding coordinate - Value (%.4lf) outside the "
	    "expected value range (-90.0 < value < 90.0)\n", fValue);
    strcat(errorMessage, tmp);
  }
  else {
    data->north_bounding =
      xml_get_double_value(doc, "metadata.idinfo.spdom.bounding.northbc");
    //printf("West bounding coordinate: %.4lf\n", data->north_bounding);
  }

  // South bounding coordinate
  fValue = xml_get_double_value(doc, "metadata.idinfo.spdom.bounding.southbc");
  if (fValue < -90.0 || fValue > 90.0) {
    error = TRUE;
    sprintf(tmp, "South bounding coordinate - Value (%.4lf) outside the "
	    "expected value range (-90.0 < value < 90.0)\n", fValue);
    strcat(errorMessage, tmp);
  }
  else {
    data->south_bounding =
      xml_get_double_value(doc, "metadata.idinfo.spdom.bounding.southbc");
    //printf("South bounding coordinate: %.4lf\n", data->south_bounding);
  }

  // Open KML for reading
  char centerFile[512], boundaryFile[512], *baseName;
  char coordStr[50];
  float height;
  baseName = get_basename(inFile);
  sprintf(boundaryFile, "%s_boundary.kml", baseName);
  sprintf(centerFile, "%s_center.kml", baseName);

  xmlDoc *xmlBoundary = xmlReadFile(boundaryFile, NULL, 0);
  if (!xmlBoundary)
    asfPrintError("Could not parse boundary file (%s)\n", boundaryFile);
  else {
    strcpy(coordStr, xml_get_string_value(xmlBoundary, 
      "kml.Document.Placemark.Polygon.outerBoundaryIs.LinearRing.coordinates"));    sscanf(coordStr, "%f,%f,%f\n%f,%f,%f\n%f,%f,%f\n%f,%f", 
	   &data->near_start_lat, &data->near_start_lon, &height,
	   &data->near_end_lat, &data->near_end_lon, &height,
	   &data->far_end_lat, &data->far_end_lon, &height,
	   &data->far_start_lat, &data->far_start_lon);
    //printf("Near start latitude: %.4f\n", data->near_start_lat);
    //printf("Near start longitude: %.4f\n", data->near_start_lon);
    //printf("Near end latitude: %.4f\n", data->near_end_lat);
    //printf("Near end longitude: %.4f\n", data->near_end_lon);
    //printf("Far start latitude: %.4f\n", data->far_start_lat);
    //printf("Far start longitude: %.4f\n", data->far_start_lon);
    //printf("Far end latitude: %.4f\n", data->far_end_lat);
    //printf("Far end longitude: %.4f\n", data->far_end_lon);
  }
  xmlFreeDoc(xmlBoundary);

  xmlDoc *xmlCenter = xmlReadFile(centerFile, NULL, 0);
  if (!xmlCenter)
    asfPrintWarning("Could not parse center point file (%s)\n", centerFile);
  else {
    strcpy(coordStr, xml_get_string_value(xmlCenter, 
      "kml.Document.Placemark.Point.coordinates"));
    sscanf(coordStr, "%f,%f", &data->center_lat, &data->center_lon);
    //printf("Center latitude: %.4f\n", data->center_lat);
    //printf("Center longitude: %.4f\n", data->center_lon);
  }
  xmlFreeDoc(xmlCenter);

  // Processing level
  strcpy(string, xml_get_string_value(doc, 
    "metadata.idinfo.proclevl.prolevid"));
  if (strlen(string) > MAX_PROCESSING_LEVEL) {
    error = TRUE;
    sprintf(tmp, 
	    "Processing level - String length: %d, allowed characters: %d\n",
	    (int) strlen(string), MAX_PROCESSING_LEVEL);
    strcat(errorMessage, tmp);
  }
  else {
    strcpy(data->processing_level, xml_get_string_value(doc, 
      "metadata.idinfo.proclevl.prolevid"));
    //printf("Processing level: %s\n", data->processing_level);
  }

  // Place
  strcpy(string, xml_get_string_value(doc, 
    "metadata.idinfo.keywords.place.placekey[0]"));
  if (strlen(string) > MAX_PLACE) {
    error = TRUE;
    sprintf(tmp, 
	    "Place - String length: %d, allowed characters: %d\n",
	    (int) strlen(string), MAX_PLACE);
    strcat(errorMessage, tmp);
  }
  else {
    data->place = (char *) MALLOC(sizeof(char)*MAX_PLACE);
    strcpy(data->place, xml_get_string_value(doc, 
      "metadata.idinfo.keywords.place.placekey[0]"));
    //printf("Place: %s\n", data->place);
  }

  // Platform
  strcpy(string, xml_get_string_value(doc, 
    "metadata.idinfo.plainsid.platflnm"));
  if (strlen(string) > MAX_PLATFORM) {
    error = TRUE;
    sprintf(tmp, "Platform - String length: %d, allowed characters: %d\n",
	    (int) strlen(string), MAX_PLATFORM);
    strcat(errorMessage, tmp);
  }
  else {
    strcpy(data->platform, xml_get_string_value(doc, 
      "metadata.idinfo.plainsid.platflnm"));
    //printf("Platform: %s\n", data->platform);
  }

  // Instrument
  strcpy(string, xml_get_string_value(doc, 
    "metadata.idinfo.plainsid.instflnm"));
  if (strlen(string) > MAX_INSTRUMENT) {
    error = TRUE;
    sprintf(tmp, "Instrument - String length: %d, allowed characters: %d\n",
	    (int) strlen(string), MAX_INSTRUMENT);
    strcat(errorMessage, tmp);
  }
  else {
    strcpy(data->instrument, xml_get_string_value(doc, 
      "metadata.idinfo.plainsid.instflnm"));
    //printf("Instrument: %s\n", data->instrument);
  }

  // Number of bands
  nValue = xml_get_int_value(doc, "metadata.idinfo.bandidnt.numbands");
  if (nValue < 0) {
    error = TRUE;
    sprintf(tmp, "Number of bands - Value (%i) outside the "
	    "expected value range (value > 0)\n", nValue);
    strcat(errorMessage, tmp);
  }
  else {
    data->band_count =
      xml_get_int_value(doc, "metadata.idinfo.bandidnt.numbands");
    //printf("Number of bands: %i\n", data->band_count);
  }

  // Browse image location
  strcpy(string, xml_get_string_value(doc, "metadata.idinfo.browse.browsen"));
  if (strlen(string) > MAX_BROWSE_LOCATION) {
    error = TRUE;
    sprintf(tmp, "Browse image location - String length: %d, allowed "
	    "characters: %d\n", (int) strlen(string), MAX_BROWSE_LOCATION);
    strcat(errorMessage, tmp);
  }
  else if (strcmp_case(string, MAGIC_UNSET_STRING) != 0) {
    data->browse_location = (char *) MALLOC(sizeof(char)*MAX_BROWSE_LOCATION);
    strcpy(data->browse_location, xml_get_string_value(doc, 
      "metadata.idinfo.browse.browsen"));
    //printf("Browse image location: %s\n", data->browse_location);
  }

  // Browse image format
  strcpy(string, xml_get_string_value(doc, "metadata.idinfo.browse.browset"));
  if (strlen(string) > MAX_BROWSE_FORMAT) {
    error = TRUE;
    sprintf(tmp, "Browse image format - String length: %d, allowed characters:"
	    " %d\n", (int) strlen(string), MAX_BROWSE_FORMAT);
    strcat(errorMessage, tmp);
  }
  else if (strcmp_case(string, MAGIC_UNSET_STRING) != 0) {
    data->browse_format = (char *) MALLOC(sizeof(char)*MAX_BROWSE_FORMAT);
    strcpy(data->browse_format, xml_get_string_value(doc, 
      "metadata.idinfo.browse.browset"));
    //printf("Browse format: %s\n", data->browse_format);
  }

  // Data access level
  strcpy(string, xml_get_string_value(doc, 
    "metadata.idinfo.secinfo.secclass"));
  if (strlen(string) > MAX_ACCESS) {
    error = TRUE;
    sprintf(tmp, "Data access level - String length: %d, allowed characters: "
	    "%d\n", (int) strlen(string), MAX_ACCESS);
    strcat(errorMessage, tmp);
  }
  else {
    strcpy(data->access, xml_get_string_value(doc, 
      "metadata.idinfo.secinfo.secclass"));
    //printf("Data access level: %s\n", data->access);
  }

  // Copyright
  strcpy(string, xml_get_string_value(doc, "metadata.idinfo.copyright"));
  if (strlen(string) > MAX_COPYRIGHT) {
    error = TRUE;
    sprintf(tmp, "Copyright - String length: %d, allowed characters: %d\n",
	    (int) strlen(string), MAX_COPYRIGHT);
    strcat(errorMessage, tmp);
  }
  else {
    strcpy(data->copyright, xml_get_string_value(doc, 
      "metadata.idinfo.copyright"));
    //printf("Copyright: %s\n", data->copyright);
  }

  // Start time
  char dateStr[25], timeStr[25], *message;
  int year, month, day, hour, minute, second;
  strcpy(dateStr, xml_get_string_value(doc, 
    "metadata.idinfo.timeperd.timeinfo.rngdates.begdate"));
  year = subStr(0, 4, dateStr);
  month = subStr(4, 2, dateStr);
  day = subStr(6, 2, dateStr);
  strcpy(timeStr, xml_get_string_value(doc, 
    "metadata.idinfo.timeperd.timeinfo.rngdates.begtime"));
  hour = subStr(0, 2, timeStr);
  minute = subStr(2, 2, timeStr);
  second = subStr(4, 2, timeStr);
  if (strcmp_case(dateStr, MAGIC_UNSET_STRING) != 0 &&
      strcmp_case(timeStr, MAGIC_UNSET_STRING) != 0) {
    if (isNumeric(dateStr) && isNumeric(timeStr)) {
      message = checkTime(year, month, day, hour, minute, second);
      if (message) {
	error = TRUE;
	sprintf(tmp, "Start time - %s", message);
	strcat(errorMessage, tmp);
      }
      else {
	data->start_time = (char *) MALLOC(sizeof(char)*MAX_START_TIME);
	sprintf(data->start_time, "%04d-%02d-%02d %02d:%02d:%02d", 
		year, month, day, hour, minute, second);
	//printf("Start time: %s\n", data->start_time);
      }
    }
  }

  // Center time
  strcpy(dateStr, xml_get_string_value(doc, 
    "metadata.idinfo.timeperd.timeinfo.sngdate.caldate"));
  year = subStr(0, 4, dateStr);
  month = subStr(4, 2, dateStr);
  day = subStr(6, 2, dateStr);
  strcpy(timeStr, xml_get_string_value(doc, 
    "metadata.idinfo.timeperd.timeinfo.sngdate.time"));
  hour = subStr(0, 2, timeStr);
  minute = subStr(2, 2, timeStr);
  second = subStr(4, 2, timeStr);
  if (strcmp_case(dateStr, MAGIC_UNSET_STRING) != 0 &&
      strcmp_case(timeStr, MAGIC_UNSET_STRING) != 0) {
    if (isNumeric(dateStr) && isNumeric(timeStr)) {
      message = checkTime(year, month, day, hour, minute, second);
      if (message) {
	error = TRUE;
	sprintf(tmp, "Center time - %s", message);
	strcat(errorMessage, tmp);
      }
      else {
	data->center_time = (char *) MALLOC(sizeof(char)*MAX_CENTER_TIME);
	sprintf(data->center_time, "%04d-%02d-%02d %02d:%02d:%02d", 
		year, month, day, hour, minute, second);
	//printf("Center time: %s\n", data->center_time);
      }
    }
  }

  // End time
  strcpy(dateStr, xml_get_string_value(doc, 
    "metadata.idinfo.timeperd.timeinfo.rngdates.enddate"));
  year = subStr(0, 4, dateStr);
  month = subStr(4, 2, dateStr);
  day = subStr(6, 2, dateStr);
  strcpy(timeStr, xml_get_string_value(doc, 
    "metadata.idinfo.timeperd.timeinfo.rngdates.endtime"));
  hour = subStr(0, 2, timeStr);
  minute = subStr(2, 2, timeStr);
  second = subStr(4, 2, timeStr);
  if (strcmp_case(dateStr, MAGIC_UNSET_STRING) != 0 &&
      strcmp_case(timeStr, MAGIC_UNSET_STRING) != 0) {
    if (isNumeric(dateStr) && isNumeric(timeStr)) {
      message = checkTime(year, month, day, hour, minute, second);
      if (message) {
	error = TRUE;
	sprintf(tmp, "End time - %s", message);
	strcat(errorMessage, tmp);
      }
      else {
	data->end_time = (char *) MALLOC(sizeof(char)*MAX_END_TIME);
	sprintf(data->end_time, "%04d-%02d-%02d %02d:%02d:%02d", 
		year, month, day, hour, minute, second);
	//printf("End time: %s\n", data->end_time);
      }
    }
  }

  // Orbit direction
  nValue = xml_get_int_value(doc, "metadata.dataqual.acqinfo.ascdscin");
  if (nValue != MAGIC_UNSET_INT) {
    if (nValue < 0 || nValue > 1) {
      error = TRUE;
      sprintf(tmp, "Orbit direction - Value (%i) outside the "
	      "expected value range (0 <= value <= 1)\n", nValue);
      strcat(errorMessage, tmp);
    }
    else {
      if (nValue == 0)
	strcpy(data->orbit_direction, "Ascending");
      else if (nValue == 1)
	strcpy(data->orbit_direction, "Descending");
      //printf("Orbit direction: %s\n", data->orbit_direction);
    }
  }
  else
    strcpy(data->orbit_direction, "Unknown");

  // Imaging mode
  strcpy(string, xml_get_string_value(doc, "metadata.idinfo.plainsid.mode"));
  if (strcmp_case(string, MAGIC_UNSET_STRING) != 0) {
    if (strlen(string) > MAX_MODE) {
      error = TRUE;
      sprintf(tmp, "Imaging mode - String length: %d, allowed characters: %d"
	      "\n", (int) strlen(string), MAX_MODE);
      strcat(errorMessage, tmp);
    }
    else {
      strcpy(data->mode, 
	     xml_get_string_value(doc, "metadata.idinfo.plainsid.mode"));
      //printf("Imaging mode: %s\n", data->mode);
    }
  }
  else
    strcpy(data->mode, "Unknown");

  // Spatial reference
  strcpy(string, xml_get_string_value(doc, "metadata.spdoinfo.direct"));
  if (strcmp_case(string, "Point") !=  0 &&
      strcmp_case(string, "Vector") != 0 &&
      strcmp_case(string, "Raster") != 0) {
    error = TRUE;
    sprintf(tmp, "Spatial reference - String (%s) not valid; expected "
	    "\"Point\", \"Vector\" or \"Raster\"\n", string);
    strcat(errorMessage, tmp);
  }
  else {
    strcpy(data->spatial_reference, 
	   xml_get_string_value(doc, "metadata.spdoinfo.direct"));
    //printf("Spatial reference: %s\n", data->spatial_reference);
  }

  // Cell value type
  strcpy(string, xml_get_string_value(doc, 
    "metadata.spdoinfo.rastinfo.cvaltype"));
  if (strlen(string) > MAX_CELL_VALUE) {
    error = TRUE;
    sprintf(tmp, 
	    "Cell value type - String length: %d, allowed characters: %d\n",
	    (int) strlen(string), MAX_CELL_VALUE);
    strcat(errorMessage, tmp);
  }
  else {
    strcpy(data->cell_value, xml_get_string_value(doc, 
      "metadata.spdoinfo.rastinfo.cvaltype"));
    //printf("Cell value type: %s\n", data->cell_value);
  }

  // Raster object type
  strcpy(string, xml_get_string_value(doc, 
    "metadata.spdoinfo.rastinfo.rasttype"));
  if (strcmp_case(string, "Point") != 0 &&
      strcmp_case(string, "Pixel") != 0 &&
      strcmp_case(string, "Grid Cell") != 0 &&
      strcmp_case(string, "Voxel") != 0 &&
      strcmp_case(string, "Swath") != 0) {
    error = TRUE;
    sprintf(tmp, "Raster object type - String (%s) not valid; expected "
	    "\"Point\", \"Pixel\", \"Grid Cell\", \"Voxel\" or \"Swath\".\n",
	    string);
    strcat(errorMessage, tmp);
  }
  else {
    strcpy(data->raster_object, xml_get_string_value(doc, 
      "metadata.spdoinfo.rastinfo.rasttype"));
    //printf("Raster object type: %s\n", data->raster_object);
  }

  // Number of rows
  nValue = xml_get_int_value(doc, "metadata.spdoinfo.rastinfo.rowcount");
  if (nValue < 0) {
    error = TRUE;
    sprintf(tmp, "Number of rows - Value (%i) outside the "
	    "expected value range (value > 0)\n", nValue);
    strcat(errorMessage, tmp);
  }
  else {
    data->row_count =
      xml_get_int_value(doc, "metadata.spdoinfo.rastinfo.rowcount");
    //printf("Number of rows: %i\n", data->row_count);
  }

  // Number of columns
  nValue = xml_get_int_value(doc, "metadata.spdoinfo.rastinfo.colcount");
  if (nValue < 0) {
    error = TRUE;
    sprintf(tmp, "Number of columns - Value (%i) outside the "
	    "expected value range (value > 0)\n", nValue);
    strcat(errorMessage, tmp);
  }
  else {
    data->col_count =
      xml_get_int_value(doc, "metadata.spdoinfo.rastinfo.colcount");
    //printf("Number of columns: %i\n", data->col_count);
  }

  // Format name
  strcpy(string, xml_get_string_value(doc, 
    "metadata.distinfo.stdorder.digform.digtinfo.formname"));
  if (strlen(string) > MAX_FORMAT) {
    error = TRUE;
    sprintf(tmp, 
	    "Format name - String length: %d, allowed characters: %d\n",
	    (int) strlen(string), MAX_FORMAT);
    strcat(errorMessage, tmp);
  }
  else {
    strcpy(data->format, xml_get_string_value(doc, 
      "metadata.distinfo.stdorder.digform.digtinfo.formname"));
    //printf("Format name: %s\n", data->format);
  }

  // Fees
  fValue = xml_get_double_value(doc, "metadata.distinfo.stdorder.fees");
  if (fValue < 0.0) {
    error = TRUE;
    sprintf(tmp, "Fees - Value (%.2lf) outside the expected value range "
	    "(value >= 0.0)\n", fValue);
    strcat(errorMessage, tmp);
  }
  else {
    data->fees = xml_get_double_value(doc, "metadata.distinfo.stdorder.fees");
    //printf("Fees: %.2lf\n", data->fees);
  }

  if (error)
    asfPrintError("%s", errorMessage);

  xmlFreeDoc(doc);
  xmlCleanupParser();

  FREE(configFile);
  FCLOSE(fLog);
  remove(logFile);

  // Add dataset to database
  addData(data);

  FREE(data);

  asfPrintStatus("\nSuccessful completion!\n\n");

  return(EXIT_SUCCESS);
}