~ubuntu-branches/ubuntu/karmic/lcms/karmic

//

//  Little cms

//

// Permission is hereby granted, free of charge, to any person obtaining 

// a copy of this software and associated documentation files (the "Software"), 

// Persistence

LCMSAPI LCMSHANDLE      LCMSEXPORT cmsIT8LoadFromFile(const char* cFileName);

LCMSAPI LCMSHANDLE      LCMSEXPORT cmsIT8LoadFromMem(void *Ptr, size_t len);

 

// Properties

LCMSAPI const char*     LCMSEXPORT cmsIT8GetSheetType(LCMSHANDLE hIT8);

 

LCMSAPI const char*     LCMSEXPORT cmsIT8GetProperty(LCMSHANDLE hIT8, const char* cProp);

LCMSAPI double          LCMSEXPORT cmsIT8GetPropertyDbl(LCMSHANDLE hIT8, const char* cProp);

LCMSAPI const char*     LCMSEXPORT cmsIT8GetDataRowCol(LCMSHANDLE IT8, int row, int col);                                                

LCMSAPI double          LCMSEXPORT cmsIT8GetDataRowColDbl(LCMSHANDLE IT8, int col, int row);

 

                                                const char* Val);

 

                                                double Val);

 

LCMSAPI const char*     LCMSEXPORT cmsIT8GetData(LCMSHANDLE IT8, const char* cPatch, const char* cSample);

 

LCMSAPI double          LCMSEXPORT cmsIT8GetDataDbl(LCMSHANDLE IT8, const char* cPatch, const char* cSample);                                                

 

                                                const char* cSample,

                                                const char *Val);

 

                                                const char* cSample,

                                                double Val);

 

LCMSAPI int             LCMSEXPORT cmsIT8EnumDataFormat(LCMSHANDLE IT8, char ***SampleNames);

 

LCMSAPI void            LCMSEXPORT cmsIT8DefineDblFormat(LCMSHANDLE IT8, const char* Formatter);

 

// Checks if c is a separator

static

{

        return (c == ' ') || (c == '\t') || (c == '\r');

}

 

// Checks whatever if c is a valid identifier char

static 

{

   return (!isseparator(c) && (c != '#') && (c !='\"') && (c != '\'') && (c > 32) && (c < 127));

}

 

// Checks whatsever if c is a valid identifier middle char.

static

{

   return isalnum(c) || ismiddle(c);

}

 

// Checks whatsever if c is a valid identifier first char.

static

{

     return !isdigit(c) && ismiddle(c);

}

// checks whether the supplied path looks like an absolute path

// NOTE: this function doesn't checks if the path exists or even if it's legal

static

{

        if(path == NULL)

                return FALSE;

// NOTE: both relPath and basePath are assumed to be no more than MAX_PATH characters long (including the null terminator!)

// NOTE: this function doesn't check if the path exists or even if it's legal

static 

{

                char *tail;

                tail = strrchr(buffer, DIR_CHAR);

                        size_t len = tail - buffer;

                        strncpy(tail + 1, relPath, MAX_PATH - len -1);

                        //      TODO: if combined path is longer than MAX_PATH, this should return FALSE!

                        return TRUE;

                }

        }

        return TRUE;

}

 

// Syntax error

static

{

        char Buffer[256], ErrMsg[1024];

        va_list args;

 

        va_start(args, Txt);

        va_end(args);

 

        it8->sy = SSYNERROR;

        return FALSE;

}

 

// Check if current symbol is same as specified. issue an error else.

static

{

        if (it8 -> sy != sy)

        return TRUE;

}

 

 

// Checks end of line separator

static

{

        if (!Check(it8, SEOLN, "Expected separator")) return FALSE;

        while (it8 -> sy == SEOLN)

 

// Returns a string holding current value

static

{

    switch (it8->sy) {

 

 

 

    default:

    }

 

}

 

// ---------------------------------------------------------- Table

 

static

LPTABLE GetTable(LPIT8 it8)

}

 

// ---------------------------------------------------------- Memory management

        for (p = it8->MemorySink; p != NULL; p = n) {

 

            n = p->Next;

        }

    }

 

    if (it8->MemoryBlock)

 

}

 

 

void* AllocBigBlock(LPIT8 it8, size_t size)

