Lines Matching defs:it8
384 static void* AllocChunk(cmsIT8* it8, cmsUInt32Number size);
484 cmsBool SynError(cmsIT8* it8, const char *Txt, ...)
494 snprintf(ErrMsg, 1023, "%s: Line %d, %s", it8->FileStack[it8 ->IncludeSP]->FileName, it8->lineno, Buffer);
496 it8->sy = SSYNERROR;
497 cmsSignalError(it8 ->ContextID, cmsERROR_CORRUPTION_DETECTED, "%s", ErrMsg);
503 cmsBool Check(cmsIT8* it8, SYMBOL sy, const char* Err)
505 if (it8 -> sy != sy)
506 return SynError(it8, NoMeta(Err));
512 void NextCh(cmsIT8* it8)
514 if (it8 -> FileStack[it8 ->IncludeSP]->Stream) {
516 it8 ->ch = fgetc(it8 ->FileStack[it8 ->IncludeSP]->Stream);
518 if (feof(it8 -> FileStack[it8 ->IncludeSP]->Stream)) {
520 if (it8 ->IncludeSP > 0) {
522 fclose(it8 ->FileStack[it8->IncludeSP--]->Stream);
523 it8 -> ch = ' '; // Whitespace to be ignored
526 it8 ->ch = 0; // EOF
530 it8->ch = *it8->Source;
531 if (it8->ch) it8->Source++;
567 void ReadReal(cmsIT8* it8, int inum)
569 it8->dnum = (cmsFloat64Number) inum;
571 while (isdigit(it8->ch)) {
573 it8->dnum = it8->dnum * 10.0 + (it8->ch - '0');
574 NextCh(it8);
577 if (it8->ch == '.') { // Decimal point
582 NextCh(it8); // Eats dec. point
584 while (isdigit(it8->ch)) {
586 frac = frac * 10.0 + (it8->ch - '0');
588 NextCh(it8);
591 it8->dnum = it8->dnum + (frac / xpow10(prec));
595 if (toupper(it8->ch) == 'E') {
600 NextCh(it8); sgn = 1;
602 if (it8->ch == '-') {
604 sgn = -1; NextCh(it8);
607 if (it8->ch == '+') {
610 NextCh(it8);
614 while (isdigit(it8->ch)) {
617 e = e * 10 + (it8->ch - '0');
619 NextCh(it8);
623 it8 -> dnum = it8 -> dnum * xpow10(e);
709 void InSymbol(cmsIT8* it8)
718 while (isseparator(it8->ch))
719 NextCh(it8);
721 if (isfirstidchar(it8->ch)) { // Identifier
724 idptr = it8->id;
728 if (++k < MAXID) *idptr++ = (char) it8->ch;
730 NextCh(it8);
732 } while (isidchar(it8->ch));
737 key = BinSrchKey(it8->id);
738 if (key == SUNDEFINED) it8->sy = SIDENT;
739 else it8->sy = key;
743 if (isdigit(it8->ch) || it8->ch == '.' || it8->ch == '-' || it8->ch == '+')
747 if (it8->ch == '-') {
749 NextCh(it8);
752 it8->inum = 0;
753 it8->sy = SINUM;
755 if (it8->ch == '0') { // 0xnnnn (Hexa) or 0bnnnn (Binary)
757 NextCh(it8);
758 if (toupper(it8->ch) == 'X') {
762 NextCh(it8);
763 while (isxdigit(it8->ch))
765 it8->ch = toupper(it8->ch);
766 if (it8->ch >= 'A' && it8->ch <= 'F') j = it8->ch -'A'+10;
767 else j = it8->ch - '0';
769 if ((long) it8->inum * 16L > (long) INT_MAX)
771 SynError(it8, "Invalid hexadecimal number");
775 it8->inum = it8->inum * 16 + j;
776 NextCh(it8);
781 if (toupper(it8->ch) == 'B') { // Binary
785 NextCh(it8);
786 while (it8->ch == '0' || it8->ch == '1')
788 j = it8->ch - '0';
790 if ((long) it8->inum * 2L > (long) INT_MAX)
792 SynError(it8, "Invalid binary number");
796 it8->inum = it8->inum * 2 + j;
797 NextCh(it8);
804 while (isdigit(it8->ch)) {
806 if ((long) it8->inum * 10L > (long) INT_MAX) {
807 ReadReal(it8, it8->inum);
808 it8->sy = SDNUM;
809 it8->dnum *= sign;
813 it8->inum = it8->inum * 10 + (it8->ch - '0');
814 NextCh(it8);
817 if (it8->ch == '.') {
819 ReadReal(it8, it8->inum);
820 it8->sy = SDNUM;
821 it8->dnum *= sign;
825 it8 -> inum *= sign;
829 if (isidchar(it8 ->ch)) {
831 if (it8 ->sy == SINUM) {
833 snprintf(it8->id, 127, "%d", it8->inum);
837 snprintf(it8->id, 127, it8 ->DoubleFormatter, it8->dnum);
840 k = (int) strlen(it8 ->id);
841 idptr = it8 ->id + k;
844 if (++k < MAXID) *idptr++ = (char) it8->ch;
846 NextCh(it8);
848 } while (isidchar(it8->ch));
851 it8->sy = SIDENT;
857 switch ((int) it8->ch) {
861 NextCh(it8);
867 it8->sy = SEOF;
873 NextCh(it8);
874 if (it8 ->ch == '\n')
875 NextCh(it8);
876 it8->sy = SEOLN;
877 it8->lineno++;
881 NextCh(it8);
882 it8->sy = SEOLN;
883 it8->lineno++;
888 NextCh(it8);
889 while (it8->ch && it8->ch != '\n' && it8->ch != '\r')
890 NextCh(it8);
892 it8->sy = SCOMMENT;
898 idptr = it8->str;
899 sng = it8->ch;
901 NextCh(it8);
903 while (k < MAXSTR && it8->ch != sng) {
905 if (it8->ch == '\n'|| it8->ch == '\r') k = MAXSTR+1;
907 *idptr++ = (char) it8->ch;
908 NextCh(it8);
913 it8->sy = SSTRING;
915 NextCh(it8);
920 SynError(it8, "Unrecognized character: 0x%x", it8 ->ch);
924 } while (it8->sy == SCOMMENT);
928 if (it8 -> sy == SINCLUDE) {
932 if(it8 -> IncludeSP >= (MAXINCLUDE-1)) {
934 SynError(it8, "Too many recursion levels");
938 InSymbol(it8);
939 if (!Check(it8, SSTRING, "Filename expected")) return;
941 FileNest = it8 -> FileStack[it8 -> IncludeSP + 1];
944 FileNest = it8 ->FileStack[it8 -> IncludeSP + 1] = (FILECTX*)AllocChunk(it8, sizeof(FILECTX));
949 if (BuildAbsolutePath(it8->str,
950 it8->FileStack[it8->IncludeSP]->FileName,
952 SynError(it8, "File path too long");
959 SynError(it8, "File %s not found", FileNest->FileName);
962 it8->IncludeSP++;
964 it8 ->ch = ' ';
965 InSymbol(it8);
972 cmsBool CheckEOLN(cmsIT8* it8)
974 if (!Check(it8, SEOLN, "Expected separator")) return FALSE;
975 while (it8 -> sy == SEOLN)
976 InSymbol(it8);
984 void Skip(cmsIT8* it8, SYMBOL sy)
986 if (it8->sy == sy && it8->sy != SEOF)
987 InSymbol(it8);
993 void SkipEOLN(cmsIT8* it8)
995 while (it8->sy == SEOLN) {
996 InSymbol(it8);
1003 cmsBool GetVal(cmsIT8* it8, char* Buffer, cmsUInt32Number max, const char* ErrorTitle)
1005 switch (it8->sy) {
1010 case SIDENT: strncpy(Buffer, it8->id, max);
1013 case SINUM: snprintf(Buffer, max, "%d", it8 -> inum); break;
1014 case SDNUM: snprintf(Buffer, max, it8->DoubleFormatter, it8 -> dnum); break;
1015 case SSTRING: strncpy(Buffer, it8->str, max);
1021 return SynError(it8, "%s", ErrorTitle);
1031 TABLE* GetTable(cmsIT8* it8)
1033 if ((it8 -> nTable >= it8 ->TablesCount)) {
1035 SynError(it8, "Table %d out of sequence", it8 -> nTable);
1036 return it8 -> Tab;
1039 return it8 ->Tab + it8 ->nTable;
1048 cmsIT8* it8 = (cmsIT8*) hIT8;
1050 if (it8 == NULL)
1053 if (it8->MemorySink) {
1058 for (p = it8->MemorySink; p != NULL; p = n) {
1061 if (p->Ptr) _cmsFree(it8 ->ContextID, p->Ptr);
1062 _cmsFree(it8 ->ContextID, p);
1066 if (it8->MemoryBlock)
1067 _cmsFree(it8 ->ContextID, it8->MemoryBlock);
1069 _cmsFree(it8 ->ContextID, it8);
1075 void* AllocBigBlock(cmsIT8* it8, cmsUInt32Number size)
1078 void* ptr = _cmsMallocZero(it8->ContextID, size);
1082 ptr1 = (OWNEDMEM*) _cmsMallocZero(it8 ->ContextID, sizeof(OWNEDMEM));
1086 _cmsFree(it8 ->ContextID, ptr);
1091 ptr1-> Next = it8 -> MemorySink;
1092 it8 -> MemorySink = ptr1;
1101 void* AllocChunk(cmsIT8* it8, cmsUInt32Number size)
1103 cmsUInt32Number Free = it8 ->Allocator.BlockSize - it8 ->Allocator.Used;
1110 if (it8 -> Allocator.BlockSize == 0)
1112 it8 -> Allocator.BlockSize = 20*1024;
1114 it8 ->Allocator.BlockSize *= 2;
1116 if (it8 ->Allocator.BlockSize < size)
1117 it8 ->Allocator.BlockSize = size;
1119 it8 ->Allocator.Used = 0;
1120 it8 ->Allocator.Block = (cmsUInt8Number*) AllocBigBlock(it8, it8 ->Allocator.BlockSize);
1123 ptr = it8 ->Allocator.Block + it8 ->Allocator.Used;
1124 it8 ->Allocator.Used += size;
1133 char *AllocString(cmsIT8* it8, const char* str)
1139 ptr = (char *) AllocChunk(it8, Size);
1186 KEYVALUE* AddToList(cmsIT8* it8, KEYVALUE** Head, const char *Key, const char *Subkey, const char* xValue, WRITEMODE WriteAs)
1198 // return SynError(it8, "duplicate key <%s>", Key);
1205 p = (KEYVALUE*) AllocChunk(it8, sizeof(KEYVALUE));
1208 SynError(it8, "AddToList: out of memory");
1213 p->Keyword = AllocString(it8, Key);
1214 p->Subkey = (Subkey == NULL) ? NULL : AllocString(it8, Subkey);
1244 p->Value = AllocString(it8, xValue);
1254 KEYVALUE* AddAvailableProperty(cmsIT8* it8, const char* Key, WRITEMODE as)
1256 return AddToList(it8, &it8->ValidKeywords, Key, NULL, NULL, as);
1261 KEYVALUE* AddAvailableSampleID(cmsIT8* it8, const char* Key)
1263 return AddToList(it8, &it8->ValidSampleID, Key, NULL, NULL, WRITE_UNCOOKED);
1268 void AllocTable(cmsIT8* it8)
1272 t = it8 ->Tab + it8 ->TablesCount;
1278 it8 ->TablesCount++;
1284 cmsIT8* it8 = (cmsIT8*) IT8;
1286 if (nTable >= it8 ->TablesCount) {
1288 if (nTable == it8 ->TablesCount) {
1290 AllocTable(it8);
1293 SynError(it8, "Table %d is out of sequence", nTable);
1298 it8 ->nTable = nTable;
1308 cmsIT8* it8;
1311 it8 = (cmsIT8*) _cmsMallocZero(ContextID, sizeof(cmsIT8));
1312 if (it8 == NULL) return NULL;
1314 AllocTable(it8);
1316 it8->MemoryBlock = NULL;
1317 it8->MemorySink = NULL;
1319 it8 ->nTable = 0;
1321 it8->ContextID = ContextID;
1322 it8->Allocator.Used = 0;
1323 it8->Allocator.Block = NULL;
1324 it8->Allocator.BlockSize = 0;
1326 it8->ValidKeywords = NULL;
1327 it8->ValidSampleID = NULL;
1329 it8 -> sy = SUNDEFINED;
1330 it8 -> ch = ' ';
1331 it8 -> Source = NULL;
1332 it8 -> inum = 0;
1333 it8 -> dnum = 0.0;
1335 it8->FileStack[0] = (FILECTX*)AllocChunk(it8, sizeof(FILECTX));
1336 it8->IncludeSP = 0;
1337 it8 -> lineno = 1;
1339 strcpy(it8->DoubleFormatter, DEFAULT_DBL_FORMAT);
1340 cmsIT8SetSheetType((cmsHANDLE) it8, "CGATS.17");
1345 AddAvailableProperty(it8, PredefinedProperties[i].id, PredefinedProperties[i].as);
1348 AddAvailableSampleID(it8, PredefinedSampleID[i]);
1351 return (cmsHANDLE) it8;
1371 cmsIT8* it8 = (cmsIT8*) hIT8;
1376 return AddToList(it8, &GetTable(it8)->HeaderList, "# ", NULL, Val, WRITE_UNCOOKED) != NULL;
1382 cmsIT8* it8 = (cmsIT8*) hIT8;
1387 return AddToList(it8, &GetTable(it8)->HeaderList, Key, NULL, Val, WRITE_STRINGIFY) != NULL;
1392 cmsIT8* it8 = (cmsIT8*) hIT8;
1395 snprintf(Buffer, 1023, it8->DoubleFormatter, Val);
1397 return AddToList(it8, &GetTable(it8)->HeaderList, cProp, NULL, Buffer, WRITE_UNCOOKED) != NULL;
1402 cmsIT8* it8 = (cmsIT8*) hIT8;
1407 return AddToList(it8, &GetTable(it8)->HeaderList, cProp, NULL, Buffer, WRITE_HEXADECIMAL) != NULL;
1412 cmsIT8* it8 = (cmsIT8*) hIT8;
1414 return AddToList(it8, &GetTable(it8)->HeaderList, Key, NULL, Buffer, WRITE_UNCOOKED) != NULL;
1419 cmsIT8* it8 = (cmsIT8*) hIT8;
1421 return AddToList(it8, &GetTable(it8)->HeaderList, Key, SubKey, Buffer, WRITE_PAIR) != NULL;
1427 cmsIT8* it8 = (cmsIT8*) hIT8;
1430 if (IsAvailableOnList(GetTable(it8) -> HeaderList, Key, NULL, &p))
1449 cmsIT8* it8 = (cmsIT8*) hIT8;
1452 if (IsAvailableOnList(GetTable(it8) -> HeaderList, Key, SubKey, &p)) {
1462 void AllocateDataFormat(cmsIT8* it8)
1464 TABLE* t = GetTable(it8);
1468 t -> nSamples = (int) cmsIT8GetPropertyDbl(it8, "NUMBER_OF_FIELDS");
1472 SynError(it8, "AllocateDataFormat: Unknown NUMBER_OF_FIELDS");
1476 t -> DataFormat = (char**) AllocChunk (it8, ((cmsUInt32Number) t->nSamples + 1) * sizeof(char *));
1479 SynError(it8, "AllocateDataFormat: Unable to allocate dataFormat array");
1485 const char *GetDataFormat(cmsIT8* it8, int n)
1487 TABLE* t = GetTable(it8);
1496 cmsBool SetDataFormat(cmsIT8* it8, int n, const char *label)
1498 TABLE* t = GetTable(it8);
1501 AllocateDataFormat(it8);
1504 SynError(it8, "More than NUMBER_OF_FIELDS fields.");
1509 t->DataFormat[n] = AllocString(it8, label);
1518 cmsIT8* it8 = (cmsIT8*) h;
1519 return SetDataFormat(it8, n, Sample);
1523 void AllocateDataSet(cmsIT8* it8)
1525 TABLE* t = GetTable(it8);
1529 t-> nSamples = atoi(cmsIT8GetProperty(it8, "NUMBER_OF_FIELDS"));
1530 t-> nPatches = atoi(cmsIT8GetProperty(it8, "NUMBER_OF_SETS"));
1532 t-> Data = (char**)AllocChunk (it8, ((cmsUInt32Number) t->nSamples + 1) * ((cmsUInt32Number) t->nPatches + 1) *sizeof (char*));
1535 SynError(it8, "AllocateDataSet: Unable to allocate data array");
1541 char* GetData(cmsIT8* it8, int nSet, int nField)
1543 TABLE* t = GetTable(it8);
1555 cmsBool SetData(cmsIT8* it8, int nSet, int nField, const char *Val)
1557 TABLE* t = GetTable(it8);
1560 AllocateDataSet(it8);
1566 return SynError(it8, "Patch %d out of range, there are %d patches", nSet, t -> nPatches);
1570 return SynError(it8, "Sample %d out of range, there are %d samples", nField, t ->nSamples);
1574 t->Data [nSet * t -> nSamples + nField] = AllocString(it8, Val);
1640 void WriteHeader(cmsIT8* it8, SAVESTREAM* fp)
1643 TABLE* t = GetTable(it8);
1671 if (!IsAvailableOnList(it8-> ValidKeywords, p->Keyword, NULL, NULL)) {
1679 AddAvailableProperty(it8, p->Keyword, WRITE_UNCOOKED);
1707 default: SynError(it8, "Unknown write mode %d", p ->WriteAs);
1720 void WriteDataFormat(SAVESTREAM* fp, cmsIT8* it8)
1723 TABLE* t = GetTable(it8);
1729 nSamples = atoi(cmsIT8GetProperty(it8, "NUMBER_OF_FIELDS"));
1743 void WriteData(SAVESTREAM* fp, cmsIT8* it8)
1746 TABLE* t = GetTable(it8);
1752 t->nPatches = atoi(cmsIT8GetProperty(it8, "NUMBER_OF_SETS"));
1789 cmsIT8* it8 = (cmsIT8*) hIT8;
1796 for (i=0; i < it8 ->TablesCount; i++) {
1799 WriteHeader(it8, &sd);
1800 WriteDataFormat(&sd, it8);
1801 WriteData(&sd, it8);
1815 cmsIT8* it8 = (cmsIT8*) hIT8;
1830 for (i=0; i < it8 ->TablesCount; i++) {
1833 WriteHeader(it8, &sd);
1834 WriteDataFormat(&sd, it8);
1835 WriteData(&sd, it8);
1852 cmsBool DataFormatSection(cmsIT8* it8)
1855 TABLE* t = GetTable(it8);
1857 InSymbol(it8); // Eats "BEGIN_DATA_FORMAT"
1858 CheckEOLN(it8);
1860 while (it8->sy != SEND_DATA_FORMAT &&
1861 it8->sy != SEOLN &&
1862 it8->sy != SEOF &&
1863 it8->sy != SSYNERROR) {
1865 if (it8->sy != SIDENT) {
1867 return SynError(it8, "Sample type expected");
1870 if (!SetDataFormat(it8, iField, it8->id)) return FALSE;
1873 InSymbol(it8);
1874 SkipEOLN(it8);
1877 SkipEOLN(it8);
1878 Skip(it8, SEND_DATA_FORMAT);
1879 SkipEOLN(it8);
1882 SynError(it8, "Count mismatch. NUMBER_OF_FIELDS was %d, found %d\n", t ->nSamples, iField);
1893 cmsBool DataSection (cmsIT8* it8)
1898 TABLE* t = GetTable(it8);
1900 InSymbol(it8); // Eats "BEGIN_DATA"
1901 CheckEOLN(it8);
1904 AllocateDataSet(it8);
1906 while (it8->sy != SEND_DATA && it8->sy != SEOF)
1914 if (it8->sy != SEND_DATA && it8->sy != SEOF) {
1916 if (!GetVal(it8, Buffer, 255, "Sample data expected"))
1919 if (!SetData(it8, iSet, iField, Buffer))
1924 InSymbol(it8);
1925 SkipEOLN(it8);
1929 SkipEOLN(it8);
1930 Skip(it8, SEND_DATA);
1931 SkipEOLN(it8);
1936 return SynError(it8, "Count mismatch. NUMBER_OF_SETS was %d, found %d\n", t ->nPatches, iSet+1);
1945 cmsBool HeaderSection(cmsIT8* it8)
1951 while (it8->sy != SEOF &&
1952 it8->sy != SSYNERROR &&
1953 it8->sy != SBEGIN_DATA_FORMAT &&
1954 it8->sy != SBEGIN_DATA) {
1957 switch (it8 -> sy) {
1960 InSymbol(it8);
1961 if (!GetVal(it8, Buffer, MAXSTR-1, "Keyword expected")) return FALSE;
1962 if (!AddAvailableProperty(it8, Buffer, WRITE_UNCOOKED)) return FALSE;
1963 InSymbol(it8);
1968 InSymbol(it8);
1969 if (!GetVal(it8, Buffer, MAXSTR-1, "Keyword expected")) return FALSE;
1970 if (!AddAvailableSampleID(it8, Buffer)) return FALSE;
1971 InSymbol(it8);
1976 strncpy(VarName, it8->id, MAXID-1);
1979 if (!IsAvailableOnList(it8-> ValidKeywords, VarName, NULL, &Key)) {
1982 return SynError(it8, "Undefined keyword '%s'", VarName);
1984 Key = AddAvailableProperty(it8, VarName, WRITE_UNCOOKED);
1989 InSymbol(it8);
1990 if (!GetVal(it8, Buffer, MAXSTR-1, "Property data expected")) return FALSE;
1993 AddToList(it8, &GetTable(it8)->HeaderList, VarName, NULL, Buffer,
1994 (it8->sy == SSTRING) ? WRITE_STRINGIFY : WRITE_UNCOOKED);
1999 if (it8->sy != SSTRING)
2000 return SynError(it8, "Invalid value '%s' for property '%s'.", Buffer, VarName);
2015 return SynError(it8, "Invalid value for property '%s'.", VarName);
2030 return SynError(it8, "Invalid value for property '%s'.", VarName);
2031 AddToList(it8, &GetTable(it8)->HeaderList, VarName, Subkey, Value, WRITE_PAIR);
2035 InSymbol(it8);
2042 return SynError(it8, "expected keyword or identifier");
2045 SkipEOLN(it8);
2054 void ReadType(cmsIT8* it8, char* SheetTypePtr)
2058 while (isseparator(it8->ch))
2059 NextCh(it8);
2061 while (it8->ch != '\r' && it8 ->ch != '\n' && it8->ch != '\t' && it8 -> ch != -1) {
2063 *SheetTypePtr++= (char) it8 ->ch;
2064 NextCh(it8);
2072 cmsBool ParseIT8(cmsIT8* it8, cmsBool nosheet)
2074 char* SheetTypePtr = it8 ->Tab[0].SheetType;
2077 ReadType(it8, SheetTypePtr);
2080 InSymbol(it8);
2082 SkipEOLN(it8);
2084 while (it8-> sy != SEOF &&
2085 it8-> sy != SSYNERROR) {
2087 switch (it8 -> sy) {
2090 if (!DataFormatSection(it8)) return FALSE;
2095 if (!DataSection(it8)) return FALSE;
2097 if (it8 -> sy != SEOF) {
2099 AllocTable(it8);
2100 it8 ->nTable = it8 ->TablesCount - 1;
2107 if (it8 ->sy == SIDENT) {
2111 while (isseparator(it8->ch))
2112 NextCh(it8);
2115 if (it8 ->ch == '\n' || it8->ch == '\r') {
2117 cmsIT8SetSheetType(it8, it8 ->id);
2118 InSymbol(it8);
2123 cmsIT8SetSheetType(it8, "");
2128 if (it8 ->sy == SSTRING) {
2129 cmsIT8SetSheetType(it8, it8 ->str);
2130 InSymbol(it8);
2138 SkipEOLN(it8);
2142 if (!HeaderSection(it8)) return FALSE;
2147 return (it8 -> sy != SSYNERROR);
2155 void CookPointers(cmsIT8* it8)
2160 cmsUInt32Number nOldTable = it8 ->nTable;
2162 for (j=0; j < it8 ->TablesCount; j++) {
2164 TABLE* t = it8 ->Tab + j;
2167 it8 ->nTable = j;
2172 SynError(it8, "Undefined DATA_FORMAT");
2186 char *Data = GetData(it8, i, idField);
2196 SetData(it8, i, idField, Buffer);
2210 char *Label = GetData(it8, i, idField);
2219 for (k=0; k < it8 ->TablesCount; k++) {
2221 TABLE* Table = it8 ->Tab + k;
2234 SetData(it8, i, idField, Buffer);
2249 it8 ->nTable = nOldTable;
2323 cmsIT8* it8;
2335 it8 = (cmsIT8*) hIT8;
2336 it8 ->MemoryBlock = (char*) _cmsMalloc(ContextID, len + 1);
2338 strncpy(it8 ->MemoryBlock, (const char*) Ptr, len);
2339 it8 ->MemoryBlock[len] = 0;
2341 strncpy(it8->FileStack[0]->FileName, "", cmsMAX_PATH-1);
2342 it8-> Source = it8 -> MemoryBlock;
2344 if (!ParseIT8(it8, type-1)) {
2350 CookPointers(it8);
2351 it8 ->nTable = 0;
2353 _cmsFree(ContextID, it8->MemoryBlock);
2354 it8 -> MemoryBlock = NULL;
2366 cmsIT8* it8;
2375 it8 = (cmsIT8*) hIT8;
2379 it8 ->FileStack[0]->Stream = fopen(cFileName, "rt");
2381 if (!it8 ->FileStack[0]->Stream) {
2387 strncpy(it8->FileStack[0]->FileName, cFileName, cmsMAX_PATH-1);
2388 it8->FileStack[0]->FileName[cmsMAX_PATH-1] = 0;
2390 if (!ParseIT8(it8, type-1)) {
2392 fclose(it8 ->FileStack[0]->Stream);
2397 CookPointers(it8);
2398 it8 ->nTable = 0;
2400 if (fclose(it8 ->FileStack[0]->Stream)!= 0) {
2411 cmsIT8* it8 = (cmsIT8*) hIT8;
2416 t = GetTable(it8);
2426 cmsIT8* it8 = (cmsIT8*) hIT8;
2434 t = GetTable(it8);
2444 Props = (char **) AllocChunk(it8, sizeof(char *) * n);
2458 cmsIT8* it8 = (cmsIT8*) hIT8;
2467 t = GetTable(it8);
2483 Props = (const char **) AllocChunk(it8, sizeof(char *) * n);
2497 int LocatePatch(cmsIT8* it8, const char* cPatch)
2501 TABLE* t = GetTable(it8);
2505 data = GetData(it8, i, t->SampleID);
2514 // SynError(it8, "Couldn't find patch '%s'\n", cPatch);
2520 int LocateEmptyPatch(cmsIT8* it8)
2524 TABLE* t = GetTable(it8);
2528 data = GetData(it8, i, t->SampleID);
2539 int LocateSample(cmsIT8* it8, const char* cSample)
2543 TABLE* t = GetTable(it8);
2547 fld = GetDataFormat(it8, i);
2561 cmsIT8* it8 = (cmsIT8*) hIT8;
2565 return LocateSample(it8, cSample);
2572 cmsIT8* it8 = (cmsIT8*) hIT8;
2576 return GetData(it8, row, col);
2594 cmsIT8* it8 = (cmsIT8*) hIT8;
2598 return SetData(it8, row, col, Val);
2604 cmsIT8* it8 = (cmsIT8*) hIT8;
2609 snprintf(Buff, 255, it8->DoubleFormatter, Val);
2611 return SetData(it8, row, col, Buff);
2618 cmsIT8* it8 = (cmsIT8*) hIT8;
2623 iField = LocateSample(it8, cSample);
2628 iSet = LocatePatch(it8, cPatch);
2633 return GetData(it8, iSet, iField);
2637 cmsFloat64Number CMSEXPORT cmsIT8GetDataDbl(cmsHANDLE it8, const char* cPatch, const char* cSample)
2641 Buffer = cmsIT8GetData(it8, cPatch, cSample);
2650 cmsIT8* it8 = (cmsIT8*) hIT8;
2656 t = GetTable(it8);
2658 iField = LocateSample(it8, cSample);
2665 AllocateDataFormat(it8);
2666 AllocateDataSet(it8);
2667 CookPointers(it8);
2672 iSet = LocateEmptyPatch(it8);
2674 return SynError(it8, "Couldn't add more patches '%s'\n", cPatch);
2680 iSet = LocatePatch(it8, cPatch);
2686 return SetData(it8, iSet, iField, Val);
2694 cmsIT8* it8 = (cmsIT8*) hIT8;
2699 snprintf(Buff, 255, it8->DoubleFormatter, Val);
2707 cmsIT8* it8 = (cmsIT8*) hIT8;
2713 t = GetTable(it8);
2714 Data = GetData(it8, nPatch, t->SampleID);
2733 cmsIT8* it8 = (cmsIT8*) hIT8;
2737 return it8 ->TablesCount;
2777 cmsIT8* it8 = (cmsIT8*) hIT8;
2782 pos = LocateSample(it8, cSample);
2786 it8->Tab[it8->nTable].SampleID = pos;
2793 cmsIT8* it8 = (cmsIT8*) hIT8;
2798 strcpy(it8->DoubleFormatter, DEFAULT_DBL_FORMAT);
2800 strncpy(it8->DoubleFormatter, Formatter, sizeof(it8->DoubleFormatter));
2802 it8 ->DoubleFormatter[sizeof(it8 ->DoubleFormatter)-1] = 0;