> DO item: REF ANY ¬ NIL; char: CHAR = in.GetChar[ ! IO.EndOfStream => EXIT]; SELECT char FROM Ascii.SP, Ascii.TAB => LOOP; -- leading white space on line '* => LOOP; -- a flag used in XDE DF files, similar to '+, we ignore it Ascii.CR, Ascii.LF => { <> IF filter.comments THEN blankLineCount ¬ blankLineCount.SUCC; LOOP }; '+ => { FlushWhiteSpace[]; item ¬ ParseFileItem[verifyRoot: TRUE]; }; '- => { FlushWhiteSpace[]; IF in.PeekChar[] = '- THEN { <> comment: ROPE = Rope.Concat["-", in.GetLineRope[]]; IF filter.comments THEN item ¬ NEW[DFUtilities.CommentItem ¬ [text: comment]]; } ELSE {in.Backup[char]; item ¬ ParseFileItem[]}; }; '/ => { <> FlushWhiteSpace[]; IF in.GetChar[] = '/ THEN { comment: ROPE ¬ NIL; comment ¬ in.GetLineRope[ ! IO.EndOfStream => CONTINUE]; <> IF filter.comments THEN item ¬ NEW[DFUtilities.CommentItem ¬ [text: Rope.Concat["--", comment]]]; } ELSE ERROR SyntaxError["'/' is illegal at the start of a line."]; }; ENDCASE => { x: REF TEXT; in.Backup[char]; x ¬ GetTokenAsRefText[SimpleToken]; SELECT TRUE FROM RefText.Equal[x, "Directory", FALSE] => item ¬ ParseDirectoryItem[exported: FALSE, readOnly: FALSE]; RefText.Equal[x, "ReadOnly", FALSE] => item ¬ ParseDirectoryItem[exported: FALSE, readOnly: TRUE]; RefText.Equal[x, "Imports", FALSE] => item ¬ ParseImportsItem[exported: FALSE]; RefText.Equal[x, "Include", FALSE], RefText.Equal[x, "Includes", FALSE] => item ¬ ParseIncludeItem[]; RefText.Equal[x, "Exports", FALSE] => { IF EndOfLineText[x ¬ GetTokenAsRefText[SimpleToken]] THEN ERROR SyntaxError["Missing directory path following 'Exports'."]; SELECT TRUE FROM RefText.Equal[x, "Directory", FALSE] => item ¬ ParseDirectoryItem[exported: TRUE, readOnly: FALSE]; RefText.Equal[x, "ReadOnly", FALSE] => item ¬ ParseDirectoryItem[exported: TRUE, readOnly: TRUE]; RefText.Equal[x, "Imports", FALSE] => item ¬ ParseImportsItem[exported: TRUE]; ENDCASE => item ¬ ParseDirectoryItem[ exported: TRUE, readOnly: FALSE, path1: Rope.FromRefText[x]]; }; ENDCASE => item ¬ ParseFileItem[name: Rope.FromRefText[x]]; }; IF item ~= NIL THEN { FlushWhiteSpace[]; IF proc[item] THEN ERROR Abort; } ELSE CancelWhiteSpace[]; ENDLOOP; RefText.ReleaseScratch[bufferN]; RefText.ReleaseScratch[bufferT]; }; SortUsingList[usingList: filter.list, nearlySorted: TRUE]; ParseInner[ ! Abort => CONTINUE; IO.EndOfStream => ERROR SyntaxError["Unexpected end of DF."]; IO.Error => ERROR SyntaxError[NIL]; ] }; ParseDigits: PROC [text: REF TEXT, start, stop: NAT] RETURNS [n: INT ¬ 0] ~ { FOR i: NAT IN[start..stop) DO char: CHAR ~ text[i]; IF char IN['0..'9] THEN n ¬ n*10+(char-'0) ELSE EXIT; ENDLOOP; }; ParseMonth: PROC [text: REF TEXT, start, stop: NAT] RETURNS [BasicTime.MonthOfYear] ~ { State: TYPE ~ {null, A, Ap, Apr, Au, Aug, D, De, Dec, F, Fe, Feb, J, Ja, Jan, Ju, Jul, Jun, M, Ma, Mar, May, N, No, Nov, O, Oc, Oct, S, Se, Sep}; state: State ¬ null; FOR i: NAT IN[start..stop) DO char: CHAR ~ text[i]; SELECT state FROM null => SELECT char FROM 'A => state ¬ A; 'D => state ¬ D; 'F => state ¬ F; 'J => state ¬ J; 'M => state ¬ M; 'N => state ¬ N; 'O => state ¬ O; 'S => state ¬ S; ENDCASE => GOTO bogus; A => SELECT char FROM 'p => state ¬ Ap; 'u => state ¬ Au; ENDCASE => GOTO bogus; Ap => SELECT char FROM 'r => state ¬ Apr; ENDCASE => GOTO bogus; Au => SELECT char FROM 'g => state ¬ Aug; ENDCASE => GOTO bogus; D => SELECT char FROM 'e => state ¬ De; ENDCASE => GOTO bogus; De => SELECT char FROM 'c => state ¬ Dec; ENDCASE => GOTO bogus; F => SELECT char FROM 'e => state ¬ Fe; ENDCASE => GOTO bogus; Fe => SELECT char FROM 'b => state ¬ Feb; ENDCASE => GOTO bogus; J => SELECT char FROM 'a => state ¬ Ja; 'u => state ¬ Ju; ENDCASE => GOTO bogus; Ja => SELECT char FROM 'n => state ¬ Jan; ENDCASE => GOTO bogus; Ju => SELECT char FROM 'l => state ¬ Jul; 'n => state ¬ Jun; ENDCASE => GOTO bogus; M => SELECT char FROM 'a => state ¬ Ma; ENDCASE => GOTO bogus; Ma => SELECT char FROM 'r => state ¬ Mar; 'y => state ¬ May; ENDCASE => GOTO bogus; N => SELECT char FROM 'o => state ¬ No; ENDCASE => GOTO bogus; No => SELECT char FROM 'v => state ¬ Nov; ENDCASE => GOTO bogus; O => SELECT char FROM 'c => state ¬ Oc; ENDCASE => GOTO bogus; Oc => SELECT char FROM 't => state ¬ Oct; ENDCASE => GOTO bogus; S => SELECT char FROM 'e => state ¬ Se; ENDCASE => GOTO bogus; Se => SELECT char FROM 'p => state ¬ Sep; ENDCASE => GOTO bogus; ENDCASE => GOTO bogus; ENDLOOP; SELECT state FROM Jan => RETURN[January]; Feb => RETURN[February]; Mar => RETURN[March]; Apr => RETURN[April]; May => RETURN[May]; Jun => RETURN[June]; Jul => RETURN[July]; Aug => RETURN[August]; Sep => RETURN[September]; Oct => RETURN[October]; Nov => RETURN[November]; Dec => RETURN[December]; ENDCASE => GOTO bogus; EXITS bogus => RETURN [unspecified]; }; ZoneInfo: TYPE ~ RECORD [zone: BasicTime.Zone, dst: BOOL]; nullZoneInfo: ZoneInfo ~ [zone: BasicTime.unspecifiedZone, dst: FALSE]; ParseZone: PROC [text: REF TEXT, start, stop: NAT] RETURNS [info: ZoneInfo ¬ nullZoneInfo] ~ { minus, dst: BOOL ¬ FALSE; hrs, mins: INT ¬ 0; SELECT stop-start FROM 3 => { zoneRope: Rope.ROPE ¬ Rope.FromRefText[text, start, 3]; SELECT TRUE FROM -- GMT needs more general parser - MGL Rope.Equal[zoneRope, "GMT"] => { hrs ¬ 0; dst ¬ FALSE }; Rope.Equal[zoneRope, "BST"] => { hrs ¬ 0; dst ¬ TRUE }; Rope.Equal[zoneRope, "PST"] => { hrs ¬ 8; dst ¬ FALSE }; Rope.Equal[zoneRope, "MST"] => { hrs ¬ 7; dst ¬ FALSE }; Rope.Equal[zoneRope, "CST"] => { hrs ¬ 6; dst ¬ FALSE }; Rope.Equal[zoneRope, "EST"] => { hrs ¬ 5; dst ¬ FALSE }; Rope.Equal[zoneRope, "PDT"] => { hrs ¬ 8; dst ¬ TRUE }; Rope.Equal[zoneRope, "MDT"] => { hrs ¬ 7; dst ¬ TRUE }; Rope.Equal[zoneRope, "CDT"] => { hrs ¬ 6; dst ¬ TRUE }; Rope.Equal[zoneRope, "EDT"] => { hrs ¬ 5; dst ¬ TRUE }; Rope.Equal[zoneRope, "JST"] => { hrs ¬ 9; minus ¬ TRUE; dst ¬ FALSE }; ENDCASE => GOTO bogus; < hrs _ 8; 'M => hrs _ 7; 'C => hrs _ 6; 'E => hrs _ 5;>> < GOTO bogus;>> < dst _ FALSE; 'D => dst _ TRUE;>> < GOTO bogus;>> < NULL;>> < GOTO bogus;>> }; 5 => { SELECT text[start] FROM '+ => NULL; '- => minus ¬ TRUE; ENDCASE => GOTO bogus; hrs ¬ ParseDigits[text, start+1, start+3]; mins ¬ ParseDigits[text, start+3, start+5]; }; ENDCASE => GOTO bogus; IF hrs IN[0..24) AND mins IN[0..60) THEN { info.zone ¬ hrs*60+mins; IF minus THEN info.zone ¬ -info.zone; info.dst ¬ dst; } ELSE GOTO bogus; EXITS bogus => RETURN [nullZoneInfo]; }; GetDateAndLineSep: PROC [in: STREAM, text: REF TEXT] RETURNS [date: DFUtilities.Date ¬ []] = { State: TYPE ~ { date1, -- awaiting beginning of date date2, -- saw "~", awaiting "=" date3, -- awaiting end of line after date day, -- in day part of date month1, -- awaiting month part of date month2, -- in month part of date year1, -- awaiting year part of date year2, -- in year part of date hour1, -- awaiting hour part of date hour2, -- in hour part of date minute1, -- awaiting minute part of date minute2, -- in minute part of date second1, -- awaiting second part of date second2, -- in second part of date zone1, -- awaiting zone part of date zone2, -- in alphabetic zone part of date (like "PST") zone3 -- in numeric zone part of date (like "+0200") }; state: State ¬ date1; dayStart, dayStop: NAT ¬ 0; monthStart, monthStop: NAT ¬ 0; yearStart, yearStop: NAT ¬ 0; hourStart, hourStop: NAT ¬ 0; minuteStart, minuteStop: NAT ¬ 0; secondStart, secondStop: NAT ¬ 0; zoneStart, zoneStop: NAT ¬ 0; append: BOOL ¬ FALSE; text.length ¬ 0; DO char: CHAR ~ in.GetChar[ ! IO.EndOfStream => EXIT]; index: NAT ~ text.length; { SELECT state FROM date1 => SELECT char FROM Ascii.SP, Ascii.TAB => { }; Ascii.CR, Ascii.LF => { date.format ¬ omitted; EXIT }; '> => { date.format ¬ greaterThan; state ¬ date3 }; '# => { date.format ¬ notEqual; state ¬ date3 }; '~ => { state ¬ date2 }; IN ['0..'9] => { append ¬ TRUE; dayStart ¬ index; state ¬ day }; ENDCASE => { GOTO bogus }; date2 => SELECT char FROM '= => { date.format ¬ notEqual; state ¬ date3 }; ENDCASE => { GOTO bogus }; date3 => SELECT char FROM Ascii.SP, Ascii.TAB => { }; Ascii.CR, Ascii.LF => { EXIT }; ENDCASE => { ERROR SyntaxError["Unrecognizable text where end-of-line was expected."] }; day => SELECT char FROM IN ['0..'9] => { }; '-, Ascii.SP => { dayStop ¬ index; state ¬ month1 }; ENDCASE => { GOTO bogus }; month1 => SELECT char FROM Ascii.SP => { }; IN ['A..'Z] => { monthStart ¬ index; state ¬ month2 }; ENDCASE => { GOTO bogus }; month2 => SELECT char FROM IN ['a..'z] => { }; '-, Ascii.SP => { monthStop ¬ index; state ¬ year1 }; ENDCASE => { GOTO bogus }; year1 => SELECT char FROM Ascii.SP => { }; IN ['0..'9] => { yearStart ¬ index; state ¬ year2 }; ENDCASE => { GOTO bogus }; year2 => SELECT char FROM IN ['0..'9] => { }; Ascii.SP, Ascii.TAB => { yearStop ¬ index; state ¬ hour1 }; ENDCASE => { GOTO bogus }; hour1 => SELECT char FROM Ascii.SP => { }; IN ['0..'9] => { hourStart ¬ index; state ¬ hour2 }; ENDCASE => { GOTO bogus }; hour2 => SELECT char FROM IN ['0..'9] => { }; ': => { hourStop ¬ index; state ¬ minute1 }; ENDCASE => { GOTO bogus }; minute1 => SELECT char FROM IN ['0..'9] => { minuteStart ¬ index; state ¬ minute2 }; ENDCASE => { GOTO bogus }; minute2 => SELECT char FROM IN ['0..'9] => { }; ': => { minuteStop ¬ index; state ¬ second1 }; ENDCASE => { GOTO bogus }; second1 => SELECT char FROM IN ['0..'9] => { secondStart ¬ index; state ¬ second2 }; ENDCASE => { GOTO bogus }; second2 => SELECT char FROM IN ['0..'9] => { }; Ascii.SP => { secondStop ¬ index; state ¬ zone1 }; ENDCASE => { GOTO bogus }; zone1 => SELECT char FROM Ascii.SP => { }; IN ['A..'Z] => { zoneStart ¬ index; state ¬ zone2 }; '+, '- => { zoneStart ¬ index; state ¬ zone3 }; ENDCASE => { GOTO bogus }; zone2 => SELECT char FROM IN ['A..'Z] => { }; Ascii.CR, Ascii.LF => { zoneStop ¬ index; EXIT }; Ascii.SP, Ascii.TAB => { zoneStop ¬ index; append ¬ FALSE; state ¬ date3 }; ENDCASE => { GOTO bogus }; zone3 => SELECT char FROM IN ['0..'9] => { }; Ascii.CR, Ascii.LF => { zoneStop ¬ index; EXIT }; Ascii.SP, Ascii.TAB => { zoneStop ¬ index; append ¬ FALSE; state ¬ date3 }; ENDCASE => { GOTO bogus }; ENDCASE => ERROR; }; IF append THEN text ¬ RefText.InlineAppendChar[to: text, from: char]; ENDLOOP; IF text.length>0 THEN { u: BasicTime.Unpacked ¬ []; day: INT ~ ParseDigits[text, dayStart, dayStop]; month: BasicTime.MonthOfYear ~ ParseMonth[text, monthStart, monthStop]; year: INT ~ ParseDigits[text, yearStart, yearStop]; hour: INT ~ ParseDigits[text, hourStart, hourStop]; minute: INT ~ ParseDigits[text, minuteStart, minuteStop]; second: INT ~ ParseDigits[text, secondStart, secondStop]; z: ZoneInfo ~ ParseZone[text, zoneStart, zoneStop]; IF year IN[0..100) THEN u.year ¬ (IF year>30 THEN 1900 ELSE 2000)+year ELSE GOTO bogus; IF month#unspecified THEN u.month ¬ month ELSE GOTO bogus; IF day IN[1..BasicTime.daysPerMonth] THEN u.day ¬ day ELSE GOTO bogus; IF hour IN[0..BasicTime.hoursPerDay) THEN u.hour ¬ hour ELSE GOTO bogus; IF minute IN[0..BasicTime.minutesPerHour) THEN u.minute ¬ minute ELSE GOTO bogus; IF second IN[0..BasicTime.secondsPerMinute) THEN u.second ¬ second ELSE GOTO bogus; IF z#nullZoneInfo THEN { u.zone ¬ z.zone; u.dst ¬ IF z.dst THEN yes ELSE no }; date.gmt ¬ BasicTime.Pack[u ! BasicTime.OutOfRange => GOTO bogus]; date.format ¬ explicit; }; EXITS bogus => ERROR SyntaxError["Illegal date specification."]; }; SyntaxError: PUBLIC ERROR [reason: ROPE] = CODE; WriteToStream: PUBLIC PROC [out: STREAM, proc: DFUtilities.SupplyItemProc] = { haveDirectory: BOOL ¬ FALSE; DO item: REF ANY = proc[]; IF item = NIL THEN EXIT; WITH item SELECT FROM directory: REF DFUtilities.DirectoryItem => haveDirectory ¬ TRUE; file: REF DFUtilities.FileItem => IF ~haveDirectory THEN ERROR SyntaxError["File item without preceding Directory item."]; imports: REF DFUtilities.ImportsItem => haveDirectory ¬ FALSE; include: REF DFUtilities.IncludeItem => haveDirectory ¬ FALSE; ENDCASE; WriteItemToStream[out, item]; ENDLOOP; }; WriteItemToStream: PUBLIC PROC [out: STREAM, item: REF ANY] = { maxUsingLineLength: INT = 90; maxReasonableFileNameLength: INT = 45; WITH item SELECT FROM directory: REF DFUtilities.DirectoryItem => { IF directory.exported THEN out.PutRope["Exports "]; IF directory.readOnly THEN out.PutRope["ReadOnly "]; IF ~(directory.exported OR directory.readOnly) THEN out.PutRope["Directory "]; out.PutRope[directory.path1]; }; file: REF DFUtilities.FileItem => { out.PutRope[" "]; IF file.verifyRoot THEN out.PutChar['+]; out.PutRope[file.name]; THROUGH [0..MAX[maxReasonableFileNameLength-file.name.Length[], 1]) DO out.PutChar[Ascii.SP]; ENDLOOP; DateToStream[out, file.date]; }; imports: REF DFUtilities.ImportsItem => { IF imports.exported THEN out.PutRope["Exports "]; out.PutRope["Imports "]; out.PutRope[imports.path1]; out.PutRope[" Of "]; DateToStream[out, imports.date]; SELECT imports.form FROM <> <> exports => NULL; all => { out.PutChar[LineSep]; out.PutRope[" Using All"]; }; list => { out.PutChar[LineSep]; out.PutRope[" Using ["]; IF imports.list ~= NIL THEN FOR i: NAT IN [0..imports.list.nEntries) DO entry: DFUtilities.UsingEntry = imports.list.u[i]; IF i # 0 THEN out.PutRope[", "]; IF entry.verifyRoot THEN out.PutChar['+]; out.PutRope[entry.name]; ENDLOOP; out.PutRope["]"]; }; <> <> <> <> <> <> <> < maxUsingLineLength THEN {>> <> <> <> <> <<}>> <> <> <> <> <> <> <<};>> <> ENDCASE; }; include: REF DFUtilities.IncludeItem => { out.PutRope["Include "]; out.PutRope[include.path1]; out.PutRope[" Of "]; DateToStream[out, include.date]; }; comment: REF DFUtilities.CommentItem => out.PutRope[comment.text]; whiteSpace: REF DFUtilities.WhiteSpaceItem => THROUGH [0..whiteSpace.lines-1) DO out.PutChar[LineSep]; ENDLOOP; ENDCASE => ERROR SyntaxError["Unrecognizable item."]; out.PutChar[LineSep]; }; SortUsingList: PUBLIC PROC [usingList: REF DFUtilities.UsingList, nearlySorted: BOOL] = { IF usingList = NIL THEN RETURN; IF nearlySorted THEN { <> FOR i: NAT IN [1..usingList.nEntries) DO item: DFUtilities.UsingEntry = usingList.u[i]; j: NAT ¬ i; -- 'j' can't be a loop control variable; we want its value on termination. WHILE Rope.Compare[item.name, usingList.u[j-1].name, FALSE] = less DO usingList.u[j] ¬ usingList.u[j-1]; IF (j ¬ j.PRED) = 0 THEN EXIT; ENDLOOP; IF j ~= i THEN usingList.u[j] ¬ item; -- test avoids unnecessary reference counting. ENDLOOP; } ELSE { <> SiftUp: PROC [low, high: NAT] = { k: NAT ¬ low; DO twoK: NAT = k*2; son: NAT ¬ twoK; IF twoK > high THEN EXIT; IF twoK+1 <= high AND Rope.Compare[usingList.u[twoK+1-1].name, usingList.u[twoK-1].name, FALSE] ~= less THEN son ¬ twoK+1; IF Rope.Compare[usingList.u[son-1].name, usingList.u[k-1].name, FALSE] = less THEN EXIT; Exchange[son-1, k-1]; k ¬ son; ENDLOOP; }; Exchange: PROC [a, b: NAT] = { temp: DFUtilities.UsingEntry = usingList.u[a]; usingList.u[a] ¬ usingList.u[b]; usingList.u[b] ¬ temp; }; FOR i: NAT DECREASING IN [1..usingList.nEntries/2] DO SiftUp[i, usingList.nEntries]; ENDLOOP; FOR i: NAT DECREASING IN [1..usingList.nEntries) DO Exchange[0, i]; SiftUp[1, i]; ENDLOOP; }; }; SearchUsingList: PUBLIC PROC [file: ROPE, list: REF DFUtilities.UsingList] RETURNS [found: BOOL ¬ FALSE, index: NAT ¬ 0] = { <> IF list = NIL THEN found ¬ TRUE -- NIL list is interpreted as "everything" ELSE { low: INTEGER ¬ 0; high: INTEGER ¬ list.nEntries.PRED; UNTIL low > high DO probe: NAT ¬ (low + high) / 2; SELECT file.Compare[list.u[probe].name, FALSE] FROM equal => RETURN [TRUE, probe]; less => IF probe = 0 THEN EXIT ELSE high ¬ probe.PRED; greater => IF probe = list.nEntries.PRED THEN EXIT ELSE low ¬ probe.SUCC; ENDCASE; ENDLOOP; found ¬ FALSE; }; }; DifferenceOfUsingLists: PUBLIC PROC [a, b: REF DFUtilities.UsingList] RETURNS [diff: REF DFUtilities.UsingList ¬ NIL] = { aI, bI: NAT ¬ 0; aL: NAT = a.nEntries; bL: NAT = b.nEntries; diff ¬ NEW[DFUtilities.UsingList[a.nEntries]]; diff.nEntries ¬ 0; UNTIL aI = aL OR bI = bL DO SELECT a.u[aI].name.Compare[b.u[bI].name, FALSE] FROM equal => aI ¬ aI.SUCC; less => { diff.u[diff.nEntries] ¬ a.u[aI]; diff.nEntries ¬ diff.nEntries.SUCC; aI ¬ aI.SUCC; }; greater => bI ¬ bI.SUCC; ENDCASE; ENDLOOP; UNTIL aI = aL DO diff.u[diff.nEntries] ¬ a.u[aI]; diff.nEntries ¬ diff.nEntries.SUCC; aI ¬ aI.SUCC; ENDLOOP; }; DateToRope: PUBLIC PROC [date: DFUtilities.Date] RETURNS [ROPE ¬ NIL] = { SELECT date.format FROM $explicit => { months: ROPE = "JanFebMarAprMayJunJulAugSepOctNovDec"; up: BasicTime.Unpacked = BasicTime.Unpack[date.gmt ! BasicTime.OutOfRange, BasicTime.TimeParametersNotKnown => GO TO noDate]; ConvertZone: PROC RETURNS [ROPE] = { dst: BOOL = up.dst = yes; jstZone: BasicTime.Zone = -9*BasicTime.minutesPerHour; SELECT up.zone FROM 0 => RETURN [IF dst THEN "BST" ELSE "GMT"]; NAT[5*BasicTime.minutesPerHour] => RETURN [IF dst THEN "EDT" ELSE "EST"]; NAT[6*BasicTime.minutesPerHour] => RETURN [IF dst THEN "CDT" ELSE "CST"]; NAT[7*BasicTime.minutesPerHour] => RETURN [IF dst THEN "MDT" ELSE "MST"]; NAT[8*BasicTime.minutesPerHour] => RETURN [IF dst THEN "PDT" ELSE "PST"]; jstZone => RETURN["JST"]; ENDCASE; RETURN [ IO.PutFR["%g%02d%02d", [character[IF up.zone < 0 THEN '- ELSE '+]], [cardinal[up.zone.ABS/BasicTime.minutesPerHour]], [cardinal[up.zone.ABS MOD BasicTime.minutesPerHour]] ] ] }; RETURN [ IO.PutFLR["%02d-%g-%02d %02d:%02d:%02d %g", LIST[ [cardinal[up.day]], [rope[months.Substr[start: up.month.ORD*3, len: 3]]], [cardinal[up.year MOD 100]], [cardinal[up.hour]], [cardinal[up.minute]], [cardinal[up.second]], [rope[ConvertZone[]]] ]] ] }; $notEqual => RETURN ["~="]; $greaterThan => RETURN [">"]; ENDCASE; EXITS noDate => {}; }; DateToStream: PUBLIC PROC [s: STREAM, date: DFUtilities.Date] = { s.PutRope[DateToRope[date] ] }; derivedList: LIST OF ROPE ¬ LIST[".bcd", ".boot", ".press", ".signals", ".mob", ".o", ".ip", ".interpress", ".c2c.c", ".dvi", ".$cheme", ".sx.c"]; IsExtension: PROC [base, ext: ROPE] RETURNS [BOOL] ~ { bsize: INT ~ Rope.Length[base]; esize: INT ~ Rope.Length[ext]; i: INT ~ Rope.FindBackward[s1: base, s2: ext, case: FALSE]; IF i<0 THEN RETURN[FALSE]; -- ext not found IF (i+esize) RETURN [pos]; '., '>, '] => RETURN [len]; ENDCASE; ENDLOOP; RETURN [len]; }; <<>> RaiseSyntaxError: PROC [prefix: ROPE, text: REF TEXT] = { ERROR SyntaxError[IO.PutFR["%g '%g'.", [rope[prefix]], [text[text]] ] ]; }; <<>> END. <> <> <> <> <> <> <<>>