FoxParser.Mod 85 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291
  1. MODULE FoxParser; (** AUTHOR "fof & fn"; PURPOSE "Oberon Compiler: Parser"; **)
  2. (* (c) fof ETH Zurich, 2009 *)
  3. IMPORT Basic := FoxBasic, Scanner := FoxScanner, D := Debugging, SyntaxTree := FoxSyntaxTree, Global := FoxGlobal, Diagnostics;
  4. CONST
  5. Trace = FALSE;
  6. CascadedWithSupport = TRUE;
  7. (** the parser reflects the following EBNF:
  8. Module = ('module' | 'cellnet' [Flags]) Identifier ['in' Identifier]';'
  9. [ImportList] DeclarationSequence [Body]
  10. 'end' Identifier '.'.
  11. ImportList = 'import' Import { ',' Import } ';'.
  12. Import = Identifier [':=' Identifier] ['in' Identifier].
  13. DeclarationSequence = {
  14. 'const' [ConstDeclaration] {';' [ConstDeclaration]}
  15. |'type' [TypeDeclaration] {';' [TypeDeclaration]}
  16. |'var' [VariableDeclaration] {';' [VariableDeclaration]}
  17. | ProcedureDeclaration
  18. | OperatorDeclaration
  19. | ';'
  20. }
  21. Declaration = IdentifierDefinition '=' Expression.
  22. TypeDeclaration = IdentifierDefinition '=' Type.
  23. VariableDeclaration = VariableNameList ':' Type.
  24. VariableNameList = IdentifierDefinition [Flags] [':=' Expression | 'extern' String] {',' IdentifierDefinition [Flags] [':=' Expression | 'extern' String] }.
  25. OperatorDeclaration = 'operator' [Flags] ['-'] String ['*'|'-'] FormalParameters ';'
  26. DeclarationSequence [Body] 'end' String.
  27. ProcedureDeclaration = 'procedure' ['^'|'&'|'~'|'-'|Flags ['-']] IdentifierDefinition [FormalParameters]';'
  28. DeclarationSequence [Body] 'end' Identifier.
  29. Flags = '{' [Identifier ['(' Expression ')'|'=' Expression] {',' Identifier ['(' Expression ')' | '=' Expression ] } ] '}'.
  30. FormalParameters = '(' [ParameterDeclaration {';' ParameterDeclaration}] ')' [':' [Flags] Type].
  31. ParameterDeclaration = ['var'|'const'] Identifier [Flags] ['= Expression] {',' Identifier [Flags] ['= Expression]}':' Type.
  32. PortList = '(' [PortDeclaration {';' PortDeclaration}] ')'.
  33. PortDeclaration = Identifier [Flags] {',' Identifier [Flags]}':' Type.
  34. Type = ArrayType | RecordType | PointerType | ObjectType | CellType | CellnetType | PortType
  35. | ProcedureType | EnumerationType | QualifiedIdentifier.
  36. PortType = 'port' ('in'|'out') ['(' Expression ')']
  37. EnumerationType = 'enum' ['('QualifiedIdentifier')'] IdentifierDefinition ['=' Expression]
  38. {',' IdentifierDefinition ['=' Expression]} 'end'.
  39. ArrayType = 'array' 'of' Type | 'array' Expression {',' Expression} 'of' Type
  40. | 'array' '[' MathArraySize {',' MathArraySize} ']' ['of' Type].
  41. MathArraySize = Expression | '*' | '?'.
  42. RecordType = 'record' [Flags] ['(' QualifiedIdentifier ')'] [VariableDeclaration {';' VariableDeclaration}] 'end'.
  43. PointerType = 'pointer' [Flags] 'to' Type.
  44. CellType = 'cell' [Flags] [PortList] [';'] DeclarationSequence [Body] 'end' [Identifier].
  45. ObjectType = 'object' | 'object' [Flags] ['(' (QualifiedIdentifier | ArrayType) ')'] DeclarationSequence [Body] 'end' [Identifier] .
  46. ProcedureType = 'procedure' [Flags] [FormalParameters].
  47. Body = 'begin' [Flags] StatementSequence ['finally' StatementSequence]
  48. | 'code' Code.
  49. Code = { any \ 'end' \ 'with' } ['with' {('in'|'out') StatementSequence}] .
  50. StatementBlock = [Flags] StatementSequence.
  51. StatementSequence = Statement {';' Statement}.
  52. Statement =
  53. [
  54. Designator [':=' Expression |'!' Expression | '?' Expression | '<<' Expresssion | '>>' Expression]
  55. | 'if' Expression 'then' StatementSequence
  56. {'elsif' Expression 'then' StatementSequence}
  57. ['else' StatementSequence]
  58. 'end'
  59. | 'with' Identifier ':' QualifiedIdentifier 'do' StatementSequence
  60. {'|' Identifier ':' QualifiedIdentifier 'do' StatementSequence}
  61. [else StatementSequence]
  62. 'end'
  63. | 'case' Expression 'of' ['|'] Case {'|' Case} ['else' StatementSequence] 'end'
  64. | 'while' Expression 'do' StatementSequence 'end'
  65. | 'repeat' StatementSequence 'until' Expression
  66. | 'for' Identifier ':=' Expression 'to' Expression ['by' Expression] 'do'
  67. StatementSequence 'end'
  68. | 'loop' StatementSequence 'end'
  69. | 'exit'
  70. | 'return' [Expression]
  71. | 'await' Expression
  72. | 'begin' StatementBlock 'end'
  73. | 'code' {any} 'end'
  74. ].
  75. Case = RangeExpression {',' RangeExpression} ':' StatementSequence.
  76. Expression = RangeExpression [RelationOp RangeExpression].
  77. RelationOp = '=' | '.=' | '#' | '.#'
  78. | '<' | '.<' | '<=' | '.<=' | '>' | '.>' | '>=' | '.>='
  79. | '??' | '!!' | '<<?' | '>>?'
  80. | 'in' | 'is'
  81. SimpleExpression = ['+'|'-'] Term {AddOp Term}.
  82. AddOp = '+' | '-' | 'or'.
  83. Term = Factor {MulOp Factor}.
  84. MulOp = '*' | '**' | '.*' | '+*' | '/' | '\' | './' | 'div' | 'mod' | '&'.
  85. Factor = Number | Character | String | 'nil' | 'imag' | 'true' | 'false' | Set
  86. | '(' Expression ')' | '~' Factor | Factor '`' | Designator | MathArray.
  87. | 'SIZE' 'OF' Designator | 'ADDRESS' 'OF' Designator
  88. MathArray = '[' Expression {',' Expression} ']'.
  89. Set = '{' [ RangeExpression {',' RangeExpression} ] '}'.
  90. Designator = ('self' | 'result' | Identifier)
  91. {'.' Identifier | '[' IndexList ']' | '(' [ExpressionList] ')' | '^'} [Flags].
  92. RangeExpression = SimpleExpression | [SimpleExpression] '..' [SimpleExpression] ['by' SimpleExpression] | '*'.
  93. IndexList = '?' [',' ExpressionList ] | ExpressionList [',' '?'].
  94. ExpressionList = Expression { ',' Expression }.
  95. IdentifierDefinition = Identifier [ '*' | '-' ].
  96. QualifiedIdentifier = Identifier ['.' Identifier].
  97. Identifier = Letter {Letter | Digit | '_'}.
  98. Letter = 'A' | 'B' | .. | 'Z' | 'a' | 'b' | .. | 'z'.
  99. String = '"' {Character} '"' | "'" {Character} "'".
  100. Number = Integer | Real.
  101. Integer = Digit {Digit} | '0' 'x' {HexDigit} | Digit {HexDigit} 'H' .
  102. Real = Digit {Digit} '.' {Digit} [ScaleFactor].
  103. ScaleFactor = ('E' | 'D') ['+' | '-'] digit {digit}.
  104. HexDigit = Digit | 'A' | 'B' | 'C' | 'D' | 'E' | 'F'
  105. Digit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' .
  106. **)
  107. TYPE
  108. Position*=Scanner.Position;
  109. Parser* = OBJECT
  110. VAR scanner-: Scanner.Scanner;
  111. symbol-: Scanner.Symbol;
  112. diagnostics: Diagnostics.Diagnostics;
  113. currentScope: SyntaxTree.Scope;
  114. recentCommentItem: ANY; recentLine: LONGINT;
  115. recentComment: SyntaxTree.Comment;
  116. moduleScope: SyntaxTree.ModuleScope;
  117. error-: BOOLEAN;
  118. Lax-: BOOLEAN;
  119. indent: LONGINT; (* for debugging purposes only *)
  120. hasSymbol: BOOLEAN;
  121. PROCEDURE S( CONST s: ARRAY OF CHAR ); (* for debugging purposes only *)
  122. VAR i: LONGINT;
  123. BEGIN
  124. D.Ln; INC( indent ); D.Int( indent,1 );
  125. FOR i := 1 TO indent DO D.Str( " " ); END;
  126. D.Str( "start: " ); D.Str( s ); D.Str( " at pos " ); D.Int( symbol.position.start,1 );
  127. END S;
  128. PROCEDURE E( CONST s: ARRAY OF CHAR ); (* for debugging purposes only *)
  129. VAR i: LONGINT;
  130. BEGIN
  131. D.Ln; D.Int( indent,1 );
  132. FOR i := 1 TO indent DO D.Str( " " ); END;
  133. D.Str( "end : " ); D.Str( s ); D.Str( " at pos " ); D.Int( symbol.position.start,1 );
  134. DEC(indent);
  135. END E;
  136. PROCEDURE EE( CONST s, t: ARRAY OF CHAR ); (* for debugging purposes only *)
  137. VAR i: LONGINT;
  138. BEGIN
  139. D.Ln; D.Int( indent,1 );
  140. FOR i := 1 TO indent DO D.Str( " " ); END;
  141. D.Str( "end : " ); D.Str( s ); D.Str( " (" ); D.Str( t ); D.Str( ") at pos " );
  142. DEC(indent);
  143. END EE;
  144. (** constructor, init parser with scanner providing input and with diagnostics for error output *)
  145. PROCEDURE & Init*( scanner: Scanner.Scanner; diagnostics: Diagnostics.Diagnostics );
  146. BEGIN
  147. SELF.scanner := scanner;
  148. SELF.diagnostics := diagnostics;
  149. error := ~scanner.GetNextSymbol(symbol);
  150. hasSymbol := TRUE;
  151. IF error THEN Basic.Error(diagnostics, scanner.source^, Basic.invalidPosition, "no input stream") END;
  152. recentCommentItem := NIL; recentComment := NIL;
  153. (* debugging *)
  154. indent := 0;
  155. Lax := FALSE;
  156. END Init;
  157. PROCEDURE Reset*;
  158. BEGIN
  159. error := FALSE;
  160. END Reset;
  161. PROCEDURE SetLax*;
  162. BEGIN
  163. Lax := TRUE;
  164. END SetLax;
  165. (** output error message and / or given code *)
  166. PROCEDURE Error(position: Position; code: LONGINT; CONST message: ARRAY OF CHAR);
  167. BEGIN
  168. Basic.ErrorC(diagnostics, scanner.source^, position, code, message);
  169. error := TRUE
  170. END Error;
  171. (** helper procedures interfacing to the scanner **)
  172. PROCEDURE SkipComments(b: BOOLEAN);
  173. VAR comment: SyntaxTree.Comment;
  174. BEGIN
  175. WHILE ~error & (b & (TokenB()= Scanner.Comment) OR ~b & (Token() = Scanner.Comment)) DO
  176. comment := SyntaxTree.NewComment(symbol.position, currentScope, symbol.string^,symbol.stringLength);
  177. IF moduleScope # NIL THEN
  178. moduleScope.AddComment(comment);
  179. END;
  180. IF recentComment = NIL THEN
  181. recentComment := comment;
  182. IF symbol.position.line = recentLine THEN
  183. IF recentCommentItem # NIL THEN
  184. IF (recentCommentItem IS SyntaxTree.Symbol) THEN
  185. IF recentCommentItem(SyntaxTree.Symbol).comment = NIL THEN
  186. recentCommentItem(SyntaxTree.Symbol).SetComment(comment)
  187. END;
  188. ELSIF (recentCommentItem IS SyntaxTree.Statement) THEN
  189. IF recentCommentItem(SyntaxTree.Statement).comment = NIL THEN
  190. recentCommentItem(SyntaxTree.Statement).SetComment(comment)
  191. END;
  192. ELSIF (recentCommentItem IS SyntaxTree.IfPart) THEN
  193. IF recentCommentItem(SyntaxTree.IfPart).comment = NIL THEN
  194. recentCommentItem(SyntaxTree.IfPart).SetComment(comment)
  195. END;
  196. ELSIF (recentCommentItem IS SyntaxTree.CasePart) THEN
  197. IF recentCommentItem(SyntaxTree.CasePart).comment = NIL THEN
  198. recentCommentItem(SyntaxTree.CasePart).SetComment(comment)
  199. END;
  200. ELSIF (recentCommentItem IS SyntaxTree.WithPart) THEN
  201. IF recentCommentItem(SyntaxTree.WithPart).comment = NIL THEN
  202. recentCommentItem(SyntaxTree.WithPart).SetComment(comment)
  203. END;
  204. END;
  205. comment.SetItem(recentCommentItem,TRUE);
  206. recentComment := NIL;
  207. recentCommentItem := NIL
  208. END;
  209. END;
  210. END;
  211. NextSymbol;
  212. (*error := ~scanner.GetNextSymbol(symbol);*)
  213. END;
  214. END SkipComments;
  215. (** Get next symbol from scanner and store it in object-local variable 'symbol' *)
  216. PROCEDURE NextSymbol*;
  217. VAR comment: SyntaxTree.Comment;
  218. BEGIN
  219. (*
  220. error := ~scanner.GetNextSymbol(symbol) OR error;
  221. hasSymbol := TRUE;
  222. SkipComments();
  223. *)
  224. hasSymbol := FALSE;
  225. END NextSymbol;
  226. PROCEDURE Token*(): LONGINT;
  227. BEGIN
  228. IF ~hasSymbol OR (symbol.token = Scanner.Escape) THEN
  229. error := ~scanner.GetNextSymbol(symbol) OR error;
  230. IF symbol.token = Scanner.Escape THEN
  231. error := ~scanner.GetNextSymbol(symbol) OR error;
  232. END;
  233. hasSymbol := TRUE;
  234. SkipComments(FALSE);
  235. END;
  236. RETURN symbol.token;
  237. END Token;
  238. (* stop on escape token *)
  239. PROCEDURE TokenB*(): LONGINT;
  240. BEGIN
  241. IF ~hasSymbol THEN
  242. error := ~scanner.GetNextSymbol(symbol) OR error;
  243. hasSymbol := TRUE;
  244. SkipComments(TRUE);
  245. END;
  246. RETURN symbol.token;
  247. END TokenB;
  248. (** Check if current symbol equals sym. If yes then return true, return false otherwise *)
  249. PROCEDURE PeekB*(token: Scanner.Token): BOOLEAN;
  250. VAR comment: SyntaxTree.Comment;
  251. BEGIN
  252. RETURN TokenB() = token
  253. END PeekB;
  254. (** Check if current symbol equals sym. If yes then return true, return false otherwise *)
  255. PROCEDURE Peek*(token: Scanner.Token): BOOLEAN;
  256. VAR comment: SyntaxTree.Comment;
  257. BEGIN
  258. SkipComments(FALSE);
  259. RETURN Token() = token
  260. END Peek;
  261. (** Check if the current symbol equals sym.If yes then read next symbol, report error otherwise. returns success value *)
  262. PROCEDURE Mandatory*( token: Scanner.Token): BOOLEAN;
  263. BEGIN
  264. ASSERT( token # Scanner.Identifier ); ASSERT( token # Scanner.String ); ASSERT( token # Scanner.Number ); (* because of NextSymbol ! *)
  265. IF ~Peek(token) THEN
  266. Error( symbol.position, token, "" );
  267. RETURN FALSE
  268. ELSE
  269. NextSymbol;
  270. RETURN TRUE
  271. END
  272. END Mandatory;
  273. (** Check if the current symbol equals sym. If yes then read next symbol, report error otherwise *)
  274. PROCEDURE Check( token: Scanner.Token );
  275. VAR b: BOOLEAN;
  276. BEGIN
  277. b := Mandatory( token );
  278. END Check;
  279. (** Check if current symbol is an identifier. If yes then copy identifier to name and get next symbol,
  280. report error otherwise and set name to empty name. returns success value *)
  281. PROCEDURE MandatoryIdentifier( VAR name: SyntaxTree.Identifier): BOOLEAN;
  282. BEGIN
  283. IF Peek(Scanner.Identifier) THEN
  284. name := symbol.identifier;
  285. NextSymbol;
  286. RETURN TRUE
  287. ELSE
  288. Error( symbol.position, Scanner.Identifier, "" );
  289. name := SyntaxTree.invalidIdentifier;
  290. RETURN FALSE
  291. END
  292. END MandatoryIdentifier;
  293. (** Expect an identifier (using MandatoryIdentifier) and return identifier object **)
  294. PROCEDURE Identifier(VAR position: Position): SyntaxTree.Identifier;
  295. VAR name: SyntaxTree.Identifier; identifier: SyntaxTree.Identifier;
  296. BEGIN
  297. position := symbol.position;
  298. IF MandatoryIdentifier(name) THEN
  299. identifier := name;
  300. ELSE
  301. identifier := SyntaxTree.invalidIdentifier;
  302. END;
  303. RETURN identifier
  304. END Identifier;
  305. (** Check if current symbol is a string (or string-like character). If yes then copy identifier to name and get next symbol,
  306. report error otherwise and set name to empty name. returns success value*)
  307. PROCEDURE MandatoryString*( VAR name: Scanner.StringType ): BOOLEAN;
  308. BEGIN
  309. IF Peek( Scanner.String) THEN
  310. name := symbol.string;
  311. NextSymbol;
  312. RETURN TRUE
  313. ELSIF Peek( Scanner.Character) THEN (* for compatibility with release: characters treated as strings *)
  314. name := symbol.string;
  315. NextSymbol;
  316. RETURN TRUE
  317. ELSE
  318. Error( symbol.position, Scanner.String, "" );
  319. NEW(name,1); name^ := "";
  320. RETURN FALSE
  321. END
  322. END MandatoryString;
  323. (** Check if current symbol is an identifier and if the name matches. If yes then get next symbol, report error otherwise. returns success value*)
  324. PROCEDURE ExpectThisIdentifier( name: SyntaxTree.Identifier ): BOOLEAN;
  325. VAR string: ARRAY 64 OF CHAR;
  326. BEGIN
  327. IF name = SyntaxTree.invalidIdentifier THEN (* nothing to be expected *)
  328. RETURN TRUE
  329. ELSIF (Token() # Scanner.Identifier) OR (symbol.identifier # name) THEN
  330. Basic.GetString(name,string);
  331. Error( symbol.position, Scanner.Identifier, string );
  332. RETURN FALSE
  333. ELSE
  334. NextSymbol;
  335. RETURN TRUE
  336. END
  337. END ExpectThisIdentifier;
  338. (** Check if current symbol is an identifier and if the name matches. If yes then get next symbol, report error otherwise. returns success value*)
  339. PROCEDURE ExpectThisString( CONST name: ARRAY OF CHAR ): BOOLEAN;
  340. BEGIN
  341. IF Peek(Scanner.String) & (symbol.string^ = name) THEN
  342. NextSymbol;
  343. RETURN TRUE
  344. ELSE
  345. Error( symbol.position, Scanner.String, name );
  346. RETURN FALSE
  347. END
  348. END ExpectThisString;
  349. (** Check if current symbol equals sym. If yes then get next symbol, return false otherwise *)
  350. PROCEDURE Optional*( token: Scanner.Token ): BOOLEAN;
  351. BEGIN
  352. (* do not use for Identifier, String or Number, if the result is needed ! *)
  353. IF Peek(token) THEN
  354. NextSymbol;
  355. RETURN TRUE
  356. ELSE
  357. RETURN FALSE
  358. END
  359. END Optional;
  360. PROCEDURE OptionalB*( token: Scanner.Token ): BOOLEAN;
  361. BEGIN
  362. (* do not use for Identifier, String or Number, if the result is needed ! *)
  363. IF PeekB(token) THEN
  364. NextSymbol;
  365. RETURN TRUE
  366. ELSE
  367. RETURN FALSE
  368. END
  369. END OptionalB;
  370. (* ignore one ore more symbols of type token *)
  371. PROCEDURE Ignore(token: Scanner.Token);
  372. BEGIN WHILE Optional(token) DO END;
  373. END Ignore;
  374. (** Parsing according to the EBNF **)
  375. (** QualifiedIdentifier = Identifier ['.' Identifier]. **)
  376. PROCEDURE QualifiedIdentifier*( ): SyntaxTree.QualifiedIdentifier;
  377. VAR prefix,suffix: SyntaxTree.Identifier; qualifiedIdentifier: SyntaxTree.QualifiedIdentifier; position0,position1: Position;
  378. BEGIN
  379. IF Trace THEN S( "QualifiedIdentifier" ) END;
  380. prefix := Identifier(position0);
  381. IF prefix # SyntaxTree.invalidIdentifier THEN
  382. IF ~Optional( Scanner.Period )THEN
  383. suffix := prefix; prefix := SyntaxTree.invalidIdentifier; (* empty *)
  384. ELSE
  385. suffix := Identifier(position1);
  386. END;
  387. qualifiedIdentifier := SyntaxTree.NewQualifiedIdentifier( position0, prefix,suffix);
  388. ELSE
  389. qualifiedIdentifier := SyntaxTree.invalidQualifiedIdentifier;
  390. END;
  391. IF Trace THEN E( "QualifiedIdentifier" ) END;
  392. RETURN qualifiedIdentifier
  393. END QualifiedIdentifier;
  394. (** IdentifierDefinition = Identifier [ '*' | '-' ]. **)
  395. PROCEDURE IdentifierDefinition( VAR name: SyntaxTree.Identifier; VAR access: SET; allowedReadOnly: BOOLEAN);
  396. VAR position: Position;
  397. BEGIN
  398. IF Trace THEN S( "IdentifierDefinition" ) END;
  399. name := Identifier(position);
  400. IF Optional( Scanner.Times ) THEN
  401. access := SyntaxTree.Public + SyntaxTree.Protected + SyntaxTree.Internal;
  402. ELSIF Optional( Scanner.Minus ) THEN
  403. IF ~allowedReadOnly THEN
  404. Error( symbol.position, Diagnostics.Invalid, "may not be defined read-only" )
  405. ELSE
  406. access := SyntaxTree.ReadOnly + {SyntaxTree.InternalWrite};
  407. END;
  408. ELSE
  409. access := SyntaxTree.Internal;
  410. END;
  411. IF Trace THEN E( "IdentifierDefinition") END;
  412. END IdentifierDefinition;
  413. (** ExpressionList = Expression { ',' Expression }. **)
  414. PROCEDURE ExpressionList( expressionList: SyntaxTree.ExpressionList );
  415. VAR expression: SyntaxTree.Expression;
  416. BEGIN
  417. IF Trace THEN S( "ExpressionList" ) END;
  418. REPEAT
  419. expression := Expression();
  420. expressionList.AddExpression( expression )
  421. UNTIL ~Optional( Scanner.Comma );
  422. IF Trace THEN E( "ExpressionList" ) END;
  423. END ExpressionList;
  424. (** IndexList = '?' [',' ExpressionList ] | ExpressionList [',' '?']. **)
  425. PROCEDURE IndexList(expressionList: SyntaxTree.ExpressionList);
  426. VAR
  427. position: Position;
  428. done: BOOLEAN;
  429. BEGIN
  430. IF Trace THEN S( "IndexList" ) END;
  431. position := symbol.position;
  432. IF Optional(Scanner.Questionmark) THEN
  433. expressionList.AddExpression(SyntaxTree.NewTensorRangeExpression(position));
  434. IF Optional(Scanner.Comma) THEN
  435. ExpressionList(expressionList);
  436. END
  437. ELSE
  438. expressionList.AddExpression(Expression());
  439. done := FALSE;
  440. WHILE ~done DO
  441. IF Optional(Scanner.Comma) THEN
  442. IF Optional(Scanner.Questionmark) THEN
  443. expressionList.AddExpression(SyntaxTree.NewTensorRangeExpression(position));
  444. done := TRUE;
  445. ELSE
  446. expressionList.AddExpression(Expression())
  447. END
  448. ELSE
  449. done := TRUE
  450. END
  451. END
  452. END;
  453. IF Trace THEN E( "IndexList" ) END;
  454. END IndexList;
  455. (** RangeExpression = SimpleExpression | [SimpleExpression] '..' [SimpleExpression] ['by' SimpleExpression] | '*'.
  456. i.e., a RangeExpression can have one of the following forms:
  457. '*'
  458. '..' [delimiter]
  459. '..' 'by' SimpleExpression
  460. '..' SimpleExpression
  461. '..' SimpleExpression 'by' SimpleExpression
  462. SimpleExpression
  463. SimpleExpression '..' [delimiter]
  464. SimpleExpression '..' 'by' SimpleExpression
  465. SimpleExpression '..' SimpleExpression
  466. SimpleExpression '..' SimpleExpression 'by' SimpleExpression
  467. a RangeExpression is always delimited by any of the following tokens: ",", ";", ":", "]", ")", "}", "=", "#", "END".
  468. **)
  469. PROCEDURE RangeExpression(): SyntaxTree.Expression;
  470. VAR
  471. expression, first, last, step: SyntaxTree.Expression;
  472. position: Position;
  473. PROCEDURE HasDelimiter(): BOOLEAN;
  474. BEGIN RETURN
  475. Peek(Scanner.Comma) OR Peek(Scanner.Semicolon) OR Peek(Scanner.Colon) OR
  476. Peek(Scanner.RightBracket) OR Peek(Scanner.RightParenthesis) OR Peek(Scanner.RightBrace) OR
  477. Peek(Scanner.Equal) OR Peek(Scanner.Unequal) OR Peek(Scanner.End)
  478. END HasDelimiter;
  479. BEGIN
  480. IF Trace THEN S( "RangeExpression" ) END;
  481. position := symbol.position;
  482. IF Optional(Scanner.Times) THEN
  483. expression := SyntaxTree.NewRangeExpression(position, NIL, NIL, NIL)
  484. ELSIF Optional(Scanner.Upto) THEN
  485. (* is range expression *)
  486. first := NIL;
  487. IF HasDelimiter() THEN
  488. last := NIL;
  489. step := NIL
  490. ELSIF Optional(Scanner.By) THEN
  491. last := NIL;
  492. step := SimpleExpression()
  493. ELSE
  494. last := SimpleExpression();
  495. IF Optional(Scanner.By) THEN
  496. step := SimpleExpression()
  497. ELSE
  498. step := NIL
  499. END
  500. END;
  501. expression := SyntaxTree.NewRangeExpression(position, first, last, step)
  502. ELSE
  503. expression := SimpleExpression();
  504. IF OptionalB(Scanner.Upto) THEN
  505. (* is range expression *)
  506. first := expression;
  507. IF HasDelimiter() THEN
  508. last := NIL;
  509. step := NIL
  510. ELSIF Optional(Scanner.By) THEN
  511. last := NIL;
  512. step := SimpleExpression()
  513. ELSE
  514. last := SimpleExpression();
  515. IF Optional(Scanner.By) THEN
  516. step := SimpleExpression()
  517. ELSE
  518. step := NIL
  519. END
  520. END;
  521. expression := SyntaxTree.NewRangeExpression(position, first, last, step)
  522. END;
  523. END;
  524. IF Trace THEN E( "RangeExpression" ) END;
  525. RETURN expression
  526. END RangeExpression;
  527. (** Designator = ('self' | 'result' | Identifier)
  528. {'.' Identifier | '[' IndexList ']' | '(' [ExpressionList] ')' | '^'} [Flags].
  529. **)
  530. PROCEDURE Designator( ): SyntaxTree.Designator;
  531. VAR
  532. designator: SyntaxTree.Designator; expressionList: SyntaxTree.ExpressionList;
  533. identifier: SyntaxTree.Identifier; position: Position;
  534. qualifiedIdentifier: SyntaxTree.QualifiedIdentifier;
  535. qualifiedType : SyntaxTree.QualifiedType;
  536. BEGIN
  537. IF Trace THEN S( "Designator" ) END;
  538. position := symbol.position;
  539. IF Optional(Scanner.Self) THEN
  540. designator := SyntaxTree.NewSelfDesignator(position);
  541. ELSIF Optional(Scanner.Result) THEN
  542. designator := SyntaxTree.NewResultDesignator(position);
  543. ELSIF (Token() = Scanner.Address) OR (Token()=Scanner.Size) OR (Token() = Scanner.Alias) THEN
  544. identifier := symbol.identifier;
  545. designator := SyntaxTree.NewIdentifierDesignator(position,identifier);
  546. NextSymbol;
  547. ELSIF (Token() = Scanner.New) THEN
  548. identifier := symbol.identifier;
  549. designator := SyntaxTree.NewIdentifierDesignator(position,identifier);
  550. NextSymbol;
  551. IF Token() # Scanner.LeftParenthesis THEN (* NEW Type () *)
  552. qualifiedIdentifier := QualifiedIdentifier();
  553. qualifiedType := SyntaxTree.NewQualifiedType(qualifiedIdentifier.position, currentScope, qualifiedIdentifier);
  554. IF Mandatory( Scanner.LeftParenthesis ) THEN
  555. expressionList := SyntaxTree.NewExpressionList();
  556. IF ~Optional(Scanner.RightParenthesis) THEN
  557. ExpressionList( expressionList );
  558. Check( Scanner.RightParenthesis )
  559. END;
  560. END;
  561. designator := SyntaxTree.NewBuiltinCallDesignator(position,Global.New, NIL, expressionList);
  562. designator(SyntaxTree.BuiltinCallDesignator).SetReturnType(qualifiedType);
  563. (* special case: NEW Type() *)
  564. END;
  565. ELSE
  566. identifier := Identifier(position);
  567. designator := SyntaxTree.NewIdentifierDesignator(position,identifier);
  568. END;
  569. LOOP
  570. position := symbol.position;
  571. IF OptionalB( Scanner.LeftParenthesis ) THEN
  572. expressionList := SyntaxTree.NewExpressionList();
  573. IF ~Optional( Scanner.RightParenthesis ) THEN
  574. ExpressionList( expressionList );
  575. Check( Scanner.RightParenthesis )
  576. END;
  577. designator := SyntaxTree.NewParameterDesignator( position,designator,expressionList);
  578. ELSIF OptionalB( Scanner.Period ) THEN
  579. IF ~Optional(Scanner.Identifier) THEN (* make sure symbol is read *) END;
  580. position := symbol.position;
  581. CASE symbol.identifierString[0] OF
  582. "a".."z", "A" .. "Z":
  583. (*IF Peek(Scanner.Size) (* special rule: support for SYSTEM.SIZE *) THEN*)
  584. identifier := symbol.identifier;
  585. NextSymbol;
  586. ELSE
  587. identifier := Identifier(position);
  588. END;
  589. designator := SyntaxTree.NewSelectorDesignator(position,designator,identifier);
  590. ELSIF OptionalB( Scanner.LeftBracket ) THEN
  591. expressionList := SyntaxTree.NewExpressionList();
  592. IndexList( expressionList );
  593. Check( Scanner.RightBracket );
  594. designator:= SyntaxTree.NewBracketDesignator( position,designator,expressionList );
  595. ELSIF OptionalB( Scanner.Arrow ) THEN
  596. designator:= SyntaxTree.NewArrowDesignator( position,designator );
  597. ELSE EXIT
  598. END;
  599. END;
  600. IF OptionalB(Scanner.LeftBrace) THEN
  601. designator.SetModifiers(Flags());
  602. END;
  603. (*IF OptionalB(Scanner.Escape) THEN END; (* skip breaking signal *)*)
  604. IF Trace THEN E( "Designator" ) END;
  605. RETURN designator
  606. END Designator;
  607. (** Set = '{' [ RangeExpression {',' RangeExpression} ] '}'. **)
  608. PROCEDURE Set( ): SyntaxTree.Expression;
  609. VAR
  610. set: SyntaxTree.Set;
  611. BEGIN
  612. IF Trace THEN S( "Set" ) END;
  613. set := SyntaxTree.NewSet(symbol.position);
  614. Check(Scanner.LeftBrace);
  615. IF ~Optional(Scanner.RightBrace) THEN
  616. REPEAT
  617. set.elements.AddExpression(RangeExpression())
  618. UNTIL ~Optional(Scanner.Comma);
  619. Check(Scanner.RightBrace);
  620. END;
  621. set.End(symbol.position.end);
  622. IF Trace THEN E( "Set" ) END;
  623. RETURN set
  624. END Set;
  625. (* MathArray = '[' Expression {',' Expression} ']'. *)
  626. PROCEDURE MathArray(): SyntaxTree.Expression;
  627. VAR array: SyntaxTree.MathArrayExpression; element: SyntaxTree.Expression;
  628. BEGIN
  629. array := SyntaxTree.NewMathArrayExpression(symbol.position);
  630. IF ~Optional(Scanner.RightBracket) THEN
  631. REPEAT
  632. element := Expression();
  633. array.elements.AddExpression(element);
  634. UNTIL ~Optional(Scanner.Comma);
  635. Check(Scanner.RightBracket);
  636. END;
  637. RETURN array
  638. END MathArray;
  639. (** Factor = Number | Character | String | 'nil' | 'imag' | 'true' | 'false' | Set
  640. | '(' Expression ')' | '~' Factor | Factor '`' | Designator | MathArray.
  641. | 'SIZE' 'OF' Designator | 'ADDRESS' 'OF' Designator
  642. **)
  643. PROCEDURE Factor( ): SyntaxTree.Expression;
  644. VAR factor: SyntaxTree.Expression; position: Position; operator: LONGINT;
  645. BEGIN
  646. IF Trace THEN S( "Factor" ) END;
  647. position := symbol.position;
  648. CASE Token() OF
  649. | Scanner.Number:
  650. IF (symbol.numberType = Scanner.Integer) THEN
  651. factor := SyntaxTree.NewIntegerValue( position, symbol.integer);
  652. ELSIF (symbol.numberType = Scanner.Hugeint) THEN
  653. factor := SyntaxTree.NewIntegerValue(position, symbol.hugeint);
  654. ELSIF (symbol.numberType = Scanner.Real) OR (symbol.numberType = Scanner.Longreal) THEN
  655. factor := SyntaxTree.NewRealValue( position, symbol.real);
  656. factor(SyntaxTree.RealValue).SetSubtype(symbol.numberType);
  657. ELSE HALT( 100 )
  658. END;
  659. NextSymbol;
  660. | Scanner.Character:
  661. factor := SyntaxTree.NewCharacterValue(position,symbol.character);
  662. NextSymbol;
  663. | Scanner.String:
  664. factor := SyntaxTree.NewStringValue( position, symbol.string );
  665. NextSymbol;
  666. WHILE (Token() = Scanner.String) OR (Token() = Scanner.Character) DO
  667. IF Token() = Scanner.Character THEN
  668. factor(SyntaxTree.StringValue).AppendChar(symbol.character);
  669. ELSE
  670. factor(SyntaxTree.StringValue).Append(symbol.string);
  671. END;
  672. factor.End(symbol.position.end);
  673. NextSymbol;
  674. END;
  675. | Scanner.Nil:
  676. factor := SyntaxTree.NewNilValue( position );
  677. NextSymbol;
  678. | Scanner.Imag:
  679. factor := SyntaxTree.NewComplexValue(position, 0, 1);
  680. factor(SyntaxTree.ComplexValue).SetSubtype(Scanner.Real);
  681. NextSymbol;
  682. | Scanner.True:
  683. factor := SyntaxTree.NewBooleanValue( position, TRUE );
  684. NextSymbol;
  685. | Scanner.False:
  686. factor := SyntaxTree.NewBooleanValue( position, FALSE );
  687. NextSymbol;
  688. | Scanner.LeftBrace:
  689. factor := Set();
  690. | Scanner.LeftParenthesis:
  691. NextSymbol;
  692. factor := Expression();
  693. Check( Scanner.RightParenthesis );
  694. factor.End( symbol.position.end );
  695. | Scanner.Not:
  696. NextSymbol;
  697. factor := Factor();
  698. factor := SyntaxTree.NewUnaryExpression( position, factor, Scanner.Not );
  699. factor.End( symbol.position.end );
  700. | Scanner.Address, Scanner.Size, Scanner.Alias:
  701. operator := Token();
  702. factor := Designator();
  703. IF Optional(Scanner.Of) THEN
  704. factor := Designator();
  705. factor := SyntaxTree.NewUnaryExpression( position, factor, operator );
  706. END;
  707. factor.End (symbol.position.end)
  708. | Scanner.Self, Scanner.Result, Scanner.Identifier, Scanner.New:
  709. factor := Designator();
  710. factor.End( symbol.position.end );
  711. | Scanner.LeftBracket:
  712. NextSymbol;
  713. factor := MathArray();
  714. factor.End(symbol.position.end);
  715. ELSE
  716. Error( position, Basic.ValueStartIncorrectSymbol, "" );
  717. NextSymbol; factor := SyntaxTree.invalidExpression;
  718. END;
  719. (* suffix *)
  720. IF OptionalB(Scanner.Transpose) THEN
  721. IF (factor IS SyntaxTree.UnaryExpression) & (factor(SyntaxTree.UnaryExpression).operator = Scanner.Transpose) THEN
  722. (* transpose operator has higher precedence than not, reevaluate expression: *)
  723. factor := factor(SyntaxTree.UnaryExpression).left;
  724. factor := SyntaxTree.NewUnaryExpression(position,factor,Scanner.Transpose);
  725. factor := SyntaxTree.NewUnaryExpression(position,factor,Scanner.Not);
  726. ELSE
  727. factor := SyntaxTree.NewUnaryExpression(position,factor,Scanner.Transpose);
  728. END;
  729. END;
  730. IF Trace THEN E( "Factor" ) END;
  731. RETURN factor
  732. END Factor;
  733. (** Term = Factor {MulOp Factor}.
  734. MulOp = '*' | '**' | '.*' | '+*' | '/' | '\' | './' | 'div' | 'mod' | '&'.
  735. **)
  736. PROCEDURE Term( ): SyntaxTree.Expression;
  737. VAR term, factor: SyntaxTree.Expression; operator: LONGINT; position: Position;
  738. BEGIN
  739. IF Trace THEN S( "Term" ) END;
  740. position := symbol.position;
  741. term := Factor();
  742. WHILE (TokenB() >= Scanner.Times) & (TokenB() <= Scanner.And) DO
  743. operator := Token();
  744. NextSymbol;
  745. factor := Factor();
  746. term := SyntaxTree.NewBinaryExpression( position, term, factor, operator );
  747. END;
  748. term.End( symbol.position.end );
  749. IF Trace THEN E( "Term" ) END;
  750. RETURN term
  751. END Term;
  752. (** SimpleExpression = ['+'|'-'] Term {AddOp Term}.
  753. AddOp = '+' | '-' | 'or'.
  754. **)
  755. PROCEDURE SimpleExpression( ): SyntaxTree.Expression;
  756. VAR operator: LONGINT; term, expression: SyntaxTree.Expression; position: Position;
  757. BEGIN
  758. IF Trace THEN S( "SimpleExpression" ) END;
  759. position := symbol.position;
  760. IF Peek(Scanner.Plus) OR Peek(Scanner.Minus) THEN (* sign should be part of the factor *)
  761. operator := Token();
  762. NextSymbol;
  763. term := Term();
  764. expression := SyntaxTree.NewUnaryExpression( position, term, operator );
  765. ELSE expression := Term();
  766. END;
  767. WHILE (TokenB() >= Scanner.Or) & (TokenB() <= Scanner.Minus) DO
  768. operator := Token();
  769. NextSymbol;
  770. term := Term();
  771. expression := SyntaxTree.NewBinaryExpression( position, expression, term, operator );
  772. END;
  773. IF Trace THEN E( "SimpleExpression" ) END;
  774. RETURN expression
  775. END SimpleExpression;
  776. (**
  777. Expression = RangeExpression [RelationOp RangeExpression].
  778. RelationOp = '=' | '.=' | '#' | '.#'
  779. | '<' | '.<' | '<=' | '.<=' | '>' | '.>' | '>=' | '.>='
  780. | '??' | '!!' | '<<?' | '>>?'
  781. | 'in' | 'is'
  782. **)
  783. PROCEDURE Expression*( ): SyntaxTree.Expression;
  784. VAR expression, rightExpression: SyntaxTree.Expression; operator: LONGINT; position: Position;
  785. BEGIN
  786. IF Trace THEN S( "Expression" ) END;
  787. position := symbol.position;
  788. expression := RangeExpression();
  789. IF (TokenB() >= Scanner.Equal) & (TokenB() <= Scanner.Is) THEN
  790. operator := Token();
  791. NextSymbol;
  792. rightExpression := RangeExpression();
  793. expression := SyntaxTree.NewBinaryExpression(position, expression, rightExpression, operator );
  794. END;
  795. (*IF OptionalB(Scanner.Escape) THEN END; (* skip breaking escape *)*)
  796. IF Trace THEN E( "Expression" ) END;
  797. RETURN expression
  798. END Expression;
  799. (** Case = RangeExpression {',' RangeExpression} ':' StatementSequence. **)
  800. PROCEDURE Case( caseStatement: SyntaxTree.CaseStatement );
  801. VAR
  802. casePart: SyntaxTree.CasePart;
  803. statements: SyntaxTree.StatementSequence;
  804. element: SyntaxTree.Expression;
  805. BEGIN
  806. IF Trace THEN S( "Case" ) END;
  807. casePart := SyntaxTree.NewCasePart();
  808. CommentCasePart(casePart);
  809. REPEAT
  810. element := RangeExpression();
  811. casePart.elements.AddExpression( element );
  812. UNTIL ~Optional( Scanner.Comma );
  813. Check( Scanner.Colon );
  814. statements := StatementSequence(caseStatement);
  815. casePart.SetStatements( statements );
  816. caseStatement.AddCasePart( casePart );
  817. IF Trace THEN E( "Case" ) END;
  818. END Case;
  819. (** Statement =
  820. [
  821. Designator [':=' Expression |'!' Expression | '?' Expression | '<<' Expresssion | '>>' Expression]
  822. | 'if' Expression 'then' StatementSequence
  823. {'elsif' Expression 'then' StatementSequence}
  824. ['else' StatementSequence]
  825. 'end'
  826. | 'with' Identifier ':' QualifiedIdentifier 'do' StatementSequence
  827. {'|' Identifier ':' QualifiedIdentifier 'do' StatementSequence}
  828. [else StatementSequence]
  829. 'end'
  830. | 'case' Expression 'of' ['|'] Case {'|' Case} ['else' StatementSequence] 'end'
  831. | 'while' Expression 'do' StatementSequence 'end'
  832. | 'repeat' StatementSequence 'until' Expression
  833. | 'for' Identifier ':=' Expression 'to' Expression ['by' Expression] 'do'
  834. StatementSequence 'end'
  835. | 'loop' StatementSequence 'end'
  836. | 'exit'
  837. | 'return' [Expression]
  838. | 'await' Expression
  839. | 'begin' StatementBlock 'end'
  840. | 'code' {any} 'end'
  841. ].
  842. **)
  843. PROCEDURE Statement*( statements: SyntaxTree.StatementSequence; outer: SyntaxTree.Statement): BOOLEAN;
  844. VAR qualifiedIdentifier: SyntaxTree.QualifiedIdentifier; expression: SyntaxTree.Expression; designator: SyntaxTree.Designator; statement: SyntaxTree.Statement;
  845. ifStatement: SyntaxTree.IfStatement; elsifPart: SyntaxTree.IfPart; statementSequence: SyntaxTree.StatementSequence; withStatement: SyntaxTree.WithStatement;
  846. withPart: SyntaxTree.WithPart; caller: SyntaxTree.ProcedureCallStatement;
  847. caseStatement: SyntaxTree.CaseStatement; whileStatement: SyntaxTree.WhileStatement; repeatStatement: SyntaxTree.RepeatStatement; forStatement: SyntaxTree.ForStatement;
  848. identifier: SyntaxTree.Identifier; loopStatement: SyntaxTree.LoopStatement; returnStatement: SyntaxTree.ReturnStatement; awaitStatement: SyntaxTree.AwaitStatement;
  849. qualifiedType: SyntaxTree.QualifiedType; code : SyntaxTree.Code; position: Position; result: BOOLEAN;
  850. commToken: Scanner.Token;
  851. BEGIN
  852. IF Trace THEN S( "Statement" ) END;
  853. CASE Token() OF
  854. | Scanner.Identifier, Scanner.Self, Scanner.Result, Scanner.New:
  855. designator := Designator();
  856. position := symbol.position;
  857. IF OptionalB( Scanner.Becomes ) THEN
  858. expression := Expression();
  859. statement := SyntaxTree.NewAssignment( position, designator, expression,outer );
  860. CommentStatement(statement);
  861. ELSIF PeekB(Scanner.ExclamationMark) OR PeekB(Scanner.Questionmark) OR PeekB(Scanner.LessLess) OR PeekB(Scanner.GreaterGreater) THEN
  862. commToken := Token();
  863. NextSymbol;
  864. expression := Expression();
  865. statement := SyntaxTree.NewCommunicationStatement(position, commToken, designator, expression, outer);
  866. CommentStatement(statement);
  867. ELSE
  868. caller := SyntaxTree.NewProcedureCallStatement(designator.position, designator,outer);
  869. statement := caller;
  870. CommentStatement(statement);
  871. END;
  872. statements.AddStatement( statement );
  873. (*IF OptionalB(Scanner.Escape) THEN END;*)
  874. result := TRUE
  875. | Scanner.If:
  876. NextSymbol;
  877. ifStatement := SyntaxTree.NewIfStatement( symbol.position ,outer);
  878. CommentStatement(ifStatement);
  879. expression := Expression();
  880. ifStatement.ifPart.SetCondition( expression );
  881. Check( Scanner.Then );
  882. statementSequence := StatementSequence(ifStatement);
  883. ifStatement.ifPart.SetStatements( statementSequence );
  884. WHILE Optional( Scanner.Elsif ) DO
  885. elsifPart := SyntaxTree.NewIfPart();
  886. CommentIfPart(elsifPart);
  887. ifStatement.AddElsifPart( elsifPart);
  888. expression := Expression();
  889. elsifPart.SetCondition( expression );
  890. Check( Scanner.Then );
  891. statementSequence := StatementSequence(ifStatement);
  892. elsifPart.SetStatements( statementSequence );
  893. END;
  894. IF Optional( Scanner.Else ) THEN
  895. statementSequence := StatementSequence(ifStatement);
  896. ifStatement.SetElsePart( statementSequence );
  897. END;
  898. Check( Scanner.End ); statements.AddStatement( ifStatement );
  899. result := TRUE
  900. | Scanner.With:
  901. withStatement := SyntaxTree.NewWithStatement( symbol.position ,outer);
  902. CommentStatement(withStatement);
  903. NextSymbol;
  904. REPEAT
  905. identifier := Identifier(position);
  906. IF Optional(Scanner.Period) & Optional(Scanner.Identifier) THEN
  907. Error(position,Diagnostics.Invalid,"forbidden qualified identifier in with statement");
  908. END;
  909. withPart := SyntaxTree.NewWithPart();
  910. CommentWithPart(withPart);
  911. withStatement.AddWithPart(withPart);
  912. designator := SyntaxTree.NewIdentifierDesignator(position,identifier);
  913. withPart.SetVariable( designator );
  914. Check( Scanner.Colon );
  915. qualifiedIdentifier := QualifiedIdentifier();
  916. qualifiedType := SyntaxTree.NewQualifiedType(qualifiedIdentifier.position, currentScope, qualifiedIdentifier);
  917. withPart.SetType(qualifiedType);
  918. Check( Scanner.Do );
  919. statementSequence := StatementSequence(withStatement);
  920. withPart.SetStatements( statementSequence );
  921. UNTIL ~Optional(Scanner.Bar) OR ~CascadedWithSupport;
  922. IF CascadedWithSupport & Optional(Scanner.Else) THEN
  923. statementSequence := StatementSequence(withStatement);
  924. withStatement.SetElsePart(statementSequence);
  925. END;
  926. Check( Scanner.End );
  927. statements.AddStatement( withStatement );
  928. result := TRUE
  929. | Scanner.Case:
  930. caseStatement := SyntaxTree.NewCaseStatement( symbol.position,outer );
  931. CommentStatement(caseStatement);
  932. NextSymbol;
  933. expression := Expression();
  934. Check( Scanner.Of );
  935. caseStatement.SetVariable( expression );
  936. IF Optional(Scanner.Bar) THEN END;
  937. REPEAT
  938. Case(caseStatement)
  939. UNTIL ~Optional(Scanner.Bar);
  940. IF Optional( Scanner.Else ) THEN
  941. statementSequence := StatementSequence(caseStatement);
  942. caseStatement.SetElsePart( statementSequence );
  943. END;
  944. Check( Scanner.End );
  945. statements.AddStatement( caseStatement );
  946. result := TRUE
  947. | Scanner.While:
  948. NextSymbol;
  949. whileStatement := SyntaxTree.NewWhileStatement( symbol.position, outer );
  950. CommentStatement(whileStatement);
  951. expression := Expression();
  952. Check( Scanner.Do );
  953. whileStatement.SetCondition( expression );
  954. statementSequence := StatementSequence(whileStatement);
  955. whileStatement.SetStatements( statementSequence );
  956. Check( Scanner.End );
  957. statements.AddStatement( whileStatement );
  958. result := TRUE
  959. | Scanner.Repeat:
  960. NextSymbol;
  961. repeatStatement := SyntaxTree.NewRepeatStatement( symbol.position, outer );
  962. CommentStatement(repeatStatement);
  963. statementSequence := StatementSequence(repeatStatement);
  964. repeatStatement.SetStatements( statementSequence );
  965. Check( Scanner.Until );
  966. expression := Expression();
  967. repeatStatement.SetCondition( expression );
  968. statements.AddStatement( repeatStatement );
  969. result := TRUE
  970. | Scanner.For:
  971. NextSymbol;
  972. forStatement := SyntaxTree.NewForStatement( symbol.position, outer);
  973. CommentStatement(forStatement);
  974. identifier := Identifier(position);
  975. IF Optional(Scanner.Period) & Optional(Scanner.Identifier) THEN
  976. Error(position,Diagnostics.Invalid,"forbidden non-local counter variable");
  977. END;
  978. designator := SyntaxTree.NewIdentifierDesignator(position,identifier);
  979. forStatement.SetVariable( designator );
  980. Check( Scanner.Becomes );
  981. expression := Expression();
  982. forStatement.SetFrom( expression );
  983. Check( Scanner.To );
  984. expression := Expression();
  985. forStatement.SetTo( expression );
  986. IF Optional( Scanner.By ) THEN
  987. expression := Expression();
  988. forStatement.SetBy( expression );
  989. END;
  990. Check( Scanner.Do );
  991. statementSequence := StatementSequence(forStatement);
  992. forStatement.SetStatements( statementSequence );
  993. Check( Scanner.End );
  994. statements.AddStatement( forStatement );
  995. result := TRUE
  996. | Scanner.Loop:
  997. NextSymbol;
  998. loopStatement := SyntaxTree.NewLoopStatement( symbol.position ,outer);
  999. CommentStatement(loopStatement);
  1000. statementSequence := StatementSequence(loopStatement);
  1001. loopStatement.SetStatements( statementSequence );
  1002. Check( Scanner.End );
  1003. statements.AddStatement( loopStatement );
  1004. result := TRUE;
  1005. | Scanner.Exit:
  1006. NextSymbol;
  1007. statement := SyntaxTree.NewExitStatement( symbol.position, outer);
  1008. CommentStatement(statement);
  1009. statements.AddStatement( statement );
  1010. result := TRUE;
  1011. | Scanner.Return:
  1012. NextSymbol;
  1013. returnStatement := SyntaxTree.NewReturnStatement( symbol.position, outer);
  1014. CommentStatement(returnStatement);
  1015. IF (Token() >= Scanner.Plus) & (Token() <= Scanner.Identifier) THEN
  1016. expression := Expression();
  1017. returnStatement.SetReturnValue( expression );
  1018. END;
  1019. statements.AddStatement( returnStatement );
  1020. result := TRUE;
  1021. | Scanner.Begin:
  1022. NextSymbol; statement := StatementBlock(outer); statements.AddStatement( statement ); Check( Scanner.End );
  1023. result := TRUE;
  1024. | Scanner.Await:
  1025. awaitStatement := SyntaxTree.NewAwaitStatement( symbol.position, outer );
  1026. CommentStatement(awaitStatement);
  1027. NextSymbol;
  1028. expression := Expression();
  1029. awaitStatement.SetCondition( expression );
  1030. statements.AddStatement( awaitStatement );
  1031. result := TRUE
  1032. | Scanner.Code:
  1033. (* assemble *)
  1034. code := Code(outer);
  1035. Check(Scanner.End);
  1036. statements.AddStatement( code );
  1037. result := TRUE
  1038. | Scanner.End: result := FALSE (* end of if, with, case, while, for, loop, or statement sequence *)
  1039. | Scanner.Until: result := FALSE (* end of repeat *)
  1040. | Scanner.Else: result := FALSE (* else of if or case *)
  1041. | Scanner.Elsif: result := FALSE (* elsif of if *)
  1042. | Scanner.Bar: result := FALSE (* next case *)
  1043. | Scanner.Finally: result := FALSE (* end block by finally statement *)
  1044. | Scanner.Semicolon: result := FALSE (* allow the empty statement *)
  1045. (* builtin pseudo procedures are resolved by checker *)
  1046. ELSE
  1047. result := FALSE;
  1048. (*
  1049. IF Lax THEN
  1050. expression := Expression();
  1051. statement := SyntaxTree.NewAssignment( position, NIL, expression,outer );
  1052. statements.AddStatement(statement);
  1053. result := ~error;
  1054. ELSE
  1055. result := FALSE;
  1056. END;
  1057. *)
  1058. END;
  1059. IF Trace THEN E( "Statement" ) END;
  1060. RETURN result
  1061. END Statement;
  1062. (** StatementSequence = Statement {';' Statement}. **)
  1063. PROCEDURE StatementSequence*(outer: SyntaxTree.Statement ): SyntaxTree.StatementSequence;
  1064. VAR statements: SyntaxTree.StatementSequence; b: BOOLEAN;
  1065. BEGIN
  1066. IF Trace THEN S( "StatementSequence" ) END;
  1067. statements := SyntaxTree.NewStatementSequence();
  1068. IF Lax THEN
  1069. WHILE ~Peek(Scanner.Return) & Statement(statements,outer) DO Ignore(Scanner.Semicolon) END;
  1070. IF Peek(Scanner.Return) & Statement(statements,outer) THEN Ignore(Scanner.Semicolon) END; (* return bound to end of statement sequence *)
  1071. ELSE
  1072. REPEAT
  1073. b := Statement( statements,outer )
  1074. UNTIL ~Optional( Scanner.Semicolon );
  1075. END;
  1076. IF Trace THEN E( "StatementSequence" ) END;
  1077. RETURN statements
  1078. END StatementSequence;
  1079. (** StatementBlock = [Flags] StatementSequence. **)
  1080. PROCEDURE StatementBlock(outer: SyntaxTree.Statement): SyntaxTree.StatementBlock;
  1081. VAR block: SyntaxTree.StatementBlock; position: Position;
  1082. BEGIN
  1083. IF Trace THEN S( "StatementBlock" ) END;
  1084. position := symbol.position;
  1085. position.start := position.end;
  1086. block := SyntaxTree.NewStatementBlock( position, outer );
  1087. CommentStatement(block);
  1088. IF Optional( Scanner.LeftBrace ) THEN
  1089. block.SetModifier(Flags());
  1090. END;
  1091. block.SetStatementSequence( StatementSequence(block) );
  1092. IF Trace THEN E( "StatementBlock" ) END;
  1093. RETURN block
  1094. END StatementBlock;
  1095. (** Code = { any \ 'end' \ 'with' } ['with' {('in'|'out') StatementSequence}] . **)
  1096. PROCEDURE Code(outer: SyntaxTree.Statement): SyntaxTree.Code;
  1097. VAR startPos: Position; endPos, i ,len: LONGINT; codeString: Scanner.StringType; code: SyntaxTree.Code;
  1098. end: Scanner.Token; in, out: BOOLEAN; left, right: SyntaxTree.Identifier;
  1099. statements, rules: SyntaxTree.StatementSequence;
  1100. BEGIN
  1101. startPos := symbol.position;
  1102. end := scanner.SkipToEndOfCode(startPos.start, endPos, symbol);
  1103. IF (end = Scanner.End) OR (end = Scanner.With) THEN
  1104. codeString := symbol.string;
  1105. code := SyntaxTree.NewCode(startPos,outer);
  1106. i := 0; len := LEN(codeString^);
  1107. code.SetSourceCode(codeString,len);
  1108. IF (end = Scanner.With) & Mandatory(Scanner.With) THEN
  1109. in := Optional(Scanner.In);
  1110. out := Optional(Scanner.Out);
  1111. WHILE in OR out DO
  1112. statements := StatementSequence(code);
  1113. IF in THEN rules := code.inRules ELSE rules := code.outRules END;
  1114. FOR i := 0 TO statements.Length()-1 DO
  1115. rules.AddStatement(statements.GetStatement(i));
  1116. END;
  1117. in := Optional(Scanner.In);
  1118. out := Optional(Scanner.Out);
  1119. END;
  1120. END;
  1121. END;
  1122. RETURN code;
  1123. END Code;
  1124. (** Body = 'begin' [Flags] StatementSequence ['finally' StatementSequence]
  1125. | 'code' Code. **)
  1126. PROCEDURE Body( scope: SyntaxTree.ProcedureScope ): SyntaxTree.Body;
  1127. VAR body: SyntaxTree.Body; code: SyntaxTree.Code; position: Position; previousScope: SyntaxTree.Scope;
  1128. BEGIN
  1129. previousScope := currentScope;
  1130. currentScope := scope;
  1131. IF Trace THEN S( "Body" ) END;
  1132. IF Peek( Scanner.Code ) THEN
  1133. body := SyntaxTree.NewBody(symbol.position,scope); (* empty body for the time being *)
  1134. (* assemble *)
  1135. code := Code(body);
  1136. body.SetCode(code);
  1137. ELSIF Mandatory( Scanner.Begin ) THEN
  1138. body := SyntaxTree.NewBody(symbol.position,scope);
  1139. IF Optional( Scanner.LeftBrace ) THEN
  1140. body.SetModifier(Flags());
  1141. END;
  1142. position := symbol.position;
  1143. body.SetStatementSequence(StatementSequence(body));
  1144. IF Optional( Scanner.Finally ) THEN
  1145. body.SetFinally(StatementSequence(body));
  1146. END;
  1147. END;
  1148. IF Trace THEN E( "Body" ) END;
  1149. currentScope := previousScope;
  1150. RETURN body
  1151. END Body;
  1152. (** wrapper for a body in records and modules *)
  1153. PROCEDURE BodyProcedure(parentScope: SyntaxTree.Scope): SyntaxTree.Procedure;
  1154. VAR procedureScope: SyntaxTree.ProcedureScope; procedure: SyntaxTree.Procedure;
  1155. BEGIN
  1156. procedureScope := SyntaxTree.NewProcedureScope(parentScope);
  1157. IF parentScope IS SyntaxTree.ModuleScope THEN
  1158. procedure := SyntaxTree.NewProcedure( symbol.position, Global.ModuleBodyName,procedureScope);
  1159. procedure.SetAccess(SyntaxTree.Hidden);
  1160. ELSE
  1161. procedure := SyntaxTree.NewProcedure( symbol.position, Global.RecordBodyName,procedureScope);
  1162. (*! todo: make this a hidden symbol. Problematic when used with paco. *)
  1163. procedure.SetAccess(SyntaxTree.Public + SyntaxTree.Protected + SyntaxTree.Internal);
  1164. END;
  1165. parentScope.AddProcedureDeclaration(procedure);
  1166. procedure.SetType(SyntaxTree.NewProcedureType(SyntaxTree.invalidPosition,parentScope));
  1167. procedure.SetBodyProcedure(TRUE);
  1168. procedureScope.SetBody(Body(procedureScope));
  1169. RETURN procedure
  1170. END BodyProcedure;
  1171. (* ProcedureType = 'procedure' [Flags] [FormalParameters]. *)
  1172. PROCEDURE ProcedureType(position: Position; parentScope: SyntaxTree.Scope): SyntaxTree.ProcedureType;
  1173. VAR procedureType: SyntaxTree.ProcedureType;
  1174. BEGIN
  1175. IF Trace THEN S( "ProcedureType" ) END;
  1176. (* procedure symbol already consumed *)
  1177. procedureType := SyntaxTree.NewProcedureType( position, parentScope);
  1178. IF Optional(Scanner.LeftBrace) THEN
  1179. procedureType.SetModifiers(Flags());
  1180. END;
  1181. IF Optional(Scanner.LeftParenthesis) THEN FormalParameters( procedureType, parentScope) END;
  1182. IF Trace THEN E( "ProcedureType" )
  1183. END;
  1184. RETURN procedureType;
  1185. END ProcedureType;
  1186. (** ObjectType = 'object' | 'object' [Flags] ['(' (QualifiedIdentifier | ArrayType) ')'] DeclarationSequence [Body] 'end' [Identifier] . **)
  1187. PROCEDURE ObjectType(position: Position; name: SyntaxTree.Identifier; parentScope: SyntaxTree.Scope ): SyntaxTree.Type;
  1188. VAR
  1189. objectType: SyntaxTree.RecordType;
  1190. pointerType: SyntaxTree.PointerType;
  1191. recordScope: SyntaxTree.RecordScope;
  1192. qualifiedIdentifier: SyntaxTree.QualifiedIdentifier;
  1193. baseType: SyntaxTree.Type;
  1194. identifier: SyntaxTree.Identifier;
  1195. str: Scanner.StringType;
  1196. type: SyntaxTree.Type;
  1197. modifiers: SyntaxTree.Modifier;
  1198. BEGIN
  1199. IF Trace THEN S( "ObjectType" ) END;
  1200. (* symbol object already consumed *)
  1201. (* generic empty OBJECT type *)
  1202. IF Peek(Scanner.Semicolon) OR Peek(Scanner.RightParenthesis) THEN
  1203. Scanner.GetKeyword(scanner.case,Scanner.Object,identifier);
  1204. qualifiedIdentifier := SyntaxTree.NewQualifiedIdentifier(position,SyntaxTree.invalidIdentifier,identifier);
  1205. type := SyntaxTree.NewQualifiedType( position, parentScope, qualifiedIdentifier );
  1206. RETURN type
  1207. END;
  1208. recordScope := SyntaxTree.NewRecordScope(parentScope);
  1209. pointerType := SyntaxTree.NewPointerType(position,parentScope);
  1210. objectType := SyntaxTree.NewRecordType( position,parentScope,recordScope);
  1211. objectType.IsObject(TRUE);
  1212. objectType.SetPointerType(pointerType);
  1213. pointerType.SetPointerBase(objectType);
  1214. IF Optional(Scanner.LeftBrace) THEN
  1215. modifiers := Flags();
  1216. pointerType.SetModifiers(modifiers);
  1217. END;
  1218. IF Optional( Scanner.LeftParenthesis ) THEN
  1219. IF Optional(Scanner.Array) THEN
  1220. baseType := ArrayType(position, parentScope) (* TODO: correct position? *)
  1221. ELSE
  1222. qualifiedIdentifier := QualifiedIdentifier();
  1223. baseType := SyntaxTree.NewQualifiedType(qualifiedIdentifier.position, parentScope, qualifiedIdentifier)
  1224. END;
  1225. objectType.SetBaseType(baseType);
  1226. Check( Scanner.RightParenthesis )
  1227. END;
  1228. (*
  1229. IF Optional( Scanner.Implements ) THEN
  1230. REPEAT
  1231. qualifiedIdentifier := QualifiedIdentifier()
  1232. UNTIL ~Optional( Scanner.Comma );
  1233. END;
  1234. *)
  1235. IF Optional( Scanner.Semicolon ) THEN
  1236. (*Warning(symbol.position,Diagnostics.Invalid,"no semicolon allowed here");*)
  1237. END;
  1238. DeclarationSequence( recordScope);
  1239. IF Peek(Scanner.Begin) OR Peek(Scanner.Code) THEN
  1240. recordScope.SetBodyProcedure(BodyProcedure(recordScope));
  1241. END;
  1242. Check(Scanner.End);
  1243. IF ExpectThisIdentifier( name ) THEN
  1244. (* check name not always, reflect in EBNF? *)
  1245. END;
  1246. IF Trace THEN E( "ObjectType" ) END;
  1247. RETURN pointerType
  1248. END ObjectType;
  1249. (** CellType = 'cell' [Flags] [PortList] [';'] DeclarationSequence [Body] 'end' [Identifier]
  1250. | 'object'. **)
  1251. PROCEDURE CellType(position: Position; name: SyntaxTree.Identifier; parentScope: SyntaxTree.Scope; isCellNet: BOOLEAN): SyntaxTree.Type;
  1252. VAR
  1253. cellType: SyntaxTree.CellType;
  1254. cellScope: SyntaxTree.CellScope;
  1255. modifiers: SyntaxTree.Modifier;
  1256. qualifiedIdentifier: SyntaxTree.QualifiedIdentifier;
  1257. qualifiedType: SyntaxTree.Type;
  1258. BEGIN
  1259. IF Trace THEN S( "CellType" ) END;
  1260. (* symbol cell already consumed *)
  1261. cellScope := SyntaxTree.NewCellScope(parentScope);
  1262. cellType := SyntaxTree.NewCellType( position, parentScope,cellScope);
  1263. cellType.IsCellNet(isCellNet);
  1264. cellScope.SetOwnerCell(cellType);
  1265. IF Optional(Scanner.Colon) THEN
  1266. qualifiedIdentifier := QualifiedIdentifier();
  1267. qualifiedType := SyntaxTree.NewQualifiedType(qualifiedIdentifier.position, parentScope, qualifiedIdentifier );
  1268. cellType.SetBaseType( qualifiedType );
  1269. END;
  1270. IF Optional(Scanner.LeftBrace) THEN
  1271. modifiers := Flags();
  1272. cellType.SetModifiers(modifiers);
  1273. END;
  1274. IF Optional( Scanner.LeftParenthesis ) THEN
  1275. PortList(cellType,cellScope);
  1276. END;
  1277. IF Optional( Scanner.Semicolon ) THEN END;
  1278. IF Optional(Scanner.Import) THEN ImportList(cellScope) END;
  1279. DeclarationSequence( cellScope);
  1280. IF Peek(Scanner.Begin) OR Peek(Scanner.Code) THEN
  1281. cellScope.SetBodyProcedure(BodyProcedure(cellScope));
  1282. END;
  1283. Check(Scanner.End);
  1284. IF ExpectThisIdentifier( name ) THEN
  1285. (* check name not always, reflect in EBNF? *)
  1286. END;
  1287. IF Trace THEN E( "CellType" ) END;
  1288. RETURN cellType
  1289. END CellType;
  1290. (** PointerType = 'pointer' [Flags] 'to' Type. **)
  1291. PROCEDURE PointerType( position: Position; parentScope: SyntaxTree.Scope ): SyntaxTree.PointerType;
  1292. VAR pointerType: SyntaxTree.PointerType; base: SyntaxTree.Type; modifiers: SyntaxTree.Modifier;
  1293. BEGIN
  1294. IF Trace THEN S( "PointerType" ) END;
  1295. (* pointer symbol already consumed *)
  1296. pointerType := SyntaxTree.NewPointerType( position ,parentScope);
  1297. IF Optional(Scanner.LeftBrace) THEN
  1298. modifiers := Flags();
  1299. pointerType.SetModifiers(modifiers)
  1300. END;
  1301. Check( Scanner.To );
  1302. base := Type(SyntaxTree.invalidIdentifier, parentScope);
  1303. pointerType.SetPointerBase( base );
  1304. IF base IS SyntaxTree.RecordType THEN
  1305. base(SyntaxTree.RecordType).SetPointerType(pointerType);
  1306. END;
  1307. IF Trace THEN E( "PointerType" ) END;
  1308. RETURN pointerType
  1309. END PointerType;
  1310. (**
  1311. RecordType = 'record' [Flags] ['(' QualifiedIdentifier ')'] [VariableDeclaration {';' VariableDeclaration}] 'end'.
  1312. **)
  1313. PROCEDURE RecordType(position: Position; parentScope:SyntaxTree.Scope ): SyntaxTree.RecordType;
  1314. VAR
  1315. recordType: SyntaxTree.RecordType;
  1316. recordScope: SyntaxTree.RecordScope;
  1317. qualifiedIdentifier: SyntaxTree.QualifiedIdentifier; flags: SET; qualifiedType: SyntaxTree.QualifiedType;
  1318. modifier: SyntaxTree.Modifier;
  1319. BEGIN
  1320. IF Trace THEN S( "RecordType" ) END;
  1321. (* record symbol already consumed *)
  1322. flags := {};
  1323. recordScope := SyntaxTree.NewRecordScope(parentScope);
  1324. recordType := SyntaxTree.NewRecordType( position, parentScope, recordScope);
  1325. IF Optional( Scanner.LeftBrace ) THEN
  1326. modifier := Flags();
  1327. recordType.SetModifiers(modifier);
  1328. END;
  1329. IF Optional( Scanner.LeftParenthesis ) THEN
  1330. qualifiedIdentifier := QualifiedIdentifier();
  1331. qualifiedType := SyntaxTree.NewQualifiedType(qualifiedIdentifier.position, parentScope, qualifiedIdentifier );
  1332. recordType.SetBaseType( qualifiedType );
  1333. Check( Scanner.RightParenthesis )
  1334. END;
  1335. IF Lax THEN
  1336. WHILE Peek(Scanner.Identifier) DO VariableDeclaration(recordScope); Ignore(Scanner.Semicolon) END;
  1337. ELSE
  1338. REPEAT
  1339. IF Peek(Scanner.Identifier) THEN VariableDeclaration( recordScope ) END;
  1340. UNTIL ~Optional( Scanner.Semicolon );
  1341. END;
  1342. WHILE Optional(Scanner.Procedure) DO ProcedureDeclaration(recordScope); Ignore(Scanner.Semicolon) END;
  1343. Check( Scanner.End );
  1344. IF Trace THEN E( "RecordType" ) END;
  1345. RETURN recordType
  1346. END RecordType;
  1347. (** ArrayType = 'array' 'of' Type | 'array' Expression {',' Expression} 'of' Type
  1348. | 'array' '[' MathArraySize {',' MathArraySize} ']' ['of' Type].
  1349. MathArraySize = Expression | '*' | '?'.
  1350. **)
  1351. PROCEDURE ArrayType(position: Position; parentScope: SyntaxTree.Scope ): SyntaxTree.Type;
  1352. VAR
  1353. arrayType: SyntaxTree.ArrayType;
  1354. type: SyntaxTree.Type;
  1355. base: SyntaxTree.Type;
  1356. expression: SyntaxTree.Expression;
  1357. PROCEDURE MathArray(): SyntaxTree.Type;
  1358. VAR mathType: SyntaxTree.MathArrayType; base: SyntaxTree.Type;
  1359. BEGIN
  1360. IF Optional(Scanner.Questionmark) THEN
  1361. mathType := SyntaxTree.NewMathArrayType(position,parentScope, SyntaxTree.Tensor);
  1362. ELSIF Optional(Scanner.Times) THEN (* open array *)
  1363. mathType := SyntaxTree.NewMathArrayType(position,parentScope, SyntaxTree.Open);
  1364. ELSE (* size given *)
  1365. mathType := SyntaxTree.NewMathArrayType(position,parentScope, SyntaxTree.Static);
  1366. expression := Expression();
  1367. mathType.SetLength(expression);
  1368. END;
  1369. IF Optional(Scanner.Comma) THEN
  1370. base := MathArray()
  1371. ELSIF Mandatory(Scanner.RightBracket) THEN
  1372. IF Optional( Scanner.Of ) THEN
  1373. base := Type(SyntaxTree.invalidIdentifier , parentScope ); (* base type *)
  1374. END;
  1375. END;
  1376. mathType.SetArrayBase(base);
  1377. RETURN mathType;
  1378. END MathArray;
  1379. BEGIN
  1380. IF Trace THEN S( "ArrayType" ) END;
  1381. (* array symbol already consumed *)
  1382. IF Optional(Scanner.LeftBracket) THEN (* math array *)
  1383. type := MathArray();
  1384. ELSIF Optional( Scanner.Of ) THEN (* open array *)
  1385. arrayType := SyntaxTree.NewArrayType(position,parentScope, SyntaxTree.Open);
  1386. type := arrayType;
  1387. base := Type( SyntaxTree.invalidIdentifier ,parentScope);
  1388. arrayType.SetArrayBase( base )
  1389. ELSE (* static array *)
  1390. arrayType := SyntaxTree.NewArrayType(position,parentScope, SyntaxTree.Static);
  1391. type := arrayType;
  1392. expression := SimpleExpression();
  1393. arrayType.SetLength( expression );
  1394. position := symbol.position;
  1395. IF Optional( Scanner.Comma ) THEN
  1396. base := ArrayType( position,parentScope);
  1397. arrayType.SetArrayBase( base )
  1398. ELSIF Mandatory( Scanner.Of ) THEN
  1399. base := Type(SyntaxTree.invalidIdentifier , parentScope ); (* base type *)
  1400. arrayType.SetArrayBase( base );
  1401. END;
  1402. END;
  1403. IF Trace THEN E( "ArrayType" ) END;
  1404. RETURN type
  1405. END ArrayType;
  1406. (** EnumerationType = 'enum' ['('QualifiedIdentifier')'] IdentifierDefinition ['=' Expression]
  1407. {',' IdentifierDefinition ['=' Expression]} 'end'. *)
  1408. PROCEDURE EnumerationType(position: Position; parentScope: SyntaxTree.Scope): SyntaxTree.Type;
  1409. VAR type: SyntaxTree.EnumerationType; scope: SyntaxTree.EnumerationScope; identifier: SyntaxTree.Identifier;
  1410. qualifiedIdentifier: SyntaxTree.QualifiedIdentifier; qualifiedType: SyntaxTree.QualifiedType; access: SET;
  1411. constant: SyntaxTree.Constant; expression: SyntaxTree.Expression;
  1412. BEGIN
  1413. (* enum symbol already consumed *)
  1414. scope := SyntaxTree.NewEnumerationScope(parentScope);
  1415. type := SyntaxTree.NewEnumerationType(position,parentScope, scope);
  1416. IF Optional( Scanner.LeftParenthesis ) THEN
  1417. qualifiedIdentifier := QualifiedIdentifier();
  1418. qualifiedType := SyntaxTree.NewQualifiedType(qualifiedIdentifier.position, parentScope, qualifiedIdentifier );
  1419. type.SetEnumerationBase( qualifiedType );
  1420. Check( Scanner.RightParenthesis )
  1421. END;
  1422. REPEAT
  1423. IdentifierDefinition(identifier,access,FALSE);
  1424. position := symbol.position;
  1425. constant := SyntaxTree.NewConstant( position, identifier );
  1426. CommentSymbol(constant);
  1427. constant.SetAccess(access);
  1428. IF Optional(Scanner.Equal) THEN
  1429. expression := Expression();
  1430. constant.SetValue( expression );
  1431. END;
  1432. scope.AddConstant( constant );
  1433. UNTIL ~Optional(Scanner.Comma);
  1434. IF Mandatory(Scanner.End) THEN END;
  1435. RETURN type
  1436. END EnumerationType;
  1437. (** PortType = 'port' ('in'|'out') ['(' Expression ')'] *)
  1438. PROCEDURE PortType(position: Position; parentScope: SyntaxTree.Scope): SyntaxTree.Type;
  1439. VAR type: SyntaxTree.Type; direction: LONGINT; sizeExpression: SyntaxTree.Expression;
  1440. BEGIN
  1441. (* port symbol already consumed *)
  1442. IF Optional(Scanner.In) THEN
  1443. direction := SyntaxTree.InPort
  1444. ELSIF Optional(Scanner.Out) THEN
  1445. direction := SyntaxTree.OutPort
  1446. ELSE
  1447. Error(position,Diagnostics.Invalid,"invalid direction, expected IN or OUT");
  1448. END;
  1449. IF Optional(Scanner.LeftParenthesis) THEN
  1450. sizeExpression := Expression();
  1451. IF Mandatory(Scanner.RightParenthesis )THEN END;
  1452. END;
  1453. type := SyntaxTree.NewPortType(position, direction, sizeExpression, parentScope);
  1454. RETURN type
  1455. END PortType;
  1456. (** Type = ArrayType | RecordType | PointerType | ObjectType | CellType | CellnetType | PortType
  1457. | ProcedureType | EnumerationType | QualifiedIdentifier. *)
  1458. PROCEDURE Type( name: SyntaxTree.Identifier; parentScope: SyntaxTree.Scope ): SyntaxTree.Type;
  1459. VAR type: SyntaxTree.Type; qualifiedIdentifier: SyntaxTree.QualifiedIdentifier; position: Position;
  1460. BEGIN
  1461. IF Trace THEN S( "Type" ) END;
  1462. position := symbol.position;
  1463. IF Optional( Scanner.Array ) THEN type := ArrayType( position,parentScope );
  1464. ELSIF Optional( Scanner.Record ) THEN type := RecordType( position,parentScope );
  1465. ELSIF Optional( Scanner.Pointer ) THEN type := PointerType( position,parentScope );
  1466. ELSIF Optional( Scanner.Object ) THEN type := ObjectType( position,name,parentScope );
  1467. ELSIF Optional( Scanner.Cell) THEN type := CellType( position, name, parentScope,FALSE);
  1468. ELSIF Optional( Scanner.CellNet) THEN type := CellType( position, name, parentScope, TRUE);
  1469. ELSIF Optional( Scanner.Port) THEN type := PortType( position, parentScope)
  1470. ELSIF Optional( Scanner.Procedure ) THEN type := ProcedureType( position,parentScope);
  1471. ELSIF Optional( Scanner.Enum ) THEN type := EnumerationType( position,parentScope);
  1472. ELSIF (Token() = Scanner.Address) OR (Token() = Scanner.Size) THEN
  1473. qualifiedIdentifier := SyntaxTree.NewQualifiedIdentifier(position,SyntaxTree.invalidIdentifier, symbol.identifier);
  1474. type := SyntaxTree.NewQualifiedType( qualifiedIdentifier.position, parentScope, qualifiedIdentifier );
  1475. NextSymbol;
  1476. ELSE qualifiedIdentifier := QualifiedIdentifier();
  1477. type := SyntaxTree.NewQualifiedType( qualifiedIdentifier.position, parentScope, qualifiedIdentifier );
  1478. END;
  1479. IF Trace THEN E( "Type" ) END;
  1480. RETURN type
  1481. END Type;
  1482. (** PortDeclaration = Identifier [Flags] {',' Identifier [Flags]}':' Type. **)
  1483. PROCEDURE PortDeclaration(cell: SyntaxTree.CellType; parentScope: SyntaxTree.Scope);
  1484. VAR
  1485. type: SyntaxTree.Type; name: SyntaxTree.Identifier;
  1486. firstParameter, parameter: SyntaxTree.Parameter;
  1487. position: Position; modifiers: SyntaxTree.Modifier;
  1488. BEGIN
  1489. IF Trace THEN S( "PortDeclaration" ) END;
  1490. firstParameter := cell.lastParameter;
  1491. REPEAT
  1492. name := Identifier(position);
  1493. parameter := SyntaxTree.NewParameter(position,cell,name,SyntaxTree.ValueParameter);
  1494. cell.AddParameter(parameter);
  1495. IF Optional(Scanner.LeftBrace) THEN
  1496. modifiers := Flags();
  1497. parameter.SetModifiers(modifiers);
  1498. END;
  1499. UNTIL ~Optional( Scanner.Comma );
  1500. Check( Scanner.Colon );
  1501. type := Type( SyntaxTree.invalidIdentifier, parentScope);
  1502. ASSERT(type # NIL);
  1503. IF firstParameter # NIL THEN parameter := firstParameter.nextParameter ELSE parameter := cell.firstParameter END;
  1504. WHILE parameter # NIL DO
  1505. parameter.SetType( type );
  1506. parameter := parameter.nextParameter;
  1507. END;
  1508. IF Trace THEN E( "PortDeclaration" )
  1509. END;
  1510. END PortDeclaration;
  1511. (** PortList = '(' [PortDeclaration {';' PortDeclaration}] ')'. **)
  1512. PROCEDURE PortList( cell: SyntaxTree.CellType ; parentScope: SyntaxTree.Scope);
  1513. BEGIN
  1514. IF Trace THEN S( "PortList" ) END;
  1515. (* left parenthesis already consumed *)
  1516. IF ~Optional( Scanner.RightParenthesis ) THEN
  1517. IF Lax THEN
  1518. WHILE Peek(Scanner.Identifier) OR Peek(Scanner.Var) OR Peek(Scanner.Const) DO PortDeclaration( cell, parentScope ); Ignore(Scanner.Semicolon) END;
  1519. ELSE
  1520. REPEAT PortDeclaration( cell, parentScope ); UNTIL ~Optional( Scanner.Semicolon );
  1521. END;
  1522. Check( Scanner.RightParenthesis );
  1523. END;
  1524. IF Trace THEN E( "PortList" ) END;
  1525. END PortList;
  1526. (** ParameterDeclaration = ['var'|'const'] Identifier [Flags] ['= Expression] {',' Identifier [Flags] ['= Expression]}':' Type.**)
  1527. PROCEDURE ParameterDeclaration( procedureType: SyntaxTree.ProcedureType ; parentScope: SyntaxTree.Scope);
  1528. VAR
  1529. type: SyntaxTree.Type; name: SyntaxTree.Identifier;
  1530. firstParameter, parameter: SyntaxTree.Parameter; kind: LONGINT; position: Position;
  1531. BEGIN
  1532. IF Trace THEN S( "ParameterDeclaration" ) END;
  1533. IF Optional( Scanner.Var ) THEN (* var parameter *)
  1534. kind := SyntaxTree.VarParameter
  1535. ELSIF Optional( Scanner.Const ) THEN (* const parameter *)
  1536. kind := SyntaxTree.ConstParameter
  1537. ELSIF Token() # Scanner.Identifier THEN
  1538. Error(symbol.position,Scanner.Identifier,"");
  1539. RETURN
  1540. ELSE kind := SyntaxTree.ValueParameter
  1541. END;
  1542. firstParameter := procedureType.lastParameter;
  1543. REPEAT
  1544. name := Identifier(position);
  1545. parameter := SyntaxTree.NewParameter(position,procedureType,name,kind);
  1546. IF Optional(Scanner.LeftBrace) THEN parameter.SetModifiers(Flags()) END;
  1547. procedureType.AddParameter(parameter);
  1548. IF Optional(Scanner.Equal) THEN
  1549. parameter.SetDefaultValue(Expression());
  1550. END
  1551. UNTIL ~Optional( Scanner.Comma );
  1552. Check( Scanner.Colon );
  1553. type := Type( SyntaxTree.invalidIdentifier, parentScope);
  1554. CommentSymbol(parameter);
  1555. ASSERT(type # NIL);
  1556. IF firstParameter # NIL THEN parameter := firstParameter.nextParameter ELSE parameter := procedureType.firstParameter END;
  1557. WHILE parameter # NIL DO
  1558. parameter.SetType( type );
  1559. parameter := parameter.nextParameter;
  1560. END;
  1561. IF Trace THEN E( "ParameterDeclaration" )
  1562. END;
  1563. END ParameterDeclaration;
  1564. (** FormalParameters = '(' [ParameterDeclaration {';' ParameterDeclaration}] ')' [':' [Flags] Type]. **)
  1565. PROCEDURE FormalParameters( procedureType: SyntaxTree.ProcedureType ; parentScope: SyntaxTree.Scope);
  1566. VAR type: SyntaxTree.Type; position: Position;
  1567. BEGIN
  1568. IF Trace THEN S( "FormalParameters" ) END;
  1569. (* left parenthesis already consumed *)
  1570. IF ~Optional( Scanner.RightParenthesis ) THEN
  1571. IF Lax THEN
  1572. WHILE Peek(Scanner.Identifier) OR Peek(Scanner.Const) OR Peek(Scanner.Var) DO
  1573. ParameterDeclaration(procedureType, parentScope); Ignore(Scanner.Semicolon)
  1574. END;
  1575. ELSE
  1576. REPEAT ParameterDeclaration( procedureType, parentScope ); UNTIL ~Optional( Scanner.Semicolon );
  1577. END;
  1578. Check( Scanner.RightParenthesis );
  1579. END;
  1580. IF Optional( Scanner.Colon ) THEN
  1581. position:= symbol.position;
  1582. IF Optional( Scanner.LeftBrace) THEN
  1583. procedureType.SetReturnTypeModifiers(Flags());
  1584. END;
  1585. type := Type(SyntaxTree.invalidIdentifier,parentScope);
  1586. (* formally, any type is permitted as return type. Actually some of them might simply not be usable *)
  1587. procedureType.SetReturnType(type);
  1588. END;
  1589. IF Trace THEN E( "FormalParameters" ) END;
  1590. END FormalParameters;
  1591. (** Flags = '{' [Identifier ['(' Expression ')'|'=' Expression] {',' Identifier ['(' Expression ')' | '=' Expression ] } ] '}'. **)
  1592. PROCEDURE Flags(): SyntaxTree.Modifier;
  1593. VAR identifier: SyntaxTree.Identifier; modifier,list: SyntaxTree.Modifier; position: Position; expression: SyntaxTree.Expression;
  1594. BEGIN
  1595. IF Trace THEN S( "Flags" ) END;
  1596. (* left brace already consumed *)
  1597. list := NIL;
  1598. IF Peek(Scanner.RightBrace) THEN (* empty flags *)
  1599. ELSE
  1600. REPEAT
  1601. position := symbol.position;
  1602. identifier := Identifier(position);
  1603. IF Optional(Scanner.LeftParenthesis) THEN
  1604. expression := Expression();
  1605. Check(Scanner.RightParenthesis)
  1606. ELSIF Optional(Scanner.Equal) THEN
  1607. expression := Expression();
  1608. ELSE
  1609. expression := NIL
  1610. END;
  1611. modifier := SyntaxTree.NewModifier(position,identifier,expression);
  1612. AppendModifier(list,modifier);
  1613. UNTIL ~Optional( Scanner.Comma ) & ~Optional(Scanner.Semicolon);
  1614. END;
  1615. Check(Scanner.RightBrace);
  1616. IF Trace THEN E( "Flags" ) END;
  1617. RETURN list;
  1618. END Flags;
  1619. PROCEDURE SetNextInComment(c: SyntaxTree.Comment; this: ANY);
  1620. BEGIN
  1621. WHILE c # NIL DO
  1622. c.SetItem(this,FALSE);
  1623. c := c.nextComment
  1624. END;
  1625. END SetNextInComment;
  1626. PROCEDURE CommentSymbol(symbol: SyntaxTree.Symbol);
  1627. BEGIN
  1628. IF (recentComment # NIL) (* & (recentComment.nextSymbol = NIL) *) THEN
  1629. symbol.SetComment(recentComment);
  1630. SetNextInComment(recentComment, symbol);
  1631. recentComment := NIL
  1632. END;
  1633. recentLine := scanner.position.line;
  1634. recentCommentItem := symbol;
  1635. END CommentSymbol;
  1636. PROCEDURE CommentStatement(symbol: SyntaxTree.Statement);
  1637. BEGIN
  1638. IF (recentComment # NIL) (* & (recentComment.nextSymbol = NIL) *) THEN
  1639. symbol.SetComment(recentComment);
  1640. SetNextInComment(recentComment, symbol);
  1641. recentComment := NIL
  1642. END;
  1643. recentLine := scanner.position.line;
  1644. recentCommentItem := symbol
  1645. END CommentStatement;
  1646. PROCEDURE CommentCasePart(symbol: SyntaxTree.CasePart);
  1647. BEGIN
  1648. IF (recentComment # NIL) (* & (recentComment.nextSymbol = NIL) *) THEN
  1649. symbol.SetComment(recentComment);
  1650. SetNextInComment(recentComment, symbol);
  1651. recentComment := NIL
  1652. END;
  1653. recentLine := scanner.position.line;
  1654. recentCommentItem := symbol
  1655. END CommentCasePart;
  1656. PROCEDURE CommentIfPart(symbol: SyntaxTree.IfPart);
  1657. BEGIN
  1658. IF (recentComment # NIL) (* & (recentComment.nextSymbol = NIL) *) THEN
  1659. symbol.SetComment(recentComment);
  1660. SetNextInComment(recentComment, symbol);
  1661. recentComment := NIL
  1662. END;
  1663. recentLine := scanner.position.line;
  1664. recentCommentItem := symbol
  1665. END CommentIfPart;
  1666. PROCEDURE CommentWithPart(symbol: SyntaxTree.WithPart);
  1667. BEGIN
  1668. IF (recentComment # NIL) (* & (recentComment.nextSymbol = NIL) *) THEN
  1669. symbol.SetComment(recentComment);
  1670. SetNextInComment(recentComment, symbol);
  1671. recentComment := NIL
  1672. END;
  1673. recentLine := scanner.position.line;
  1674. recentCommentItem := symbol
  1675. END CommentWithPart;
  1676. (** ProcedureDeclaration = 'procedure' ['^'|'&'|'~'|'-'|Flags ['-']] IdentifierDefinition [FormalParameters]';'
  1677. DeclarationSequence [Body] 'end' Identifier.
  1678. Forward declarations ignored.
  1679. **)
  1680. PROCEDURE ProcedureDeclaration( parentScope: SyntaxTree.Scope);
  1681. VAR name: SyntaxTree.Identifier;
  1682. procedure: SyntaxTree.Procedure;
  1683. procedureType: SyntaxTree.ProcedureType;
  1684. procedureScope : SyntaxTree.ProcedureScope;
  1685. access: SET;
  1686. position: Position;
  1687. isConstructor: BOOLEAN;
  1688. isFinalizer: BOOLEAN;
  1689. isInline: BOOLEAN;
  1690. modifiers: SyntaxTree.Modifier;
  1691. forwardDeclaration: BOOLEAN;
  1692. string: Scanner.StringType;
  1693. parameter: SyntaxTree.Parameter;
  1694. qualifiedIdentifier : SyntaxTree.QualifiedIdentifier;
  1695. identifier: SyntaxTree.Identifier;
  1696. kind: LONGINT;
  1697. BEGIN
  1698. IF Trace THEN S( "Procedure" ) END;
  1699. (* symbol procedure has already been consumed *)
  1700. modifiers := NIL;
  1701. isConstructor := FALSE; isFinalizer := FALSE; isInline := FALSE;
  1702. procedureType := SyntaxTree.NewProcedureType(symbol.position, parentScope);
  1703. position := symbol.position;
  1704. IF Optional( Scanner.Arrow) THEN (* ignore forward declarations *)
  1705. forwardDeclaration := TRUE;
  1706. ELSE forwardDeclaration := FALSE;
  1707. END;
  1708. IF Optional( Scanner.And ) THEN (* constructor *)
  1709. isConstructor := TRUE
  1710. ELSIF Optional( Scanner.Not ) THEN (* finalizer *)
  1711. isFinalizer := TRUE
  1712. ELSIF Optional( Scanner.Minus ) THEN (* inline *)
  1713. isInline := TRUE;
  1714. ELSIF Optional( Scanner.LeftBrace) THEN
  1715. modifiers := Flags();
  1716. IF Optional( Scanner.Minus ) THEN (* inline *)
  1717. isInline := TRUE
  1718. END;
  1719. END;
  1720. IF Peek(Scanner.String) OR Peek(Scanner.Character) THEN (* for compatibility with release *)
  1721. Error (position, Diagnostics.Invalid, "Invalid operator declaration: replace 'procedure' by 'operator' keyword!");
  1722. OperatorDeclaration( parentScope );
  1723. RETURN
  1724. END;
  1725. procedureScope := SyntaxTree.NewProcedureScope(parentScope);
  1726. IF Optional(Scanner.LeftParenthesis) THEN (* type bound *)
  1727. IF Optional(Scanner.Var) THEN
  1728. kind := SyntaxTree.VarParameter
  1729. ELSIF Optional(Scanner.Const) THEN
  1730. kind := SyntaxTree.ConstParameter;
  1731. ELSE
  1732. kind := SyntaxTree.ConstParameter;
  1733. END;
  1734. identifier := Identifier(position);
  1735. parameter := SyntaxTree.NewParameter(position, procedureType, identifier, kind);
  1736. Check(Scanner.Colon);
  1737. qualifiedIdentifier := SyntaxTree.NewQualifiedIdentifier(position, SyntaxTree.invalidIdentifier, Identifier(position));
  1738. parameter.SetType(SyntaxTree.NewQualifiedType(position, procedureScope, qualifiedIdentifier));
  1739. Check(Scanner.RightParenthesis);
  1740. procedureType.SetSelfParameter(parameter);
  1741. parameter.SetSelfParameter(TRUE);
  1742. END;
  1743. position:= symbol.position;
  1744. IdentifierDefinition( name, access,TRUE);
  1745. procedure := SyntaxTree.NewProcedure( position, name, procedureScope);
  1746. procedure.SetConstructor(isConstructor);
  1747. procedure.SetFinalizer(isFinalizer);
  1748. procedure.SetInline(isInline);
  1749. CommentSymbol(procedure);
  1750. procedure.SetAccess(access);
  1751. procedureType.SetModifiers(modifiers);
  1752. procedure.SetType(procedureType);
  1753. IF Optional(Scanner.Extern) & MandatoryString(string) THEN procedure.SetExternalName(string); END;
  1754. IF Optional(Scanner.LeftParenthesis) THEN FormalParameters( procedureType, procedureScope) END;
  1755. IF (procedure.externalName = NIL) & ~forwardDeclaration THEN
  1756. IF Lax THEN Ignore(Scanner.Semicolon) ELSE Check( Scanner.Semicolon ) END;
  1757. DeclarationSequence( procedureScope);
  1758. IF Peek(Scanner.Begin) OR Peek(Scanner.Code) THEN
  1759. procedureScope.SetBody(Body(procedureScope));
  1760. END;
  1761. Check(Scanner.End);
  1762. IF ExpectThisIdentifier( name ) THEN END;
  1763. END;
  1764. parentScope.AddProcedureDeclaration( procedure );
  1765. IF Trace THEN E( "Procedure") END;
  1766. END ProcedureDeclaration;
  1767. (** OperatorDeclaration = 'operator' [Flags] ['-'] String ['*'|'-'] FormalParameters ';'
  1768. DeclarationSequence [Body] 'end' String.
  1769. **)
  1770. PROCEDURE OperatorDeclaration(parentScope: SyntaxTree.Scope );
  1771. VAR
  1772. string: Scanner.StringType;
  1773. procedureScope: SyntaxTree.ProcedureScope;
  1774. procedureType: SyntaxTree.ProcedureType;
  1775. operator: SyntaxTree.Operator;
  1776. access: SET;
  1777. i: LONGINT; ch: CHAR; position: Position;
  1778. modifiers: SyntaxTree.Modifier; (* nopov *)
  1779. isInline, forward: BOOLEAN;
  1780. BEGIN
  1781. IF Trace THEN S( "Operator" ) END;
  1782. (* symbol operator already consumed *)
  1783. position := symbol.position;
  1784. forward := Optional(Scanner.Arrow);
  1785. isInline := FALSE;
  1786. IF Optional( Scanner.LeftBrace) THEN
  1787. modifiers := Flags();
  1788. END;
  1789. IF Optional( Scanner.Minus ) THEN (* inline *)
  1790. isInline := TRUE;
  1791. END;
  1792. IF MandatoryString( string ) THEN
  1793. (* copy string to name and check for length. LEN(name)>0, LEN(string)>0 can be presumed *)
  1794. i := 0; WHILE (string^[i] # 0X) DO INC(i) END;
  1795. IF i >= Scanner.MaxIdentifierLength THEN (* string too long to act as operator identifier *)
  1796. Error(symbol.position,Basic.StringTooLong,"");
  1797. END
  1798. END;
  1799. IF Optional( Scanner.Times ) THEN access := SyntaxTree.ReadOnly;
  1800. ELSIF Optional( Scanner.Minus ) THEN access := SyntaxTree.ReadOnly;
  1801. ELSE access := SyntaxTree.Internal;
  1802. END;
  1803. procedureScope := SyntaxTree.NewProcedureScope(parentScope);
  1804. operator := SyntaxTree.NewOperator( symbol.position, SyntaxTree.NewIdentifier(string^), procedureScope);
  1805. CommentSymbol(operator);
  1806. operator.SetAccess(access);
  1807. procedureType := SyntaxTree.NewProcedureType(symbol.position,parentScope);
  1808. IF Mandatory(Scanner.LeftParenthesis) THEN FormalParameters( procedureType, procedureScope ) END;
  1809. procedureType.SetModifiers(modifiers); (* nopov *)
  1810. operator.SetType( procedureType );
  1811. operator.SetInline(isInline);
  1812. IF Lax THEN Ignore(Scanner.Semicolon) ELSE Check( Scanner.Semicolon ) END;
  1813. IF ~forward THEN
  1814. DeclarationSequence( procedureScope );
  1815. IF Peek(Scanner.Begin) OR Peek(Scanner.Code) THEN
  1816. procedureScope.SetBody(Body(procedureScope));
  1817. END;
  1818. IF Mandatory(Scanner.End) & ExpectThisString(string^) THEN END;
  1819. END;
  1820. parentScope.AddProcedureDeclaration(operator);
  1821. IF parentScope IS SyntaxTree.ModuleScope THEN
  1822. parentScope(SyntaxTree.ModuleScope).AddOperator(operator);
  1823. ELSIF parentScope IS SyntaxTree.RecordScope THEN
  1824. parentScope(SyntaxTree.RecordScope).AddOperator(operator);
  1825. ELSE
  1826. Error(position,Diagnostics.Invalid,"Operators only allowed in module or record scope"); (* nopov *)
  1827. END;
  1828. IF Trace THEN EE( "Operator", string^ ) END;
  1829. END OperatorDeclaration;
  1830. (** VariableNameList = IdentifierDefinition [Flags] [':=' Expression | 'extern' String] {',' IdentifierDefinition [Flags] [':=' Expression | 'extern' String] }.**)
  1831. PROCEDURE VariableNameList( scope: SyntaxTree.Scope );
  1832. VAR varname: SyntaxTree.Identifier; position: Position; variable: SyntaxTree.Variable; flags,access: SET; string: Scanner.StringType;
  1833. BEGIN
  1834. IF Trace THEN S( "VariableNameList" ) END;
  1835. REPEAT
  1836. flags := {};
  1837. position := symbol.position;
  1838. IdentifierDefinition( varname, access,TRUE);
  1839. variable := SyntaxTree.NewVariable( position, varname );
  1840. CommentSymbol(variable);
  1841. IF Optional(Scanner.LeftBrace) THEN variable.SetModifiers(Flags()) END;
  1842. IF Optional(Scanner.Becomes) THEN variable.SetInitializer (Expression());
  1843. ELSIF Optional(Scanner.Extern) & MandatoryString(string) THEN variable.SetExternalName(string); END;
  1844. variable.SetAccess(access);
  1845. scope.AddVariable(variable);
  1846. UNTIL ~Optional( Scanner.Comma );
  1847. IF Trace THEN E( "VariableNameList" ) END;
  1848. END VariableNameList;
  1849. (** VariableDeclaration = VariableNameList ':' Type. **)
  1850. PROCEDURE VariableDeclaration(parentScope: SyntaxTree.Scope );
  1851. VAR
  1852. variable, firstVariable: SyntaxTree.Variable; type: SyntaxTree.Type;
  1853. BEGIN
  1854. IF Trace THEN S( "VariableDeclaration" ) END;
  1855. firstVariable := parentScope.lastVariable;
  1856. VariableNameList( parentScope );
  1857. Check( Scanner.Colon );
  1858. type := Type( SyntaxTree.invalidIdentifier, parentScope );
  1859. variable := firstVariable;
  1860. IF firstVariable # NIL THEN variable := firstVariable.nextVariable ELSE variable := parentScope.firstVariable END;
  1861. WHILE variable # NIL DO
  1862. variable.SetType( type );
  1863. variable := variable.nextVariable;
  1864. END;
  1865. IF Trace THEN E( "VariableDeclaration" ) END;
  1866. END VariableDeclaration;
  1867. (** TypeDeclaration = IdentifierDefinition '=' Type.**)
  1868. PROCEDURE TypeDeclaration(parentScope: SyntaxTree.Scope);
  1869. VAR name: SyntaxTree.Identifier; position: Position; type: SyntaxTree.Type; typeDeclaration: SyntaxTree.TypeDeclaration; access: SET;
  1870. BEGIN
  1871. IF Trace THEN S( "TypeDeclaration" ) END;
  1872. position := symbol.position;
  1873. IdentifierDefinition( name, access,FALSE);
  1874. typeDeclaration := SyntaxTree.NewTypeDeclaration( position,name);
  1875. CommentSymbol(typeDeclaration);
  1876. Check( Scanner.Equal );
  1877. type := Type( name , parentScope);
  1878. type.SetTypeDeclaration(typeDeclaration);
  1879. typeDeclaration.SetDeclaredType(type);
  1880. (*
  1881. type.SetName(typeDeclaration.name); (* don't do that: overwrites global names ! *)
  1882. *)
  1883. typeDeclaration.SetAccess(access);
  1884. parentScope.AddTypeDeclaration( typeDeclaration );
  1885. IF Trace THEN E( "TypeDeclaration" ) END;
  1886. END TypeDeclaration;
  1887. (** ConstDeclaration = IdentifierDefinition '=' Expression. **)
  1888. PROCEDURE ConstDeclaration(parentScope: SyntaxTree.Scope );
  1889. VAR name: SyntaxTree.Identifier; position: Position; constant: SyntaxTree.Constant; expression: SyntaxTree.Expression; access: SET;
  1890. BEGIN
  1891. IF Trace THEN S( "ConstDeclaration" ) END;
  1892. IdentifierDefinition( name, access, FALSE);
  1893. position := symbol.position;
  1894. constant := SyntaxTree.NewConstant( position, name );
  1895. CommentSymbol(constant);
  1896. constant.SetAccess(access);
  1897. Check( Scanner.Equal );
  1898. expression := Expression();
  1899. constant.SetValue( expression );
  1900. parentScope.AddConstant( constant );
  1901. IF Trace THEN E( "ConstDeclaration" ) END;
  1902. END ConstDeclaration;
  1903. (** DeclarationSequence = { 'const' [ConstDeclaration] {';' [ConstDeclaration]}
  1904. |'type' [TypeDeclaration] {';' [TypeDeclaration]}
  1905. |'var' [VariableDeclaration] {';' [VariableDeclaration]}
  1906. | ProcedureDeclaration
  1907. | OperatorDeclaration
  1908. | ';'
  1909. }
  1910. **)
  1911. PROCEDURE DeclarationSequence( parentScope: SyntaxTree.Scope);
  1912. VAR previousScope: SyntaxTree.Scope;
  1913. BEGIN
  1914. previousScope := currentScope;
  1915. currentScope := parentScope;
  1916. IF Trace THEN S( "DeclarationSequence" ) END;
  1917. IF Lax THEN
  1918. LOOP
  1919. Ignore(Scanner.Semicolon);
  1920. IF Optional(Scanner.Const) THEN
  1921. WHILE Peek(Scanner.Identifier) DO ConstDeclaration(parentScope); Ignore(Scanner.Semicolon) END;
  1922. ELSIF Optional(Scanner.Type) THEN
  1923. WHILE Peek(Scanner.Identifier) DO TypeDeclaration(parentScope); Ignore(Scanner.Semicolon) END;
  1924. ELSIF Optional(Scanner.Var) THEN
  1925. WHILE Peek(Scanner.Identifier) DO VariableDeclaration(parentScope); Ignore(Scanner.Semicolon); END;
  1926. ELSIF Optional(Scanner.Procedure) THEN
  1927. ProcedureDeclaration(parentScope); Ignore(Scanner.Semicolon)
  1928. ELSIF Optional(Scanner.Operator) THEN
  1929. OperatorDeclaration(parentScope); Ignore(Scanner.Semicolon);
  1930. ELSE
  1931. EXIT
  1932. END;
  1933. END;
  1934. ELSE
  1935. LOOP
  1936. IF Optional( Scanner.Const ) THEN
  1937. REPEAT
  1938. IF Peek(Scanner.Identifier) THEN ConstDeclaration( parentScope ) END
  1939. UNTIL ~Optional( Scanner.Semicolon )
  1940. ELSIF Optional( Scanner.Type ) THEN
  1941. REPEAT
  1942. IF Peek(Scanner.Identifier) THEN TypeDeclaration( parentScope) END
  1943. UNTIL ~Optional( Scanner.Semicolon )
  1944. ELSIF Optional( Scanner.Var ) THEN
  1945. REPEAT
  1946. IF Peek(Scanner.Identifier) THEN VariableDeclaration( parentScope ) END
  1947. UNTIL ~Optional( Scanner.Semicolon )
  1948. ELSIF Optional(Scanner.Operator) THEN
  1949. OperatorDeclaration( parentScope);
  1950. ELSIF Optional( Scanner.Procedure ) THEN
  1951. ProcedureDeclaration( parentScope );
  1952. ELSE EXIT
  1953. END;
  1954. Ignore(Scanner.Semicolon)
  1955. END;
  1956. END;
  1957. currentScope := previousScope;
  1958. IF Trace THEN E( "DeclarationSequence" ) END;
  1959. END DeclarationSequence;
  1960. (**
  1961. ImportList = 'import' Import { ',' Import } ';'.
  1962. Import = Identifier [':=' Identifier] ['in' Identifier].
  1963. **)
  1964. PROCEDURE ImportList( scope: SyntaxTree.Scope );
  1965. VAR alias, name, context: SyntaxTree.Identifier; import: SyntaxTree.Import; position, idPosition: Position;
  1966. BEGIN
  1967. IF Trace THEN S( "ImportList" ) END;
  1968. (* import symbol already consumed *)
  1969. REPEAT
  1970. alias := Identifier(idPosition);
  1971. position := symbol.position;
  1972. IF alias # SyntaxTree.invalidIdentifier THEN
  1973. IF Optional( Scanner.Becomes ) THEN name := Identifier(idPosition) ELSE name := alias; END;
  1974. import := SyntaxTree.NewImport( position, alias, name, TRUE );
  1975. CommentSymbol(import);
  1976. IF Optional(Scanner.In) THEN
  1977. position := symbol.position;
  1978. context := Identifier(idPosition);
  1979. IF context # SyntaxTree.invalidIdentifier THEN import.SetContext(context) END;
  1980. END;
  1981. WITH scope: SyntaxTree.ModuleScope DO
  1982. scope.AddImport( import );
  1983. | scope: SyntaxTree.CellScope DO
  1984. scope.AddImport( import );
  1985. END;
  1986. END;
  1987. UNTIL ~Optional( Scanner.Comma );
  1988. IF Lax THEN Ignore(Scanner.Semicolon) ELSE Check( Scanner.Semicolon ) END;
  1989. IF Trace THEN E( "ImportList" ); END;
  1990. END ImportList;
  1991. (** Module = ('module' | 'cellnet' [Flags]) Identifier ['in' Identifier]';'
  1992. [ImportList] DeclarationSequence [Body]
  1993. 'end' Identifier '.'.
  1994. **)
  1995. PROCEDURE Module*(): SyntaxTree.Module;
  1996. VAR moduleName, context: SyntaxTree.Identifier; module: SyntaxTree.Module; position: Position; isCellNet: BOOLEAN;
  1997. scannerDiagnostics: Diagnostics.Diagnostics; modifiers: SyntaxTree.Modifier; c: SyntaxTree.Comment;
  1998. BEGIN
  1999. IF Trace THEN S( "Module" ) END;
  2000. position := symbol.position;
  2001. moduleScope := SyntaxTree.NewModuleScope(); (* needed to feed in comment already before module starts *)
  2002. currentScope := moduleScope;
  2003. isCellNet := Optional(Scanner.CellNet);
  2004. IF isCellNet OR Mandatory( Scanner.Module ) THEN
  2005. (*c := recentComment; recentComment := NIL;*)
  2006. IF isCellNet & Optional(Scanner.LeftBrace) THEN modifiers := Flags() ELSE modifiers := NIL END;
  2007. moduleName := Identifier(position);
  2008. module := SyntaxTree.NewModule( scanner.source^, position, moduleName, moduleScope, scanner.case );
  2009. CommentSymbol(module);
  2010. (*
  2011. module.SetComment(c);
  2012. SetNextInComment(c, module);
  2013. *)
  2014. IF isCellNet THEN module.SetCellNet(TRUE); module.SetModifiers(modifiers); END;
  2015. module.SetType(SyntaxTree.moduleType);
  2016. IF Optional(Scanner.In) THEN
  2017. position := symbol.position;
  2018. context := Identifier(position);
  2019. module.SetContext(context);
  2020. END;
  2021. IF Lax THEN Ignore(Scanner.Semicolon) ELSE Check(Scanner.Semicolon) END;
  2022. IF ~Peek(Scanner.EndOfText) THEN
  2023. module.SetClosingComment(recentComment);
  2024. SetNextInComment(recentComment, module);
  2025. recentComment := NIL;
  2026. END;
  2027. IF Optional(Scanner.Import) THEN ImportList(moduleScope) END;
  2028. DeclarationSequence( moduleScope);
  2029. IF Peek(Scanner.Begin) OR Peek(Scanner.Code) THEN
  2030. moduleScope.SetBodyProcedure(BodyProcedure(moduleScope)); (* insert empty body procedure if necessary *)
  2031. END;
  2032. Check(Scanner.End);
  2033. IF ExpectThisIdentifier( moduleName ) THEN
  2034. IF Token() # Scanner.Period THEN
  2035. Error( symbol.position, Scanner.Period, "" )
  2036. ELSIF ~error & ~scanner.error THEN (* read ahead to read comments and to check for next module *)
  2037. scanner.ResetCase;
  2038. scannerDiagnostics := NIL;
  2039. scanner.ResetErrorDiagnostics(scannerDiagnostics);
  2040. NextSymbol;
  2041. scanner.ResetErrorDiagnostics(scannerDiagnostics);
  2042. END;
  2043. (*
  2044. (* do not use Check for not reading after end of module *)
  2045. IF ~Peek(Scanner.Module) & ~Peek(Scanner.CellNet) THEN
  2046. SetNextInComment(recentComment,module);
  2047. module.SetClosingComment(recentComment);
  2048. recentComment := NIL;
  2049. END;
  2050. *)
  2051. END;
  2052. END;
  2053. IF Trace THEN E( "Module" ) END;
  2054. RETURN module
  2055. END Module;
  2056. (** check if another module declaration is available after recent module parsing -> for parsing and compiling multiple modules within a single file **)
  2057. PROCEDURE NextModule*(): BOOLEAN;
  2058. BEGIN
  2059. RETURN Peek(Scanner.Module) OR Peek(Scanner.CellNet);
  2060. END NextModule;
  2061. END Parser;
  2062. (* utilities *)
  2063. PROCEDURE AppendModifier(VAR list: SyntaxTree.Modifier; modifier: SyntaxTree.Modifier);
  2064. VAR this, next: SyntaxTree.Modifier;
  2065. BEGIN
  2066. IF list = NIL THEN list := modifier
  2067. ELSE
  2068. this := list;
  2069. next := list.nextModifier;
  2070. WHILE next # NIL DO
  2071. this := next;
  2072. next := this.nextModifier;
  2073. END;
  2074. this.SetNext(modifier);
  2075. END;
  2076. END AppendModifier;
  2077. (** parser retrieval **)
  2078. PROCEDURE NewParser*( scanner: Scanner.Scanner; diagnostics: Diagnostics.Diagnostics): Parser;
  2079. VAR parser: Parser;
  2080. BEGIN
  2081. NEW( parser, scanner, diagnostics ); RETURN parser;
  2082. END NewParser;
  2083. END FoxParser.