kis_cos_parser.cpp File Reference

#include "kis_cos_parser.h"
#include <QTextCodec>
#include <QVariantHash>
#include <QVariantList>
#include <QBuffer>
#include <QVariant>
#include <QDebug>

Go to the source code of this file.

Enumerations
enum	{   Null = 0x00 , Space = 0x20 , Tab = 0x09 , LineFeed = 0x0a ,   FormFeed = 0x0c , Return = 0x0d , BeginArray = 0x5b , BeginObject = 0x3c ,   EndArray = 0x5d , EndObject = 0x3e , BeginName = 0x2f , BeginString = 0x28 ,   EndString = 0x29 , ByteOrderMark = 0xfe }

Functions
void	eatSpace (QIODevice &dev)
bool	isWhiteSpace (char c)
bool	parseHexString (QIODevice &dev, QVariant &val)
bool	parseName (QIODevice &dev, QVariant &val)
bool	parseNumber (QIODevice &dev, QVariant &val)
bool	parseString (QIODevice &dev, QVariant &val)

Variables
const QMap< char, char >	escaped

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
Null
Space
Tab
LineFeed
FormFeed
Return
BeginArray
BeginObject
EndArray
EndObject
BeginName
BeginString
EndString
ByteOrderMark

Definition at line 15 of file kis_cos_parser.cpp.

     {
    Null = 0x00,
    Space = 0x20,
    Tab = 0x09,
    LineFeed = 0x0a,
    FormFeed = 0x0c,
    Return = 0x0d,
    BeginArray = 0x5b, // [
    BeginObject = 0x3c, // <
    EndArray = 0x5d, // ]
    EndObject = 0x3e, // >
    BeginName = 0x2f, // /
    BeginString = 0x28, // (
    EndString = 0x29, // )
    ByteOrderMark = 0xfe
};

Function Documentation

eatSpace()

void eatSpace

(

QIODevice &

dev

)

Definition at line 46 of file kis_cos_parser.cpp.

                              {
    char c;
    dev.peek(&c, 1);
    while (isWhiteSpace(c) && !dev.atEnd()) {
        dev.skip(1);
        dev.peek(&c, 1);
    }
}

References isWhiteSpace().

isWhiteSpace()

bool isWhiteSpace

(

char

c

)

Definition at line 32 of file kis_cos_parser.cpp.

                          {
    switch (c) {
    case Null:
    case Tab:
    case LineFeed:
    case FormFeed:
    case Return:
    case Space:
        return true;
    default:
        return false;
    }
}

References FormFeed, LineFeed, Null, Return, Space, and Tab.

parseHexString()

bool parseHexString	(	QIODevice &	dev,
		QVariant &	val )

Definition at line 136 of file kis_cos_parser.cpp.

                                                   {
    char c;
    dev.getChar(&c);
    QByteArray hex;
 
    while (c!= EndObject && !dev.atEnd()) {
        hex.append(c);
        dev.getChar(&c);
    }
 
    val = QString("<"+QString::fromLatin1(hex)+">");
    return true;
}

References EndObject.

parseName()

bool parseName	(	QIODevice &	dev,
		QVariant &	val )

Definition at line 55 of file kis_cos_parser.cpp.

                                              {
    char c;
    dev.getChar(&c);
    QString name = "/"; // prepending with / so that we know this is a name.
 
    while (c >= 0x21 && c<0x7e && !isWhiteSpace(c) && c != BeginName && !dev.atEnd()) {
        name.append(c);
        dev.getChar(&c);
    }
 
    if (c == BeginName) {
        dev.ungetChar(c);
    }
    val = QVariant(name);
    return true;
}

References BeginName, and isWhiteSpace().

parseNumber()

bool parseNumber	(	QIODevice &	dev,
		QVariant &	val )

Definition at line 150 of file kis_cos_parser.cpp.

                                                {
    char c;
    bool isDouble = false;
    dev.getChar(&c);
    QString number;
    if (c == '-' || c == '+') {
        number.append(c);
        dev.getChar(&c);
    }
    while (c >= '0' && c <= '9') {
        number.append(c);
        dev.getChar(&c);
    }
    if (c == '.') {
        isDouble = true;
        number.append(c);
        dev.getChar(&c);
        while (c >= '0' && c <= '9') {
            number.append(c);
            dev.getChar(&c);
        }
    }
 
    bool ok;
    if (isDouble) {
        val = number.toDouble(&ok);
    } else {
        val = number.toInt(&ok);
    }
    return ok;
}

parseString()

bool parseString	(	QIODevice &	dev,
		QVariant &	val )

Definition at line 83 of file kis_cos_parser.cpp.

                                                {
    char c;
    dev.getChar(&c);
    QByteArray text;
 
    while(c != EndString && !dev.atEnd()) {
        if (c == '\\') {
 
            // Try to parse PDF \ddd notation.
            char c2;
            dev.peek(&c2, 1);
 
            if (escaped.keys().contains(c2)) {
                text.append(escaped.value(c2));
                dev.skip(1);
            } else {
                QByteArray octal;
                for (int i=0; i<3; i++) {
                    char c2;
                    dev.peek(&c2, 1);
                    if (c2 >= '0' && c2 <= '9') {
                        octal.append(c2);
                        dev.skip(1);
                    }
                }
                bool ok;
                int val = octal.toInt(&ok, 8);
                if (ok) {
                    qWarning() << "escaped octal" << val;
                    // don't know how to actually interpret this as a char...
                } else {
                    text.append(c);
                    text.append(octal);
 
                }
            }
        } else {
            text.append(c);
        }
        dev.getChar(&c);
    }
 
 
    if (text.startsWith(ByteOrderMark)) {
        QTextCodec *Utf16Codec = QTextCodec::codecForName("UTF-16BE");
        val = Utf16Codec->toUnicode(text);
    } else {
        val = QString::fromLatin1(text);
    }
 
    return true;
}

References ByteOrderMark, EndString, and escaped.

Variable Documentation

escaped

const QMap<char, char> escaped

Initial value:

= {
    {'n', LineFeed},
    {'r', Return},
    {'t', Tab},
    {'b', 0x08}, 
    {'f', FormFeed},
    {'(', BeginString},
    {')', EndString},
    {'\\', 0x5c} 
}

Definition at line 72 of file kis_cos_parser.cpp.

                                 {
    {'n', LineFeed},
    {'r', Return},
    {'t', Tab},
    {'b', 0x08}, // backspace
    {'f', FormFeed},
    {'(', BeginString},
    {')', EndString},
    {'\\', 0x5c} // reverse solidus/backslash
};