{

   LPOWNEDMEM ptr1;

 

        if (ptr) {

 

                ZeroMemory(ptr, size);

 

                if (ptr1 == NULL) {

 

                    return NULL;

                }

 

// Searches through linked list

 

static

{

 

    for (;  p != NULL; p = p->Next) {

 

// Add a property into a linked list

static

{

    LPKEYVALUE p;

    LPKEYVALUE last;

 

                         last->Value   = AllocString(it8, xValue);

                         last->WriteAs = WriteAs;

    }

 

    p = (LPKEYVALUE) AllocChunk(it8, sizeof(KEYVALUE));

    if (p == NULL)

    {

}

 

static

{

        return AddToList(it8, &it8->ValidKeywords, Key, NULL, WRITE_UNCOOKED);

}

 

 

static

{

        return AddToList(it8, &it8->ValidSampleID, Key, NULL, WRITE_UNCOOKED);

}

    LPIT8 it8;

    int i;

 

    if (it8 == NULL) return NULL;

 

    ZeroMemory(it8, sizeof(IT8));

 

}

 

{

        LPIT8 it8 = (LPIT8) hIT8;

 

        return TRUE;

}

 

{

    LPIT8 it8 = (LPIT8) hIT8;

 

 

 

// Sets a property

{

    LPIT8 it8 = (LPIT8) hIT8;

 

}

 

 

{

    LPIT8 it8 = (LPIT8) hIT8;

    char Buffer[1024];

    return AddToList(it8, &GetTable(it8)->HeaderList, cProp, Buffer, WRITE_UNCOOKED);    

}

 

{

    LPIT8 it8 = (LPIT8) hIT8;

    char Buffer[1024];

    return AddToList(it8, &GetTable(it8)->HeaderList, cProp, Buffer, WRITE_HEXADECIMAL);    

}

 

{

    LPIT8 it8 = (LPIT8) hIT8;    

    

}

 

static

{

    LPTABLE t = GetTable(it8);

 

}

 

 

{

        LPIT8 it8 = (LPIT8) h;

        return SetDataFormat(it8, n, Sample);

}

 

static

{

    LPTABLE t = GetTable(it8);

 

}

 

 

static

void Writef(LPSAVESTREAM f, const char* frm, ...)

{

    va_list args;

 

    va_start(args, frm);

    WriteStr(f, Buffer);

    va_end(args);

 

 

 

// Saves whole file

{

    SAVESTREAM sd;      

    int i;

 

 

// Saves to memory

{

    SAVESTREAM sd;      

    int i;

// -------------------------------------------------------------- Higer level parsing

 

static

{

    int iField = 0;    

    LPTABLE t = GetTable(it8);

 

 

static

{

    int  iField = 0;

    int  iSet   = 0;

    InSymbol(it8);   // Eats "BEGIN_DATA"

    CheckEOLN(it8);

 

    while (it8->sy != SEND_DATA && it8->sy != SEOF)

    {

        if (iField >= t -> nSamples) {

 

        if (it8->sy != SEND_DATA && it8->sy != SEOF) {

 

                return FALSE;

 

            if (!SetData(it8, iSet, iField, Buffer))

 

 

static

{

    char VarName[MAXID];

    char Buffer[MAXSTR];

 

        case SKEYWORD:

                InSymbol(it8);

                if (!AddAvailableProperty(it8, Buffer)) return FALSE;

                InSymbol(it8);

                break;

                }

 

                InSymbol(it8);

 

                                

                AddToList(it8, &GetTable(it8)->HeaderList, VarName, Buffer, 

 

 

static

{

    char* SheetTypePtr;

 

 

    for (idField = 0; idField < t -> nSamples; idField++)

    {

        Fld = t->DataFormat[idField];

        if (!Fld) continue;

 

                                        char *Type  = p ->Value;

                                        int  nTable = k;                                        

 

                                                                                

                                        SetData(it8, i, idField, Buffer);

                                    }

// that should be something like some printable characters plus a \n

 

static

{

    size_t i;

 

 

 

static

{

   FILE *fp;

   size_t Size;

    if (!hIT8) return NULL;

 

    it8 = (LPIT8) hIT8;

 

    strncpy(it8 ->MemoryBlock, (const char*) Ptr, len);

    it8 ->MemoryBlock[len] = 0;

    CookPointers(it8);

    it8 ->nTable = 0;

 

    it8 -> MemoryBlock = NULL;

 

    return hIT8;

}

 

 

{

    LPIT8 it8 = (LPIT8) hIT8;

    

}

 

 

{

    LPIT8 it8 = (LPIT8) hIT8;

    char Buff[256];

 

 

 

                        const char* cSample,

                        const char *Val)

{

}

 

 

                        const char* cSample,

                        double Val)

{

    LPIT8 it8 = (LPIT8) hIT8;

    char Buff[256];

 

        return cmsIT8SetData(hIT8, cPatch, cSample, Buff);

 

}

 

 

const char* LCMSEXPORT cmsIT8GetPatchName(LCMSHANDLE hIT8, int nPatch, char* buffer)

{

        if (!Data) return NULL;

        if (!buffer) return Data;

 

        return buffer;

}

 

    cLabelFld = cmsIT8GetData(hIT8, cSet, cField); 

    if (!cLabelFld) return -1;

    

            return -1;

    

    if (ExpectedType != NULL && *ExpectedType == 0)