{ Created: Tuesday, January 15, 1991 at 8:56 AM Script.p Pascal Interface to the Macintosh Libraries Copyright Apple Computer, Inc. 1986-1991 All rights reserved } {$IFC UNDEFINED UsingIncludes} {$SETC UsingIncludes := 0} {$ENDC} {$IFC NOT UsingIncludes} UNIT Script; INTERFACE {$ENDC} {$IFC UNDEFINED UsingScript} {$SETC UsingScript := 1} {$I+} {$SETC ScriptIncludes := UsingIncludes} {$SETC UsingIncludes := 1} {$IFC UNDEFINED UsingTypes} {$I $$Shell(PInterfaces)Types.p} {$ENDC} {$IFC UNDEFINED UsingOSUtils} {$I $$Shell(PInterfaces)OSUtils.p} {$ENDC} {$IFC UNDEFINED UsingQuickdraw} {$I $$Shell(PInterfaces)Quickdraw.p} {$ENDC} {$SETC UsingIncludes := ScriptIncludes} CONST { Script System constants } smSystemScript = -1; {designates system script.} smCurrentScript = -2; {designates current font script.} smAllScripts = -3; {designates any script.} smRoman = 0; {Roman} smJapanese = 1; {Japanese} smTradChinese = 2; {Traditional Chinese} smKorean = 3; {Korean} smArabic = 4; {Arabic} smHebrew = 5; {Hebrew} smGreek = 6; {Greek} smCyrillic = 7; {Cyrillic} smRSymbol = 8; {Right-left symbol} smDevanagari = 9; {Devanagari} smGurmukhi = 10; {Gurmukhi} smGujarati = 11; {Gujarati} smOriya = 12; {Oriya} smBengali = 13; {Bengali} smTamil = 14; {Tamil} smTelugu = 15; {Telugu} smKannada = 16; {Kannada/Kanarese} smMalayalam = 17; {Malayalam} smSinhalese = 18; {Sinhalese} smBurmese = 19; {Burmese} smKhmer = 20; {Khmer/Cambodian} smThai = 21; {Thai} smLaotian = 22; {Laotian} smGeorgian = 23; {Georgian} smArmenian = 24; {Armenian} smSimpChinese = 25; {Simplified Chinese} smTibetan = 26; {Tibetan} smMongolian = 27; {Mongolian} smGeez = 28; {Geez/Ethiopic} smEthiopic = 28; {Synonym for smGeez} smEastEurRoman = 29; {Synonym for smSlavic} smVietnamese = 30; {Vietnamese} smExtArabic = 31; {extended Arabic} smUninterp = 32; {uninterpreted symbols, e.g. palette symbols} {Obsolete names for script systems (kept for backward compatibility)} smChinese = 2; {(use smTradChinese or smSimpChinese)} smRussian = 7; {(old name for smCyrillic)} { smMaldivian = 25; (no more smMaldivian!)} smAmharic = 28; {(old name for smGeez)} smSlavic = 29; {(old name for smEastEurRoman)} smSindhi = 31; {(old name for smExtArabic)} { Calendar Codes } calGregorian = 0; calArabicCivil = 1; calArabicLunar = 2; calJapanese = 3; calJewish = 4; calCoptic = 5; calPersian = 6; { Integer Format Codes } intWestern = 0; intArabic = 1; intRoman = 2; intJapanese = 3; intEuropean = 4; intOutputMask = $8000; { CharByte byte types } smSingleByte = 0; smFirstByte = -1; smLastByte = 1; smMiddleByte = 2; { CharType field masks } smcTypeMask = $000F; smcReserved = $00F0; smcClassMask = $0F00; smcOrientationMask = $1000; {two-byte script glyph orientation} smcRightMask = $2000; smcUpperMask = $4000; smcDoubleMask = $8000; { Basic CharType character types } smCharPunct = $0000; smCharAscii = $0001; smCharEuro = $0007; smCharExtAscii = $0007; { More correct synonym for smCharEuro } { Additional CharType character types for script systems } smCharKatakana = $0002; {Japanese Katakana} smCharHiragana = $0003; {Japanese Hiragana} smCharIdeographic = $0004; {Hanzi, Kanji, Hanja} smCharTwoByteGreek = $0005; {2-byte Greek in Far East systems} smCharTwoByteRussian = $0006; {2-byte Cyrillic in Far East systems} smCharBidirect = $0008; {Arabic/Hebrew} smCharHangul = $000C; {Korean Hangul} smCharJamo = $000D; {Korean Jamo} { old names for some of above, for backward compatibility } smCharFISKana = $0002; {Katakana} smCharFISGana = $0003; {Hiragana} smCharFISIdeo = $0004; {Hanzi, Kanji, Hanja} smCharFISGreek = $0005; {2-byte Greek in Far East systems} smCharFISRussian = $0006; {2-byte Cyrillic in Far East systems} { CharType classes for punctuation (smCharPunct) } smPunctNormal = $0000; smPunctNumber = $0100; smPunctSymbol = $0200; smPunctBlank = $0300; { Additional CharType classes for punctuation in two-byte systems } smPunctRepeat = $0400; { repeat marker } smPunctGraphic = $0500; { line graphics } { CharType Katakana and Hiragana classes for two-byte systems } smKanaSmall = $0100; {small kana character} smKanaHardOK = $0200; {can have dakuten} smKanaSoftOK = $0300; {can have dakuten or han-dakuten} { CharType Ideographic classes for two-byte systems } smIdeographicLevel1 = $0000; {level 1 char} smIdeographicLevel2 = $0100; {level 2 char} smIdeographicUser = $0200; {user char} { old names for above, for backward compatibility } smFISClassLvl1 = $0000; {level 1 char} smFISClassLvl2 = $0100; {level 2 char} smFISClassUser = $0200; {user char} { CharType Jamo classes for Korean systems } smJamoJaeum = $0000; {simple consonant char} smJamoBogJaeum = $0100; {complex consonant char} smJamoMoeum = $0200; {simple vowel char} smJamoBogMoeum = $0300; {complex vowel char} { CharType glyph orientation for two-byte systems } smCharHorizontal = $0000; { horizontal character form, or for both } smCharVertical = $1000; { vertical character form } { CharType directions } smCharLeft = $0000; smCharRight = $2000; { CharType case modifers } smCharLower = $0000; smCharUpper = $4000; { CharType character size modifiers (1 or multiple bytes). } smChar1byte = $0000; smChar2byte = $8000; { Char2Pixel directions } smLeftCaret = 0; {Place caret for left block} smRightCaret = -1; {Place caret for right block} smHilite = 1; {Direction is TESysJust} { Transliterate target types for Roman } smTransAscii = 0; {convert to ASCII} smTransNative = 1; {convert to font script} smTransCase = $FE; {convert case for all text} smTransSystem = $FF; {convert to system script} { Transliterate target types for two-byte scripts } smTransAscii1 = 2; {1-byte Roman} smTransAscii2 = 3; {2-byte Roman} smTransKana1 = 4; {1-byte Japanese Katakana} smTransKana2 = 5; {2-byte Japanese Katakana} smTransGana2 = 7; {2-byte Japanese Hiragana (no 1-byte Hiragana)} smTransHangul2 = 8; {2-byte Korean Hangul} smTransJamo2 = 9; {2-byte Korean Jamo} smTransBopomofo2 = 10; {2-byte Chinese Bopomofo} { Transliterate target modifiers } smTransLower = $4000; {target becomes lowercase} smTransUpper = $8000; {target becomes uppercase} { Transliterate source mask - general } smMaskAll = $FFFFFFFF; {Convert all text} { Transliterate source masks } smMaskAscii = $00000001; {2^smTransAscii} smMaskNative = $00000002; {2^smTransNative} { Transliterate source masks for two-byte scripts } smMaskAscii1 = $00000004; {2^smTransAscii1} smMaskAscii2 = $00000008; {2^smTransAscii2} smMaskKana1 = $00000010; {2^smTransKana1} smMaskKana2 = $00000020; {2^smTransKana2} smMaskGana2 = $00000080; {2^smTransGana2} smMaskHangul2 = $00000100; {2^smTransHangul2} smMaskJamo2 = $00000200; {2^smTransJamo2} smMaskBopomofo2 = $00000400; {2^smTransBopomofo2} { Result values from GetEnvirons, SetEnvirons, GetScript and SetScript calls. } smNotInstalled = 0; {routine not available in script} smBadVerb = -1; {Bad verb passed to a routine} smBadScript = -2; {Bad script code passed to a routine} { Values for script redraw flag. } smRedrawChar = 0; {Redraw character only} smRedrawWord = 1; {Redraw entire word (2-byte systems)} smRedrawLine = -1; {Redraw entire line (bidirectional systems)} { GetEnvirons and SetEnvirons verbs } smVersion = 0; {Script Manager version number} smMunged = 2; {Globals change count} smEnabled = 4; {Count of enabled scripts, incl Roman} smBidirect = 6; {At least one bidirectional script} smFontForce = 8; {Force font flag} smIntlForce = 10; {Force intl flag} smForced = 12; {Script was forced to system script} smDefault = 14; {Script was defaulted to Roman script} smPrint = 16; {Printer action routine} smSysScript = 18; {System script} smLastScript = 20; {Last keyboard script} smKeyScript = 22; {Keyboard script} smSysRef = 24; {System folder refNum} smKeyCache = 26; {obsolete} smKeySwap = 28; {Swapping table handle} smGenFlags = 30; {General flags long} smOverride = 32; {Script override flags} smCharPortion = 34; {Ch vs SpExtra proportion} { New for System 7.0: } smDoubleByte = 36; {Flag for double-byte script installed} smKCHRCache = 38; {Returns pointer to KCHR cache} smRegionCode = 40; {Returns current region code (verXxx)} { GetScript and SetScript verbs. Note: Verbs private to script systems are negative, while those general across script systems are non-negative. } smScriptVersion = 0; {Script software version} smScriptMunged = 2; {Script entry changed count} smScriptEnabled = 4; {Script enabled flag} smScriptRight = 6; {Right to left flag} smScriptJust = 8; {Justification flag} smScriptRedraw = 10; {Word redraw flag} smScriptSysFond = 12; {Preferred system font} smScriptAppFond = 14; {Preferred Application font} smScriptBundle = 16; {Beginning of itlb verbs} smScriptNumber = 16; {Script itl0 id} smScriptDate = 18; {Script itl1 id} smScriptSort = 20; {Script itl2 id} smScriptFlags = 22; {flags word} smScriptToken = 24; {Script itl4 id} smScriptEncoding = 26; {id of optional itl5, if present} smScriptLang = 28; {Current language for script} smScriptNumDate = 30; {Script Number/Date formats.} smScriptKeys = 32; {Script KCHR id} smScriptIcon = 34; {ID # of SICN or kcs#/kcs4/kcs8 suite} smScriptPrint = 36; {Script printer action routine} smScriptTrap = 38; {Trap entry pointer} smScriptCreator = 40; {Script file creator} smScriptFile = 42; {Script file name} smScriptName = 44; {Script name} { There is a hole here for old Kanji private verbs 46-76 New for System 7.0: } smScriptMonoFondSize = 78; {default monospace FOND (hi) & size (lo)} smScriptPrefFondSize = 80; {preferred FOND (hi) & size (lo)} smScriptSmallFondSize = 82; {default small FOND (hi) & size (lo)} smScriptSysFondSize = 84; {default system FOND (hi) & size (lo)} smScriptAppFondSize = 86; {default app FOND (hi) & size (lo)} smScriptHelpFondSize = 88; {default Help Mgr FOND (hi) & size (lo)} smScriptValidStyles = 90; {mask of valid styles for script} smScriptAliasStyle = 92; {style (set) to use for aliases} { Negative verbs for KeyScript } smKeyNextScript = -1; { Switch to next available script } smKeySysScript = -2; { Switch to the system script } smKeySwapScript = -3; { Switch to previously-used script } { New for System 7.0: } smKeyNextKybd = -4; { Switch to next keyboard in current keyscript } smKeySwapKybd = -5; { Switch to previously-used keyboard in current keyscript } smKeyDisableKybds = -6; { Disable keyboards not in system or Roman script } smKeyEnableKybds = -7; { Re-enable keyboards for all enabled scripts } smKeyToggleInline = -8; { Toggle inline input for current keyscript } smKeyToggleDirection = -9; { Toggle default line direction (TESysJust) } smKeyNextInputMethod = -10; { Switch to next input method in current keyscript } smKeySwapInputMethod = -11; { Switch to last-used input method in current keyscript } smKeyDisableKybdSwitch = -12; { Disable switching from the current keyboard } { Bits in the smScriptFlags word (bits above 7 are non-static) } smsfIntellCP = 0; {Script has intelligent cut & paste} smsfSingByte = 1; {Script has only single bytes} smsfNatCase = 2; {Native chars have upper & lower case} smsfContext = 3; {Script is contextual} smsfNoForceFont = 4; {Script will not force characters} smsfB0Digits = 5; {Script has alternate digits at B0-B9} smsfAutoInit = 6; {Auto initialize the script} smsfForms = 13; {Uses contextual forms for letters} smsfLigatures = 14; {Uses contextual ligatures} smsfReverse = 15; {Reverses native text, right-left} { Bits in the smGenFlags long. First (high-order) byte is set from itlc flags byte. } smfShowIcon = 31; {Show icon even if only one script} smfDualCaret = 30; {Use dual caret for mixed direction text} smfNameTagEnab = 29; {Reserved for internal use} { Roman script constants The following are here for backward compatibility, but should not be used. This information should be obtained using GetScript. } romanSysFond = $3FFF; {system font id number} romanAppFond = 3; {application font id number} romanFlags = $0007; {roman settings} { Script Manager font equates. } smFondStart = $4000; {start from 16K} smFondEnd = $C000; {past end of range at 48K} { Miscellaneous font equates. } smUprHalfCharSet = $80; {first char code in top half of std char set} { Character Set Extensions } diaeresisUprY = $D9; fraction = $DA; intlCurrency = $DB; leftSingGuillemet = $DC; rightSingGuillemet = $DD; fiLigature = $DE; flLigature = $DF; dblDagger = $E0; centeredDot = $E1; baseSingQuote = $E2; baseDblQuote = $E3; perThousand = $E4; circumflexUprA = $E5; circumflexUprE = $E6; acuteUprA = $E7; diaeresisUprE = $E8; graveUprE = $E9; acuteUprI = $EA; circumflexUprI = $EB; diaeresisUprI = $EC; graveUprI = $ED; acuteUprO = $EE; circumflexUprO = $EF; appleLogo = $F0; graveUprO = $F1; acuteUprU = $F2; circumflexUprU = $F3; graveUprU = $F4; dotlessLwrI = $F5; circumflex = $F6; tilde = $F7; macron = $F8; breveMark = $F9; overDot = $FA; ringMark = $FB; cedilla = $FC; doubleAcute = $FD; ogonek = $FE; hachek = $FF; { String2Date status values } fatalDateTime = $8000; {String2Date and String2Time mask to a fatal error} longDateFound = 1; {String2Date mask to long date found} leftOverChars = 2; {String2Date & Time mask to warn of left over characters} sepNotIntlSep = 4; {String2Date & Time mask to warn of non-standard separators} fieldOrderNotIntl = 8; {String2Date & Time mask to warn of non-standard field order} extraneousStrings = 16; {String2Date & Time mask to warn of unparsable strings in text} tooManySeps = 32; {String2Date & Time mask to warn of too many separators} sepNotConsistent = 64; {String2Date & Time mask to warn of inconsistent separators} tokenErr = $8100; {String2Date & Time mask for 'tokenizer err encountered'} cantReadUtilities = $8200; dateTimeNotFound = $8400; dateTimeInvalid = $8800; { TokenType values } tokenIntl = 4; {the itl resource number of the tokenizer} tokenEmpty = -1; {used internally as an empty flag} tokenUnknown = 0; {chars that do not match a defined token type} tokenWhite = 1; {white space} tokenLeftLit = 2; {literal begin} tokenRightLit = 3; {literal end} tokenAlpha = 4; {alphabetic} tokenNumeric = 5; {numeric} tokenNewLine = 6; {new line} tokenLeftComment = 7; {open comment} tokenRightComment = 8; {close comment} tokenLiteral = 9; {literal} tokenEscape = 10; {character escape (e.g. '\' in "\n", "\t")} tokenAltNum = 11; {alternate number (e.g. $B0-B9 in Arabic,Hebrew)} tokenRealNum = 12; {real number} tokenAltReal = 13; {alternate real number} tokenReserve1 = 14; {reserved} tokenReserve2 = 15; {reserved} tokenLeftParen = 16; {open parenthesis} tokenRightParen = 17; {close parenthesis} tokenLeftBracket = 18; {open square bracket} tokenRightBracket = 19; {close square bracket} tokenLeftCurly = 20; {open curly bracket} tokenRightCurly = 21; {close curly bracket} tokenLeftEnclose = 22; {open guillemet} tokenRightEnclose = 23; {close guillemet} tokenPlus = 24; tokenMinus = 25; tokenAsterisk = 26; {times/multiply} tokenDivide = 27; tokenPlusMinus = 28; {plus or minus symbol} tokenSlash = 29; tokenBackSlash = 30; tokenLess = 31; {less than symbol} tokenGreat = 32; {greater than symbol} tokenEqual = 33; tokenLessEqual2 = 34; {less than or equal, 2 characters (e.g. <=)} tokenLessEqual1 = 35; {less than or equal, 1 character} tokenGreatEqual2 = 36; {greater than or equal, 2 characters (e.g. >=)} tokenGreatEqual1 = 37; {greater than or equal, 1 character} token2Equal = 38; {double equal (e.g. ==)} tokenColonEqual = 39; {colon equal} tokenNotEqual = 40; {not equal, 1 character} tokenLessGreat = 41; {less/greater, Pascal not equal (e.g. <>)} tokenExclamEqual = 42; {exclamation equal, C not equal (e.g. !=)} tokenExclam = 43; {exclamation point} tokenTilde = 44; {centered tilde} tokenComma = 45; tokenPeriod = 46; tokenLeft2Quote = 47; {open double quote} tokenRight2Quote = 48; {close double quote} tokenLeft1Quote = 49; {open single quote} tokenRight1Quote = 50; {close single quote} token2Quote = 51; {double quote} token1Quote = 52; {single quote} tokenSemicolon = 53; tokenPercent = 54; tokenCaret = 55; tokenUnderline = 56; tokenAmpersand = 57; tokenAtSign = 58; tokenBar = 59; {vertical bar} tokenQuestion = 60; tokenPi = 61; {lower-case pi} tokenRoot = 62; {square root symbol} tokenSigma = 63; {capital sigma} tokenIntegral = 64; {integral sign} tokenMicro = 65; tokenCapPi = 66; {capital pi} tokenInfinity = 67; tokenColon = 68; tokenHash = 69; {e.g. #} tokenDollar = 70; tokenNoBreakSpace = 71; {non-breaking space} tokenFraction = 72; tokenIntlCurrency = 73; tokenLeftSingGuillemet = 74; tokenRightSingGuillemet = 75; tokenPerThousand = 76; tokenEllipsis = 77; tokenCenterDot = 78; tokenNil = 127; delimPad = -2; { obsolete, misspelled token names kept for backward compatibility } tokenTilda = 44; tokenCarat = 55; { the NumberParts indices } tokLeftQuote = 1; tokRightQuote = 2; tokLeadPlacer = 3; tokLeader = 4; tokNonLeader = 5; tokZeroLead = 6; tokPercent = 7; tokPlusSign = 8; tokMinusSign = 9; tokThousands = 10; tokSeparator = 12; {11 is a reserved field} tokEscape = 13; tokDecPoint = 14; tokEPlus = 15; tokEMinus = 16; tokMaxSymbols = 31; curNumberPartsVersion = 1; {current version of NumberParts record} fVNumber = 0; {first version of NumFormatString} { Date equates } smallDateBit = 31; {Restrict valid date/time to range of Time global} togChar12HourBit = 30; {If toggling hour by char, accept hours 1..12 only} togCharZCycleBit = 29; {Modifier for togChar12HourBit: accept hours 0..11 only} togDelta12HourBit = 28; {If toggling hour up/down, restrict to 12-hour range (am/pm)} genCdevRangeBit = 27; {Restrict date/time to range used by genl CDEV} validDateFields = -1; maxDateField = 10; eraMask = $0001; yearMask = $0002; monthMask = $0004; dayMask = $0008; hourMask = $0010; minuteMask = $0020; secondMask = $0040; dayOfWeekMask = $0080; dayOfYearMask = $0100; weekOfYearMask = $0200; pmMask = $0400; dateStdMask = $007F; {default for ValidDate flags and ToggleDate TogglePB.togFlags} { Toggle results } toggleUndefined = 0; toggleOK = 1; toggleBadField = 2; toggleBadDelta = 3; toggleBadChar = 4; toggleUnknown = 5; toggleBadNum = 6; toggleOutOfRange = 7; {synonym for toggleErr3} toggleErr3 = 7; toggleErr4 = 8; toggleErr5 = 9; { New constants for System 7.0: Constants for truncWhere argument in TruncString and TruncText } smTruncEnd = 0; { Truncate at end } smTruncMiddle = $4000; { Truncate in middle } { Constants for TruncString and TruncText results } smNotTruncated = 0; { No truncation was necessary } smTruncated = 1; { Truncation performed } smTruncErr = -1; { General error } {Constants for styleRunPosition argument in NPortionText, NDrawJust, NMeasureJust, NChar2Pixel, and NPixel2Char.} smOnlyStyleRun = 0; { This is the only style run on the line } smLeftStyleRun = 1; { This is leftmost of multiple style runs on the line } smRightStyleRun = 2; { This is rightmost of multiple style runs on the line } smMiddleStyleRun = 3; { There are multiple style runs on the line and this is neither the leftmost nor the rightmost. } TYPE TokenResults = (tokenOK,tokenOverflow,stringOverflow,badDelim,badEnding, crash); LongDateField = (eraField,yearField,monthField,dayField,hourField,minuteField, secondField,dayOfWeekField,dayOfYearField,weekOfYearField,pmField,res1Field, res2Field,res3Field); StyledLineBreakCode = (smBreakWord,smBreakChar,smBreakOverflow); FormatClass = (fPositive,fNegative,fZero); FormatResultType = (fFormatOK,fBestGuess,fOutOfSynch,fSpuriousChars,fMissingDelimiter, fExtraDecimal,fMissingLiteral,fExtraExp,fFormatOverflow,fFormStrIsNAN, fBadPartsTable,fExtraPercent,fExtraSeparator,fEmptyFormatString); CharByteTable = PACKED ARRAY [0..255] OF SignedByte; ToggleResults = INTEGER; BreakTablePtr = ^BreakTable; BreakTable = RECORD charTypes: ARRAY [0..255] OF SignedByte; tripleLength: INTEGER; triples: ARRAY [0..0] OF INTEGER; END; { New NBreakTable for System 7.0: } NBreakTablePtr = ^NBreakTable; NBreakTable = RECORD flags1: SignedByte; flags2: SignedByte; version: INTEGER; classTableOff: INTEGER; auxCTableOff: INTEGER; backwdTableOff: INTEGER; forwdTableOff: INTEGER; doBackup: INTEGER; reserved: INTEGER; charTypes: ARRAY [0..255] OF SignedByte; tables: ARRAY [0..0] OF INTEGER; END; OffPair = RECORD offFirst: INTEGER; offSecond: INTEGER; END; OffsetTable = ARRAY [0..2] OF OffPair; ItlcRecord = RECORD itlcSystem: INTEGER; {default system script} itlcReserved: INTEGER; {reserved} itlcFontForce: SignedByte; {default font force flag} itlcIntlForce: SignedByte; {default intl force flag} itlcOldKybd: SignedByte; {MacPlus intl keybd flag} itlcFlags: SignedByte; {general flags} itlcIconOffset: INTEGER; {keyboard icon offset; not used in 7.0} itlcIconSide: SignedByte; {keyboard icon side; not used in 7.0} itlcIconRsvd: SignedByte; {rsvd for other icon info} itlcRegionCode: INTEGER; {preferred verXxx code} itlcReserved3: ARRAY [0..33] OF SignedByte; {for future use} END; ItlbRecord = RECORD itlbNumber: INTEGER; {itl0 id number} itlbDate: INTEGER; {itl1 id number} itlbSort: INTEGER; {itl2 id number} itlbFlags: INTEGER; {Script flags} itlbToken: INTEGER; {itl4 id number} itlbEncoding: INTEGER; {itl5 ID # (optional; char encoding)} itlbLang: INTEGER; {current language for script } itlbNumRep: SignedByte; {number representation code} itlbDateRep: SignedByte; {date representation code } itlbKeys: INTEGER; {KCHR id number} itlbIcon: INTEGER; {ID # of SICN or kcs#/kcs4/kcs8 suite.} END; { New ItlbExtRecord structure for System 7.0 } ItlbExtRecord = RECORD base: ItlbRecord; {un-extended ItlbRecord} itlbLocalSize: LONGINT; {size of script's local record} itlbMonoFond: INTEGER; {default monospace FOND ID} itlbMonoSize: INTEGER; {default monospace font size} itlbPrefFond: INTEGER; {preferred FOND ID} itlbPrefSize: INTEGER; {preferred font size} itlbSmallFond: INTEGER; {default small FOND ID} itlbSmallSize: INTEGER; {default small font size} itlbSysFond: INTEGER; {default system FOND ID} itlbSysSize: INTEGER; {default system font size} itlbAppFond: INTEGER; {default application FOND ID} itlbAppSize: INTEGER; {default application font size} itlbHelpFond: INTEGER; {default Help Mgr FOND ID} itlbHelpSize: INTEGER; {default Help Mgr font size} itlbValidStyles: Style; {set of valid styles for script} itlbAliasStyle: Style; {style (set) to mark aliases} END; MachineLocation = RECORD latitude: Fract; longitude: Fract; CASE INTEGER OF 0: (dlsDelta: SignedByte); {signed byte; daylight savings delta} 1: (gmtDelta: LONGINT); {must mask - see documentation} END; String2DateStatus = INTEGER; TokenType = INTEGER; DelimType = ARRAY [0..1] OF TokenType; CommentType = ARRAY [0..3] OF TokenType; TokenRecPtr = ^TokenRec; TokenRec = RECORD theToken: TokenType; position: Ptr; {pointer into original source} length: LONGINT; {length of text in original source} stringPosition: StringPtr; {Pascal/C string copy of identifier} END; TokenBlockPtr = ^TokenBlock; TokenBlock = RECORD source: Ptr; {pointer to stream of characters} sourceLength: LONGINT; {length of source stream} tokenList: Ptr; {pointer to array of tokens} tokenLength: LONGINT; {maximum length of TokenList} tokenCount: LONGINT; {number tokens generated by tokenizer} stringList: Ptr; {pointer to stream of identifiers} stringLength: LONGINT; {length of string list} stringCount: LONGINT; {number of bytes currently used} doString: BOOLEAN; {make strings & put into StringList} doAppend: BOOLEAN; {append to TokenList rather than replace} doAlphanumeric: BOOLEAN; {identifiers may include numeric} doNest: BOOLEAN; {do comments nest?} leftDelims: ARRAY [0..1] OF TokenType; rightDelims: ARRAY [0..1] OF TokenType; leftComment: ARRAY [0..3] OF TokenType; rightComment: ARRAY [0..3] OF TokenType; escapeCode: TokenType; {escape symbol code} decimalCode: TokenType; itlResource: Handle; {handle to itl4 resource of current script} reserved: ARRAY [0..7] OF LONGINT; {must be zero!} END; UntokenTablePtr = ^UntokenTable; UntokenTableHandle = ^UntokenTablePtr; UntokenTable = RECORD len: INTEGER; lastToken: INTEGER; index: ARRAY [0..255] OF INTEGER; {index table; last = lastToken} END; DateCachePtr = ^DateCacheRecord; DateCacheRecord = PACKED RECORD hidden: ARRAY [0..255] OF INTEGER; {only for temporary use} END; LongDateTime = comp; LongDateCvt = RECORD CASE INTEGER OF 0: (c: Comp); 1: (lHigh: LONGINT; lLow: LONGINT); END; LongDateRec = RECORD CASE INTEGER OF 0: (era: INTEGER; year: INTEGER; month: INTEGER; day: INTEGER; hour: INTEGER; minute: INTEGER; second: INTEGER; dayOfWeek: INTEGER; dayOfYear: INTEGER; weekOfYear: INTEGER; pm: INTEGER; res1: INTEGER; res2: INTEGER; res3: INTEGER); 1: (list: ARRAY [0..13] OF INTEGER); {Index by LongDateField!} 2: (eraAlt: INTEGER; oldDate: DateTimeRec); END; DateDelta = SignedByte; TogglePB = RECORD togFlags: LONGINT; {caller normally sets low word to dateStdMask=$7F} amChars: ResType; {from 'itl0', but uppercased} pmChars: ResType; {from 'itl0', but uppercased} reserved: ARRAY [0..3] OF LONGINT; END; FormatOrder = ARRAY [0..0] OF INTEGER; FormatOrderPtr = ^FormatOrder; FormatStatus = INTEGER; WideChar = RECORD CASE BOOLEAN OF TRUE: (a: PACKED ARRAY [0..1] OF CHAR); {0 is the high order character} FALSE: (b: INTEGER); END; WideCharArr = RECORD size: INTEGER; data: PACKED ARRAY [0..9] OF WideChar; END; NumFormatString = PACKED RECORD fLength: Byte; fVersion: Byte; data: PACKED ARRAY [0..253] OF SignedByte; {private data} END; Itl4Ptr = ^Itl4Rec; Itl4Handle = ^Itl4Ptr; Itl4Rec = RECORD flags: INTEGER; {reserved} resourceType: LONGINT; {contains 'itl4'} resourceNum: INTEGER; {resource ID} version: INTEGER; {version number} resHeader1: LONGINT; {reserved} resHeader2: LONGINT; {reserved} numTables: INTEGER; {number of tables, one-based} mapOffset: LONGINT; {offset to table that maps byte to token} strOffset: LONGINT; {offset to routine that copies canonical string} fetchOffset: LONGINT; {offset to routine that gets next byte of character} unTokenOffset: LONGINT; {offset to table that maps token to canonical string} defPartsOffset: LONGINT; {offset to default number parts table} resOffset6: LONGINT; {reserved} resOffset7: LONGINT; {reserved} resOffset8: LONGINT; {reserved} END; { New NItl4Rec for System 7.0: } NItl4Ptr = ^NItl4Rec; NItl4Handle = ^NItl4Ptr; NItl4Rec = RECORD flags: INTEGER; {reserved} resourceType: LONGINT; {contains 'itl4'} resourceNum: INTEGER; {resource ID} version: INTEGER; {version number} format: INTEGER; {format code} resHeader: INTEGER; {reserved} resHeader2: LONGINT; {reserved} numTables: INTEGER; {number of tables, one-based} mapOffset: LONGINT; {offset to table that maps byte to token} strOffset: LONGINT; {offset to routine that copies canonical string} fetchOffset: LONGINT; {offset to routine that gets next byte of character} unTokenOffset: LONGINT; {offset to table that maps token to canonical string} defPartsOffset: LONGINT; {offset to default number parts table} whtSpListOffset: LONGINT; {offset to white space code list} resOffset7: LONGINT; {reserved} resOffset8: LONGINT; {reserved} resLength1: INTEGER; {reserved} resLength2: INTEGER; {reserved} resLength3: INTEGER; {reserved} unTokenLength: INTEGER; {length of untoken table} defPartsLength: INTEGER; {length of default number parts table} whtSpListLength: INTEGER; {length of white space code list} resLength7: INTEGER; {reserved} resLength8: INTEGER; {reserved} END; NumberPartsPtr = ^NumberParts; NumberParts = RECORD version: INTEGER; data: ARRAY [1..31] OF WideChar; {index by [tokLeftQuote..tokMaxSymbols]} pePlus: WideCharArr; peMinus: WideCharArr; peMinusPlus: WideCharArr; altNumTable: WideCharArr; reserved: PACKED ARRAY [0..19] OF CHAR; END; FVector = RECORD start: INTEGER; length: INTEGER; END; TripleInt = ARRAY [0..2] OF FVector; { index by [fPositive..fZero] } ScriptRunStatus = RECORD script: SignedByte; variant: SignedByte; END; { New types for System 7.0: type for truncWhere parameter in new TruncString, TruncText } TruncCode = INTEGER; { type for styleRunPosition parameter in NPixel2Char etc. } JustStyleCode = INTEGER; FUNCTION FontScript: INTEGER; INLINE $2F3C,$8200,$0000,$A8B5; FUNCTION IntlScript: INTEGER; INLINE $2F3C,$8200,$0002,$A8B5; PROCEDURE KeyScript(code: INTEGER); INLINE $2F3C,$8002,$0004,$A8B5; FUNCTION Font2Script(fontNumber: INTEGER): INTEGER; INLINE $2F3C,$8202,$0006,$A8B5; FUNCTION GetEnvirons(verb: INTEGER): LONGINT; INLINE $2F3C,$8402,$0008,$A8B5; FUNCTION SetEnvirons(verb: INTEGER;param: LONGINT): OSErr; INLINE $2F3C,$8206,$000A,$A8B5; FUNCTION GetScript(script: INTEGER;verb: INTEGER): LONGINT; INLINE $2F3C,$8404,$000C,$A8B5; FUNCTION SetScript(script: INTEGER;verb: INTEGER;param: LONGINT): OSErr; INLINE $2F3C,$8208,$000E,$A8B5; FUNCTION CharByte(textBuf: Ptr;textOffset: INTEGER): INTEGER; INLINE $2F3C,$8206,$0010,$A8B5; FUNCTION CharType(textBuf: Ptr;textOffset: INTEGER): INTEGER; INLINE $2F3C,$8206,$0012,$A8B5; FUNCTION Pixel2Char(textBuf: Ptr;textLen: INTEGER;slop: INTEGER;pixelWidth: INTEGER; VAR leadingEdge: BOOLEAN): INTEGER; INLINE $2F3C,$820E,$0014,$A8B5; FUNCTION Char2Pixel(textBuf: Ptr;textLen: INTEGER;slop: INTEGER;offset: INTEGER; direction: INTEGER): INTEGER; INLINE $2F3C,$820C,$0016,$A8B5; FUNCTION Transliterate(srcHandle: Handle;dstHandle: Handle;target: INTEGER; srcMask: LONGINT): OSErr; INLINE $2F3C,$820E,$0018,$A8B5; PROCEDURE FindWord(textPtr: Ptr;textLength: INTEGER;offset: INTEGER;leadingEdge: BOOLEAN; breaks: BreakTablePtr;VAR offsets: OffsetTable); INLINE $2F3C,$8012,$001A,$A8B5; PROCEDURE HiliteText(textPtr: Ptr;textLength: INTEGER;firstOffset: INTEGER; secondOffset: INTEGER;VAR offsets: OffsetTable); INLINE $2F3C,$800E,$001C,$A8B5; PROCEDURE DrawJust(textPtr: Ptr;textLength: INTEGER;slop: INTEGER); INLINE $2F3C,$8008,$001E,$A8B5; PROCEDURE MeasureJust(textPtr: Ptr;textLength: INTEGER;slop: INTEGER;charLocs: Ptr); INLINE $2F3C,$800C,$0020,$A8B5; FUNCTION ParseTable(VAR table: CharByteTable): BOOLEAN; INLINE $2F3C,$8204,$0022,$A8B5; FUNCTION GetDefFontSize: INTEGER; INLINE $3EB8,$0BA8,$6604,$3EBC,$000C; FUNCTION GetSysFont: INTEGER; INLINE $3EB8,$0BA6; FUNCTION GetAppFont: INTEGER; INLINE $3EB8,$0984; FUNCTION GetMBarHeight: INTEGER; INLINE $3EB8,$0BAA; FUNCTION GetSysJust: INTEGER; INLINE $3EB8,$0BAC; PROCEDURE SetSysJust(newJust: INTEGER); INLINE $31DF,$0BAC; PROCEDURE ReadLocation(VAR loc: MachineLocation); INLINE $205F,$203C,$000C,$00E4,$A051; PROCEDURE WriteLocation(loc: MachineLocation); INLINE $205F,$203C,$000C,$00E4,$A052; PROCEDURE UprText(textPtr: Ptr;len: INTEGER); INLINE $301F,$205F,$A054; PROCEDURE LwrText(textPtr: Ptr;len: INTEGER); INLINE $301F,$205F,$A056; { New for 7.0 } PROCEDURE LowerText(textPtr: Ptr;len: INTEGER); INLINE $301F,$205F,$A056; PROCEDURE StripText(textPtr: Ptr;len: INTEGER); INLINE $301F,$205F,$A256; PROCEDURE UpperText(textPtr: Ptr;len: INTEGER); INLINE $301F,$205F,$A456; PROCEDURE StripUpperText(textPtr: Ptr;len: INTEGER); INLINE $301F,$205F,$A656; FUNCTION StyledLineBreak(textPtr: Ptr;textLen: LONGINT;textStart: LONGINT; textEnd: LONGINT;flags: LONGINT;VAR textWidth: Fixed;VAR textOffset: LONGINT): StyledLineBreakCode; INLINE $2F3C,$821C,$FFFE,$A8B5; PROCEDURE GetFormatOrder(ordering: FormatOrderPtr;firstFormat: INTEGER; lastFormat: INTEGER;lineRight: BOOLEAN;rlDirProc: Ptr;dirParam: Ptr); INLINE $2F3C,$8012,$FFFC,$A8B5; FUNCTION IntlTokenize(tokenParam: TokenBlockPtr): TokenResults; INLINE $2F3C,$8204,$FFFA,$A8B5; FUNCTION InitDateCache(theCache: DateCachePtr): OSErr; INLINE $2F3C,$8204,$FFF8,$A8B5; FUNCTION String2Date(textPtr: Ptr;textLen: LONGINT;theCache: DateCachePtr; VAR lengthUsed: LONGINT;VAR dateTime: LongDateRec): String2DateStatus; INLINE $2F3C,$8214,$FFF6,$A8B5; FUNCTION String2Time(textPtr: Ptr;textLen: LONGINT;theCache: DateCachePtr; VAR lengthUsed: LONGINT;VAR dateTime: LongDateRec): String2DateStatus; INLINE $2F3C,$8214,$FFF4,$A8B5; PROCEDURE LongDate2Secs(lDate: LongDateRec;VAR lSecs: LongDateTime); INLINE $2F3C,$8008,$FFF2,$A8B5; PROCEDURE LongSecs2Date(VAR lSecs: LongDateTime;VAR lDate: LongDateRec); INLINE $2F3C,$8008,$FFF0,$A8B5; FUNCTION ToggleDate(VAR lSecs: LongDateTime;field: LongDateField;delta: DateDelta; ch: INTEGER;params: TogglePB): ToggleResults; INLINE $2F3C,$820E,$FFEE,$A8B5; FUNCTION Str2Format(inString: Str255;partsTable: NumberParts;VAR outString: NumFormatString): FormatStatus; INLINE $2F3C,$820C,$FFEC,$A8B5; FUNCTION Format2Str(myCanonical: NumFormatString;partsTable: NumberParts; VAR outString: Str255;VAR positions: TripleInt): FormatStatus; INLINE $2F3C,$8210,$FFEA,$A8B5; FUNCTION FormatX2Str(x: Extended80;myCanonical: NumFormatString;partsTable: NumberParts; VAR outString: Str255): FormatStatus; INLINE $2F3C,$8210,$FFE8,$A8B5; FUNCTION FormatStr2X(source: Str255;myCanonical: NumFormatString;partsTable: NumberParts; VAR x: Extended80): FormatStatus; INLINE $2F3C,$8210,$FFE6,$A8B5; FUNCTION PortionText(textPtr: Ptr;textLen: LONGINT): Fixed; INLINE $2F3C,$8408,$0024,$A8B5; FUNCTION FindScriptRun(textPtr: Ptr;textLen: LONGINT;VAR lenUsed: LONGINT): ScriptRunStatus; INLINE $2F3C,$820C,$0026,$A8B5; FUNCTION VisibleLength(textPtr: Ptr;textLen: LONGINT): LONGINT; INLINE $2F3C,$8408,$0028,$A8B5; FUNCTION ValidDate(vDate: LongDateRec;flags: LONGINT;VAR newSecs: LongDateTime): INTEGER; INLINE $2F3C,$820C,$FFE4,$A8B5; { New for 7.0 } PROCEDURE NFindWord(textPtr: Ptr;textLength: INTEGER;offset: INTEGER;leadingEdge: BOOLEAN; nbreaks: NBreakTablePtr;VAR offsets: OffsetTable); INLINE $2F3C,$8012,$FFE2,$A8B5; FUNCTION TruncString(width: INTEGER;VAR theString: Str255;truncWhere: TruncCode): INTEGER; INLINE $2F3C,$8208,$FFE0,$A8B5; FUNCTION TruncText(width: INTEGER;textPtr: Ptr;VAR length: INTEGER;truncWhere: TruncCode): INTEGER; INLINE $2F3C,$820C,$FFDE,$A8B5; FUNCTION ReplaceText(baseText: Handle;substitutionText: Handle;key: Str15): INTEGER; INLINE $2F3C,$820C,$FFDC,$A8B5; FUNCTION NPixel2Char(textBuf: Ptr;textLen: LONGINT;slop: Fixed;pixelWidth: Fixed; VAR leadingEdge: BOOLEAN;VAR widthRemaining: Fixed;styleRunPosition: JustStyleCode; numer: Point;denom: Point): INTEGER; INLINE $2F3C,$8222,$002E,$A8B5; FUNCTION NChar2Pixel(textBuf: Ptr;textLen: LONGINT;slop: Fixed;offset: LONGINT; direction: INTEGER;styleRunPosition: JustStyleCode;numer: Point;denom: Point): INTEGER; INLINE $2F3C,$821C,$0030,$A8B5; PROCEDURE NDrawJust(textPtr: Ptr;textLength: LONGINT;slop: Fixed;styleRunPosition: JustStyleCode; numer: Point;denom: Point); INLINE $2F3C,$8016,$0032,$A8B5; PROCEDURE NMeasureJust(textPtr: Ptr;textLength: LONGINT;slop: Fixed;charLocs: Ptr; styleRunPosition: JustStyleCode;numer: Point;denom: Point); INLINE $2F3C,$801A,$0034,$A8B5; FUNCTION NPortionText(textPtr: Ptr;textLen: LONGINT;styleRunPosition: JustStyleCode; numer: Point;denom: Point): Fixed; INLINE $2F3C,$8412,$0036,$A8B5; {$ENDC} { UsingScript } {$IFC NOT UsingIncludes} END. {$ENDC}