\n\n;Complete list of token names\n\n
\nEnd_of_input Op_multiply Op_divide Op_mod Op_add Op_subtract\nOp_negate Op_not Op_less Op_lessequal Op_greater Op_greaterequal\nOp_equal Op_notequal Op_assign Op_and Op_or Keyword_if\nKeyword_else Keyword_while Keyword_print Keyword_putc LeftParen RightParen\nLeftBrace RightBrace Semicolon Comma Identifier Integer\nString\n
\n\n{{task heading|Output Format}}\n\nThe program output should be a sequence of lines, each consisting of the following whitespace-separated fields:\n\n# the line number where the token starts\n# the column number where the token starts\n# the token name\n# the token value (only for
Identifier,
Integer, and
String tokens)\n# the number of spaces between fields is up to you. Neatly aligned is nice, but not a requirement.\n
\n\nThis task is intended to be used as part of a pipeline, with the other compiler tasks - for example:\n
lex < hello.t | parse | gen | vm\n\nOr possibly:\n
lex hello.t lex.out\n
parse lex.out parse.out\n
gen parse.out gen.out\n
vm gen.out\n\n
\nThis implies that the output of this task (the lexical analyzer) should be suitable as input to any of the [[Compiler/syntax_analyzer|Syntax Analyzer task]] programs.\n\n{{task heading|Diagnostics}}\n\nThe following error conditions should be caught:\n\n:::{| class=\"wikitable\"\n|-\n! Error\n! Example\n|-\n| Empty character constant\n|
''\n|-\n| Unknown escape sequence.\n|
\\r\n|-\n| Multi-character constant.\n|
'xx'\n|-\n| End-of-file in comment. Closing comment characters not found.\n|-\n| End-of-file while scanning string literal. Closing string character not found.\n|-\n| End-of-line while scanning string literal. Closing string character not found before end-of-line.\n|-\n| Unrecognized character.\n|
|\n|-\n| Invalid number. Starts like a number, but ends in non-numeric characters.\n|
123abc\n|}\n\n{{task heading|Test Cases}}\n:{| class=\"wikitable\"\n|-\n! Input\n! Output\n|-\n| style=\"vertical-align:top\" |\nTest Case 1:\n
/*\n Hello world\n */\nprint(\"Hello, World!\\n\");\n\n| style=\"vertical-align:top\" |\n
\n 4 1 Keyword_print\n 4 6 LeftParen\n 4 7 String \"Hello, World!\\n\"\n 4 24 RightParen\n 4 25 Semicolon\n 5 1 End_of_input\n
\n\n|-\n| style=\"vertical-align:top\" |\nTest Case 2:\n
/*\n Show Ident and Integers\n */\nphoenix_number = 142857;\nprint(phoenix_number, \"\\n\");\n\n| style=\"vertical-align:top\" |\n
\n 4 1 Identifier phoenix_number\n 4 16 Op_assign\n 4 18 Integer 142857\n 4 24 Semicolon\n 5 1 Keyword_print\n 5 6 LeftParen\n 5 7 Identifier phoenix_number\n 5 21 Comma\n 5 23 String \"\\n\"\n 5 27 RightParen\n 5 28 Semicolon\n 6 1 End_of_input\n
\n\n|-\n| style=\"vertical-align:top\" |\nTest Case 3:\n
/*\n All lexical tokens - not syntactically correct, but that will\n have to wait until syntax analysis\n */\n/* Print */ print /* Sub */ -\n/* Putc */ putc /* Lss */ <\n/* If */ if /* Gtr */ >\n/* Else */ else /* Leq */ <=\n/* While */ while /* Geq */ >=\n/* Lbrace */ { /* Eq */ ==\n/* Rbrace */ } /* Neq */ !=\n/* Lparen */ ( /* And */ &&\n/* Rparen */ ) /* Or */ ||\n/* Uminus */ - /* Semi */ ;\n/* Not */ ! /* Comma */ ,\n/* Mul */ * /* Assign */ =\n/* Div */ / /* Integer */ 42\n/* Mod */ % /* String */ \"String literal\"\n/* Add */ + /* Ident */ variable_name\n/* character literal */ '\\n'\n/* character literal */ '\\\\'\n/* character literal */ ' '\n\n| style=\"vertical-align:top\" |\n
\n 5 16 Keyword_print\n 5 40 Op_subtract\n 6 16 Keyword_putc\n 6 40 Op_less\n 7 16 Keyword_if\n 7 40 Op_greater\n 8 16 Keyword_else\n 8 40 Op_lessequal\n 9 16 Keyword_while\n 9 40 Op_greaterequal\n 10 16 LeftBrace\n 10 40 Op_equal\n 11 16 RightBrace\n 11 40 Op_notequal\n 12 16 LeftParen\n 12 40 Op_and\n 13 16 RightParen\n 13 40 Op_or\n 14 16 Op_subtract\n 14 40 Semicolon\n 15 16 Op_not\n 15 40 Comma\n 16 16 Op_multiply\n 16 40 Op_assign\n 17 16 Op_divide\n 17 40 Integer 42\n 18 16 Op_mod\n 18 40 String \"String literal\"\n 19 16 Op_add\n 19 40 Identifier variable_name\n 20 26 Integer 10\n 21 26 Integer 92\n 22 26 Integer 32\n 23 1 End_of_input\n
\n\n|-\n| style=\"vertical-align:top\" |\nTest Case 4:\n
/*** test printing, embedded \\n and comments with lots of '*' ***/\nprint(42);\nprint(\"\\nHello World\\nGood Bye\\nok\\n\");\nprint(\"Print a slash n - \\\\n.\\n\");\n\n| style=\"vertical-align:top\" |\n
\n 2 1 Keyword_print\n 2 6 LeftParen\n 2 7 Integer 42\n 2 9 RightParen\n 2 10 Semicolon\n 3 1 Keyword_print\n 3 6 LeftParen\n 3 7 String \"\\nHello World\\nGood Bye\\nok\\n\"\n 3 38 RightParen\n 3 39 Semicolon\n 4 1 Keyword_print\n 4 6 LeftParen\n 4 7 String \"Print a slash n - \\\\n.\\n\"\n 4 33 RightParen\n 4 34 Semicolon\n 5 1 End_of_input\n
\n\n|}\n\n;Additional examples\nYour solution should pass all the test cases above and the additional tests found '''[[Compiler/Sample_programs|Here]]'''.\n\n\n{{task heading|Reference}}\nThe C and Python versions can be considered reference implementations.\n\n\n;Related Tasks\n* [[Compiler/syntax_analyzer|Syntax Analyzer task]]\n* [[Compiler/code_generator|Code Generator task]]\n* [[Compiler/virtual_machine_interpreter|Virtual Machine Interpreter task]]\n* [[Compiler/AST_interpreter|AST Interpreter task]]\n
\n
\n\n","language":"00-TASK"},{"code":"with Ada.Text_IO, Ada.Streams.Stream_IO, Ada.Strings.Unbounded, Ada.Command_Line,\n Ada.Exceptions;\nuse Ada.Strings, Ada.Strings.Unbounded, Ada.Streams, Ada.Exceptions;\n\nprocedure Main is\n package IO renames Ada.Text_IO;\n\n package Lexer is\n type Token is (Op_multiply, Op_divide, Op_mod, Op_add, Op_subtract, Op_negate,\n Op_less, Op_lessequal, Op_greater, Op_greaterequal, Op_equal,\n Op_notequal, Op_not, Op_assign, Op_and, Op_or,\n\n LeftParen, RightParen, LeftBrace, RightBrace, Semicolon, Comma,\n\n Keyword_if, Keyword_else, Keyword_while, Keyword_print, Keyword_putc,\n Identifier, Token_Integer, Token_String, End_of_input,\n\n Empty_Char_Error, Invalid_Escape_Error, Multi_Char_Error, EOF_Comment_Error,\n EOF_String_Error, EOL_String_Error, Invalid_Char_Error, Invalid_Num_Error\n );\n\n subtype Operator is Token range Op_multiply .. Op_or;\n subtype Symbol is Token range Token'Succ(Operator'Last) .. Comma;\n subtype Keyword is Token range Token'Succ(Symbol'Last) .. Keyword_putc;\n subtype Error is Token range Empty_Char_Error .. Invalid_Num_Error;\n subtype Operator_or_Error is Token\n with Static_Predicate => Operator_or_Error in Operator | Error;\n\n subtype Whitespace is Character\n with Static_Predicate => Whitespace in ' ' | ASCII.HT | ASCII.CR | ASCII.LF;\n\n Lexer_Error : exception;\n Invalid_Escape_Code : constant Character := ASCII.NUL;\n\n procedure run(input : Stream_IO.File_Type);\n end Lexer;\n\n package body Lexer is\n use type Stream_IO.Count;\n\n procedure run(input : Stream_IO.File_Type) is\n type State is (State_Start, State_Identifier, State_Integer, State_Char, State_String,\n State_Comment);\n curr_state : State := State_Start;\n curr_char : Character;\n curr_col, curr_row, token_col, token_row : Positive := 1;\n token_text : Unbounded_String := Unbounded.Null_Unbounded_String;\n\n function look_ahead return Character is\n next_char : Character := ASCII.LF;\n begin\n if not Stream_IO.End_Of_File(input) then\n next_char := Character'Input(Stream_IO.Stream(input));\n Stream_IO.Set_Index(input, Stream_IO.Index(input) - 1);\n end if;\n return next_char;\n end look_ahead;\n\n procedure next_char is\n next : Character := Character'Input(Stream_IO.Stream(input));\n begin\n curr_col := curr_col + 1;\n if curr_char = ASCII.LF then\n curr_row := curr_row + 1;\n curr_col := 1;\n end if;\n curr_char := next;\n end next_char;\n\n procedure print_token(tok : Token; text : String := \"\") is\n procedure raise_error(text : String) is\n begin\n raise Lexer_Error with \"Error: \" & text;\n end;\n begin\n IO.Put(token_row'Image & ASCII.HT & token_col'Image & ASCII.HT);\n case tok is\n when Operator | Symbol | Keyword | End_of_input => IO.Put_Line(tok'Image);\n when Token_Integer => IO.Put_Line(\"INTEGER\" & ASCII.HT & text);\n when Token_String => IO.Put_Line(\"STRING\" & ASCII.HT & ASCII.Quotation & text & ASCII.Quotation);\n when Identifier => IO.Put_Line(tok'Image & ASCII.HT & text);\n when Empty_Char_Error => raise_error(\"empty character constant\");\n when Invalid_Escape_Error => raise_error(\"unknown escape sequence: \" & text);\n when Multi_Char_Error => raise_error(\"multi-character constant: \" & text);\n when EOF_Comment_Error => raise_error(\"EOF in comment\");\n when EOF_String_Error => raise_error(\"EOF in string\");\n when EOL_String_Error => raise_error(\"EOL in string\");\n when Invalid_Char_Error => raise_error(\"invalid character: \" & curr_char);\n when Invalid_Num_Error => raise_error(\"invalid number: \" & text);\n end case;\n end print_token;\n\n procedure lookahead_choose(determiner : Character; a, b : Operator_or_Error) is\n begin\n if look_ahead = determiner then\n print_token(a);\n next_char;\n else\n print_token(b);\n end if;\n end lookahead_choose;\n\n function to_escape_code(c : Character) return Character is\n begin\n case c is\n when 'n' => return ASCII.LF;\n when '\\' => return '\\';\n when others =>\n print_token(Invalid_Escape_Error, ASCII.Back_Slash & c);\n return Invalid_Escape_Code;\n end case;\n end to_escape_code;\n begin\n curr_char := Character'Input(Stream_IO.Stream(input));\n loop\n case curr_state is\n when State_Start =>\n token_col := curr_col;\n token_row := curr_row;\n case curr_char is\n when '*' => print_token(Op_multiply);\n when '/' =>\n if look_ahead = '*' then\n next_char;\n curr_state := State_Comment;\n else\n print_token(Op_divide);\n end if;\n when '%' => print_token(Op_mod);\n when '+' => print_token(Op_add);\n when '-' => print_token(Op_subtract);\n when '(' => print_token(LeftParen);\n when ')' => print_token(RightParen);\n when '{' => print_token(LeftBrace);\n when '}' => print_token(RightBrace);\n when ';' => print_token(Semicolon);\n when ',' => print_token(Comma);\n when '<' => lookahead_choose('=', Op_lessequal, Op_less);\n when '>' => lookahead_choose('=', Op_greaterequal, Op_greater);\n when '!' => lookahead_choose('=', Op_notequal, Op_not);\n when '=' => lookahead_choose('=', Op_equal, Op_assign);\n when '&' => lookahead_choose('&', Op_and, Invalid_Char_Error);\n when '|' => lookahead_choose('|', Op_or, Invalid_Char_Error);\n when 'a' .. 'z' | 'A' .. 'Z' | '_' =>\n Unbounded.Append(token_text, curr_char);\n curr_state := State_Identifier;\n when '0' .. '9' =>\n Unbounded.Append(token_text, curr_char);\n curr_state := State_Integer;\n when ''' => curr_state := State_Char;\n when ASCII.Quotation => curr_state := State_String;\n when Whitespace => null;\n when others => null;\n end case;\n next_char;\n\n when State_Identifier =>\n case curr_char is\n when 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' =>\n Unbounded.Append(token_text, curr_char);\n next_char;\n when others =>\n if token_text = \"if\" then\n print_token(Keyword_if);\n elsif token_text = \"else\" then\n print_token(Keyword_else);\n elsif token_text = \"while\" then\n print_token(Keyword_while);\n elsif token_text = \"print\" then\n print_token(Keyword_print);\n elsif token_text = \"putc\" then\n print_token(Keyword_putc);\n else\n print_token(Identifier, To_String(token_text));\n end if;\n Unbounded.Set_Unbounded_String(token_text, \"\");\n curr_state := State_Start;\n end case;\n\n when State_Integer =>\n case curr_char is\n when '0' .. '9' =>\n Unbounded.Append(token_text, curr_char);\n next_char;\n when 'a' .. 'z' | 'A' .. 'Z' | '_' =>\n print_token(Invalid_Num_Error, To_String(token_text));\n when others =>\n print_token(Token_Integer, To_String(token_text));\n Unbounded.Set_Unbounded_String(token_text, \"\");\n curr_state := State_Start;\n end case;\n\n when State_Char =>\n case curr_char is\n when ''' =>\n if Unbounded.Length(token_text) = 0 then\n print_token(Empty_Char_Error);\n elsif Unbounded.Length(token_text) = 1 then\n print_token(Token_Integer, Character'Pos(Element(token_text, 1))'Image);\n else\n print_token(Multi_Char_Error, To_String(token_text));\n end if;\n Set_Unbounded_String(token_text, \"\");\n curr_state := State_Start;\n when '\\' =>\n Unbounded.Append(token_text, to_escape_code(look_ahead));\n next_char;\n when others => Unbounded.Append(token_text, curr_char);\n end case;\n next_char;\n\n when State_String =>\n case curr_char is\n when ASCII.Quotation =>\n print_token(Token_String, To_String(token_text));\n Set_Unbounded_String(token_text, \"\");\n curr_state := State_Start;\n when '\\' =>\n if to_escape_code(look_ahead) /= Invalid_Escape_Code then\n Unbounded.Append(token_text, curr_char);\n end if;\n when ASCII.LF | ASCII.CR => print_token(EOL_String_Error);\n when others => Unbounded.Append(token_text, curr_char);\n end case;\n next_char;\n\n when State_Comment =>\n case curr_char is\n when '*' =>\n if look_ahead = '/' then\n next_char;\n curr_state := State_Start;\n end if;\n when others => null;\n end case;\n next_char;\n end case;\n end loop;\n exception\n when error : Stream_IO.End_Error =>\n if curr_state = State_String then\n print_token(EOF_String_Error);\n else\n print_token(End_of_input);\n end if;\n when error : Lexer.Lexer_Error => IO.Put_Line(Exception_Message(error));\n end run;\n end Lexer;\n\n source_file : Stream_IO.File_Type;\nbegin\n if Ada.Command_Line.Argument_Count < 1 then\n IO.Put_Line(\"usage: lex [filename]\");\n return;\n end if;\n Stream_IO.Open(source_file, Stream_IO.In_File, Ada.Command_Line.Argument(1));\n Lexer.run(source_file);\nexception\n when error : others => IO.Put_Line(\"Error: \" & Exception_Message(error));\nend Main;\n","language":"Ada"},{"code":"BEGIN\n # implement C-like getchar, where EOF and EOLn are \"characters\" (-1 and 10 resp.). #\n INT eof = -1, eoln = 10;\n BOOL eof flag := FALSE;\n STRING buf := \"\";\n INT col := 1;\n INT line := 0;\n on logical file end (stand in, (REF FILE f)BOOL: eof flag := TRUE);\n PROC getchar = INT:\n IF eof flag THEN eof\n ELIF col = UPB buf THEN col +:= 1; eoln\n ELIF col > UPB buf THEN IF line > 0 THEN read(newline) FI;\n line +:= 1;\n read(buf);\n IF eof flag THEN col := 1; eof\n ELSE col := 0; getchar\n FI\n ELSE col +:= 1; ABS buf[col]\n FI;\n PROC nextchar = INT: IF eof flag THEN eof ELIF col >= UPB buf THEN eoln ELSE ABS buf[col+1] FI;\n\n PROC is blank = (INT ch) BOOL: ch = 0 OR ch = 9 OR ch = 10 OR ch = 13 OR ch = ABS \" \";\n PROC is digit = (INT ch) BOOL: ch >= ABS \"0\" AND ch <= ABS \"9\";\n PROC is ident start = (INT ch) BOOL: ch >= ABS \"A\" AND ch <= ABS \"Z\" OR\n ch >= ABS \"a\" AND ch <= ABS \"z\" OR\n ch = ABS \"_\";\n PROC is ident = (INT ch) BOOL: is ident start(ch) OR is digit(ch);\n\n PROC ident or keyword = (INT start char) VOID:\n BEGIN\n STRING w := REPR start char;\n INT start col = col;\n WHILE is ident (next char) DO w +:= REPR getchar OD;\n IF w = \"if\" THEN output2(\"Keyword_if\", start col)\n ELIF w = \"else\" THEN output2(\"Keyword_else\", start col)\n ELIF w = \"while\" THEN output2(\"Keyword_while\", start col)\n ELIF w = \"print\" THEN output2(\"Keyword_print\", start col)\n ELIF w = \"putc\" THEN output2(\"Keyword_putc\", start col)\n ELSE output2(\"Identifier \" + w, start col)\n FI\n END;\n PROC char = VOID:\n BEGIN\n INT start col = col;\n INT ch := getchar;\n IF ch = ABS \"'\" THEN error(\"Empty character constant\")\n ELIF ch = ABS \"\\\" THEN ch := getchar;\n IF ch = ABS \"n\" THEN ch := 10\n ELIF ch = ABS \"\\\" THEN SKIP\n ELSE error(\"Unknown escape sequence. \\\" + REPR ch)\n FI\n FI;\n IF nextchar /= ABS \"'\" THEN error(\"Multi-character constant.\") FI;\n getchar;\n output2(\"Integer \" + whole(ch, 0), start col)\n END;\n PROC string = VOID:\n BEGIN\n INT start col = col;\n STRING s := \"\"\"\";\n WHILE INT ch := getchar; ch /= ABS \"\"\"\"\n DO\n IF ch = eoln THEN error(\"End-of-line while scanning string literal. Closing string character not found before end-of-line.\")\n ELIF ch = eof THEN error(\"End-of-file while scanning string literal. Closing string character not found.\")\n ELIF ch = ABS \"\\\" THEN s +:= REPR ch; ch := getchar;\n IF ch /= ABS \"\\\" AND ch /= ABS \"n\" THEN error(\"Unknown escape sequence. \\\" + REPR ch) FI;\n s +:= REPR ch\n ELSE s +:= REPR ch\n FI\n OD;\n output2(\"String \" + s + \"\"\"\", start col)\n END;\n PROC comment = VOID:\n BEGIN\n WHILE INT ch := getchar; NOT (ch = ABS \"*\" AND nextchar = ABS \"/\")\n DO IF ch = eof THEN error(\"End-of-file in comment. Closing comment characters not found.\") FI\n OD;\n getchar\n END;\n PROC number = (INT first digit) VOID:\n BEGIN\n INT start col = col;\n INT n := first digit - ABS \"0\";\n WHILE is digit (nextchar) DO\n INT u := getchar - ABS \"0\";\n IF LENG n * 10 + LENG u > max int THEN error(\"Integer too big\") FI;\n n := n * 10 + u\n OD;\n IF is ident start (nextchar) THEN error(\"Invalid number. Starts like a number, but ends in non-numeric characters.\") FI;\n output2(\"Integer \" + whole(n, 0), start col)\n END;\n\n PROC output = (STRING s) VOID: output2(s, col);\n PROC output2 = (STRING s, INT col) VOID: print((whole(line,-8), whole(col,-8), \" \", s, newline));\n\n PROC if follows = (CHAR second, STRING longer, shorter) VOID:\n IF nextchar = ABS second\n THEN output(longer); getchar\n ELSE output(shorter)\n FI;\n PROC error = (STRING s)VOID: (put(stand error, (\"At \", whole(line,0), \":\", whole(col,0), \" \", s, new line)); stop);\n PROC unrecognized = (INT char) VOID: error(\"Unrecognized character \" + REPR char);\n PROC double char = (INT first, STRING op) VOID:\n IF nextchar /= first THEN unrecognized(first)\n ELSE output2(op, col-1); getchar\n FI;\n\n WHILE INT ch := getchar; ch /= eof\n DO\n IF is blank(ch) THEN SKIP\n ELIF ch = ABS \"(\" THEN output(\"LeftParen\")\n ELIF ch = ABS \")\" THEN output(\"RightParen\")\n ELIF ch = ABS \"{\" THEN output(\"LeftBrace\")\n ELIF ch = ABS \"}\" THEN output(\"RightBrace\")\n ELIF ch = ABS \";\" THEN output(\"Semicolon\")\n ELIF ch = ABS \",\" THEN output(\"Comma\")\n ELIF ch = ABS \"*\" THEN output(\"Op_multiply\")\n ELIF ch = ABS \"/\" THEN IF next char = ABS \"*\" THEN comment\n ELSE output(\"Op_divide\")\n FI\n ELIF ch = ABS \"%\" THEN output(\"Op_mod\")\n ELIF ch = ABS \"+\" THEN output(\"Op_add\")\n ELIF ch = ABS \"-\" THEN output(\"Op_subtract\")\n ELIF ch = ABS \"<\" THEN if follows(\"=\", \"Op_lessequal\", \"Op_less\")\n ELIF ch = ABS \">\" THEN if follows(\"=\", \"Op_greaterequal\", \"Op_greater\")\n ELIF ch = ABS \"=\" THEN if follows(\"=\", \"Op_equal\", \"Op_assign\")\n ELIF ch = ABS \"!\" THEN if follows(\"=\", \"Op_notequal\", \"Op_not\")\n ELIF ch = ABS \"&\" THEN double char(ch, \"Op_and\")\n ELIF ch = ABS \"|\" THEN double char(ch, \"Op_or\")\n ELIF is ident start (ch) THEN ident or keyword (ch)\n ELIF ch = ABS \"\"\"\" THEN string\n ELIF ch = ABS \"'\" THEN char\n ELIF is digit(ch) THEN number(ch)\n ELSE unrecognized(ch)\n FI\n OD;\n output(\"End_Of_Input\")\nEND\n","language":"ALGOL-68"},{"code":"begin\n %lexical analyser %\n % Algol W strings are limited to 256 characters in length so we limit source lines %\n % and tokens to 256 characters %\n\n integer lineNumber, columnNumber;\n string(256) line;\n string(256) tkValue;\n integer tkType, tkLine, tkColumn, tkLength, tkIntegerValue;\n logical tkTooLong;\n string(1) currChar;\n string(1) newlineChar;\n\n integer LINE_WIDTH, MAX_TOKEN_LENGTH, MAXINTEGER_OVER_10, MAXINTEGER_MOD_10;\n integer tOp_multiply , tOp_divide , tOp_mod , tOp_add\n , tOp_subtract , tOp_negate , tOp_less , tOp_lessequal\n , tOp_greater , tOp_greaterequal , tOp_equal , tOp_notequal\n , tOp_not , tOp_assign , tOp_and , tOp_or\n , tLeftParen , tRightParen , tLeftBrace , tRightBrace\n , tSemicolon , tComma , tKeyword_if , tKeyword_else\n , tKeyword_while , tKeyword_print , tKeyword_putc , tIdentifier\n , tInteger , tString , tEnd_of_input , tComment\n ;\n\n string(16) array tkName ( 1 :: 32 );\n\n % reports an error %\n procedure lexError( string(80) value message ); begin\n integer errorPos;\n write( i_w := 1, s_w := 0, \"**** Error at(\", lineNumber, \",\", columnNumber, \"): \" );\n errorPos := 0;\n while errorPos < 80 and message( errorPos // 1 ) not = \".\" do begin\n writeon( s_w := 0, message( errorPos // 1 ) );\n errorPos := errorPos + 1\n end while_not_at_end_of_message ;\n writeon( s_w := 0, \".\" )\n end lexError ;\n\n % gets the next source character %\n procedure nextChar ; begin\n if columnNumber = LINE_WIDTH then begin\n currChar := newlineChar;\n columnNumber := columnNumber + 1\n end\n else if columnNumber > LINE_WIDTH then begin\n readcard( line );\n columnNumber := 1;\n if not XCPNOTED(ENDFILE) then lineNumber := lineNumber + 1;\n currChar := line( 0 // 1 )\n end\n else begin\n currChar := line( columnNumber // 1 );\n columnNumber := columnNumber + 1\n end\n end nextChar ;\n\n % gets the next token, returns the token type %\n integer procedure nextToken ; begin\n\n % returns true if currChar is in the inclusive range lowerValue to upperValue %\n % false otherwise %\n logical procedure range( string(1) value lowerValue, upperValue ) ; begin\n currChar >= lowerValue and currChar <= upperValue\n end range ;\n\n % returns true if the current character can start an identifier, false otherwise %\n logical procedure identifierStartChar ; begin\n currChar = \"_\" or range( \"a\", \"z\" ) or range( \"A\", \"Z\" )\n end identifierStartChar ;\n\n % add the current character to the token and get the next %\n procedure addAndNextChar ; begin\n if tkLength >= MAX_TOKEN_LENGTH then tkTooLong := true\n else begin\n tkValue( tkLength // 1 ) := currChar;\n tkLength := tkLength + 1\n end if_symbol_not_too_long ;\n nextChar\n end % addAndNextChar % ;\n\n % handle a single character token %\n procedure singleCharToken( integer value tokenType ) ; begin\n tkType := tokenType;\n nextChar\n end singleCharToken ;\n\n % handle a doubled character token: && or || %\n procedure doubleCharToken( integer value tokenType ) ; begin\n string(1) firstChar;\n firstChar := currChar;\n tkType := tokenType;\n nextChar;\n if currChar = firstChar then nextChar\n else % the character wasn't doubled % lexError( \"Unrecognised character.\" );\n end singleCharToken ;\n\n % handle an operator or operator= token %\n procedure opOrOpEqual( integer value opToken, opEqualToken ) ; begin\n tkType := opToken;\n nextChar;\n if currChar = \"=\" then begin\n % have operator= %\n tkType := opEqualToken;\n nextChar\n end if_currChar_is_equal ;\n end opOrOpEqual ;\n\n % handle a / operator or /* comment %\n procedure divideOrComment ; begin\n tkType := tOp_divide;\n nextChar;\n if currChar = \"*\" then begin\n % have a comment %\n logical moreComment;\n tkType := tComment;\n moreComment := true;\n while moreComment do begin\n nextChar;\n while currChar not = \"*\" and not XCPNOTED(ENDFILE) do nextChar;\n while currChar = \"*\" and not XCPNOTED(ENDFILE) do nextChar;\n moreComment := ( currChar not = \"/\" and not XCPNOTED(ENDFILE) )\n end while_more_comment ;\n if not XCPNOTED(ENDFILE)\n then nextChar\n else lexError( \"End-of-file in comment.\" )\n end if_currChar_is_star ;\n end divideOrComment ;\n\n % handle an indentifier or keyword %\n procedure identifierOrKeyword ; begin\n tkType := tIdentifier;\n while identifierStartChar or range( \"0\", \"9\" ) do addAndNextChar;\n % there are only 5 keywords, so we just test each in turn here %\n if tkValue = \"if\" then tkType := tKeyword_if\n else if tkValue = \"else\" then tkType := tKeyword_else\n else if tkValue = \"while\" then tkType := tKeyword_while\n else if tkValue = \"print\" then tkType := tKeyword_print\n else if tkValue = \"putc\" then tkType := tKeyword_putc;\n if tkType not = tIdentifier then tkValue := \"\";\n end identifierOrKeyword ;\n\n % handle an integer literal %\n procedure integerLiteral ; begin\n logical overflowed;\n integer digit;\n overflowed := false;\n tkType := tInteger;\n while range( \"0\", \"9\" ) do begin\n digit := ( decode( currChar ) - decode( \"0\" ) );\n if tkIntegerValue > MAXINTEGER_OVER_10 then overflowed := true\n else if tkIntegerValue = MAXINTEGER_OVER_10\n and digit > MAXINTEGER_MOD_10 then overflowed := true\n else begin\n tkIntegerValue := tkIntegerValue * 10;\n tkIntegerValue := tkIntegerValue + digit;\n end;\n nextChar\n end while_have_a_digit ;\n if overflowed then lexError( \"Number too large.\" );\n if identifierStartChar then lexError( \"Number followed by letter or underscore.\" );\n end integerLiteral ;\n\n % handle a char literal %\n procedure charLiteral ; begin\n nextChar;\n if currChar = \"'\" or currChar = newlineChar then lexError( \"Invalid character constant.\" )\n else if currChar = \"\\\" then begin\n % have an escape %\n nextChar;\n if currChar = \"n\" then currChar := newlineChar\n else if currChar not = \"\\\" then lexError( \"Unknown escape sequence.\" )\n end;\n tkType := tInteger;\n tkIntegerValue := decode( currChar );\n % should have a closing quoute next %\n nextChar;\n if currChar not = \"'\"\n then lexError( \"Multi-character constant.\" )\n else nextChar\n end charLiteral ;\n\n % handle a string literal %\n procedure stringLiteral ; begin\n tkType := tString;\n tkValue( 0 // 1 ) := currChar;\n tkLength := 1;\n nextChar;\n while currChar not = \"\"\"\" and currChar not = newlineChar and not XCPNOTED(ENDFILE) do addAndNextChar;\n if currChar = newlineChar then lexError( \"End-of-line while scanning string literal.\" )\n else if XCPNOTED(ENDFILE) then lexError( \"End-of-file while scanning string literal.\" )\n else % currChar must be \"\"\"\" % addAndNextChar\n end stringLiteral ;\n\n while begin\n % skip white space %\n while ( currChar = \" \" or currChar = newlineChar ) and not XCPNOTED(ENDFILE) do nextChar;\n % get the token %\n tkLine := lineNumber;\n tkColumn := columnNumber;\n tkValue := \"\";\n tkLength := 0;\n tkIntegerValue := 0;\n tkTooLong := false;\n if XCPNOTED(ENDFILE) then tkType := tEnd_of_input\n else if currChar = \"*\" then singleCharToken( tOp_multiply )\n else if currChar = \"/\" then divideOrComment\n else if currChar = \"%\" then singleCharToken( tOp_mod )\n else if currChar = \"+\" then singleCharToken( tOp_add )\n else if currChar = \"-\" then singleCharToken( tOp_subtract )\n else if currChar = \"<\" then opOrOpEqual( tOp_less, tOp_lessequal )\n else if currChar = \">\" then opOrOpEqual( tOp_greater, tOp_greaterequal )\n else if currChar = \"=\" then opOrOpEqual( tOp_assign, tOp_equal )\n else if currChar = \"!\" then opOrOpEqual( tOp_not, tOp_notequal )\n else if currChar = \"&\" then doubleCharToken( tOp_and )\n else if currChar = \"|\" then doubleCharToken( tOp_or )\n else if currChar = \"(\" then singleCharToken( tLeftParen )\n else if currChar = \")\" then singleCharToken( tRightParen )\n else if currChar = \"{\" then singleCharToken( tLeftBrace )\n else if currChar = \"}\" then singleCharToken( tRightBrace )\n else if currChar = \";\" then singleCharToken( tSemicolon )\n else if currChar = \",\" then singleCharToken( tComma )\n else if identifierStartChar then identifierOrKeyword\n else if range( \"0\", \"9\" ) then integerLiteral\n else if currChar = \"'\" then charLiteral\n else if currChar = \"\"\"\" then stringLiteral\n else begin\n lexError( \"Unrecognised character.\" );\n singleCharToken( tComment )\n end ;\n % continue until we get something other than a comment %\n tkType = tComment\n end do begin end;\n if tkTooLong then if tkType = tString\n then lexError( \"String literal too long.\" )\n else lexError( \"Identifier too long.\" );\n tkType\n end nextToken ;\n\n % outputs the current token %\n procedure writeToken ; begin\n write( i_w := 5, s_w := 2, tkLine, tkColumn, tkName( tkType ) );\n if tkType = tInteger then writeon( i_w := 11, tkIntegerValue )\n else if tkLength > 0 then begin\n writeon( \" \" );\n for tkPos := 0 until tkLength - 1 do writeon( s_w := 0, tkValue( tkPos // 1 ) );\n end\n end writeToken ;\n\n LINE_WIDTH := 256; MAXINTEGER_MOD_10 := MAXINTEGER rem 10;\n MAX_TOKEN_LENGTH := 256; MAXINTEGER_OVER_10 := MAXINTEGER div 10;\n newlineChar := code( 10 );\n tOp_multiply := 1; tkName( tOp_multiply ) := \"Op_multiply\";\n tOp_divide := 2; tkName( tOp_divide ) := \"Op_divide\";\n tOp_mod := 3; tkName( tOp_mod ) := \"Op_mod\";\n tOp_add := 4; tkName( tOp_add ) := \"Op_add\";\n tOp_subtract := 5; tkName( tOp_subtract ) := \"Op_subtract\";\n tOp_negate := 6; tkName( tOp_negate ) := \"Op_negate\";\n tOp_less := 7; tkName( tOp_less ) := \"Op_less\";\n tOp_lessequal := 8; tkName( tOp_lessequal ) := \"Op_lessequal\";\n tOp_greater := 9; tkName( tOp_greater ) := \"Op_greater\";\n tOp_greaterequal := 10; tkName( tOp_greaterequal ) := \"Op_greaterequal\";\n tOp_equal := 11; tkName( tOp_equal ) := \"Op_equal\";\n tOp_notequal := 12; tkName( tOp_notequal ) := \"Op_notequal\";\n tOp_not := 13; tkName( tOp_not ) := \"Op_not\";\n tOp_assign := 14; tkName( tOp_assign ) := \"Op_assign\";\n tOp_and := 15; tkName( tOp_and ) := \"Op_and\";\n tOp_or := 16; tkName( tOp_or ) := \"Op_or\";\n tLeftParen := 17; tkName( tLeftParen ) := \"LeftParen\";\n tRightParen := 18; tkName( tRightParen ) := \"RightParen\";\n tLeftBrace := 19; tkName( tLeftBrace ) := \"LeftBrace\";\n tRightBrace := 20; tkName( tRightBrace ) := \"RightBrace\";\n tSemicolon := 21; tkName( tSemicolon ) := \"Semicolon\";\n tComma := 22; tkName( tComma ) := \"Comma\";\n tKeyword_if := 23; tkName( tKeyword_if ) := \"Keyword_if\";\n tKeyword_else := 24; tkName( tKeyword_else ) := \"Keyword_else\";\n tKeyword_while := 25; tkName( tKeyword_while ) := \"Keyword_while\";\n tKeyword_print := 26; tkName( tKeyword_print ) := \"Keyword_print\";\n tKeyword_putc := 27; tkName( tKeyword_putc ) := \"Keyword_putc\";\n tIdentifier := 28; tkName( tIdentifier ) := \"Identifier\";\n tInteger := 29; tkName( tInteger ) := \"Integer\";\n tString := 30; tkName( tString ) := \"String\";\n tEnd_of_input := 31; tkName( tEnd_of_input ) := \"End_of_input\";\n tComment := 32; tkName( tComment ) := \"Comment\";\n\n % allow the program to continue after reaching end-of-file %\n ENDFILE := EXCEPTION( false, 1, 0, false, \"EOF\" );\n % ensure the first call to nextToken reads the first line %\n lineNumber := 0;\n columnNumber := LINE_WIDTH + 1;\n currChar := \" \";\n % get and print all tokens from standard input %\n while nextToken not = tEnd_of_input do writeToken;\n writeToken\nend.\n","language":"ALGOL-W"},{"code":"(********************************************************************)\n(* Usage: lex [INPUTFILE [OUTPUTFILE]]\n If INPUTFILE or OUTPUTFILE is \"-\" or missing, then standard input\n or standard output is used, respectively. *)\n\n#define ATS_DYNLOADFLAG 0\n\n#include \"share/atspre_staload.hats\"\nstaload UN = \"prelude/SATS/unsafe.sats\"\n\n#define NIL list_nil ()\n#define :: list_cons\n\n%{^\n/* alloca(3) is needed for ATS exceptions. */\n#include
\n%}\n\n(********************************************************************)\n\n#define NUM_TOKENS 31\n#define RESERVED_WORD_HASHTAB_SIZE 9\n\n#define TOKEN_ELSE 0\n#define TOKEN_IF 1\n#define TOKEN_PRINT 2\n#define TOKEN_PUTC 3\n#define TOKEN_WHILE 4\n#define TOKEN_MULTIPLY 5\n#define TOKEN_DIVIDE 6\n#define TOKEN_MOD 7\n#define TOKEN_ADD 8\n#define TOKEN_SUBTRACT 9\n#define TOKEN_NEGATE 10\n#define TOKEN_LESS 11\n#define TOKEN_LESSEQUAL 12\n#define TOKEN_GREATER 13\n#define TOKEN_GREATEREQUAL 14\n#define TOKEN_EQUAL 15\n#define TOKEN_NOTEQUAL 16\n#define TOKEN_NOT 17\n#define TOKEN_ASSIGN 18\n#define TOKEN_AND 19\n#define TOKEN_OR 20\n#define TOKEN_LEFTPAREN 21\n#define TOKEN_RIGHTPAREN 22\n#define TOKEN_LEFTBRACE 23\n#define TOKEN_RIGHTBRACE 24\n#define TOKEN_SEMICOLON 25\n#define TOKEN_COMMA 26\n#define TOKEN_IDENTIFIER 27\n#define TOKEN_INTEGER 28\n#define TOKEN_STRING 29\n#define TOKEN_END_OF_INPUT 30\n\ntypedef token_t =\n [i : int | TOKEN_ELSE <= i; i <= TOKEN_END_OF_INPUT]\n int i\ntypedef tokentuple_t = (token_t, String, ullint, ullint)\ntypedef token_names_vt = @[string][NUM_TOKENS]\n\nvtypedef reserved_words_vt =\n @[String][RESERVED_WORD_HASHTAB_SIZE]\nvtypedef reserved_word_tokens_vt =\n @[token_t][RESERVED_WORD_HASHTAB_SIZE]\n\nvtypedef lookups_vt =\n [p_toknames : addr]\n [p_wordtab : addr]\n [p_toktab : addr]\n @{\n pf_toknames = token_names_vt @ p_toknames,\n pf_wordtab = reserved_words_vt @ p_wordtab,\n pf_toktab = reserved_word_tokens_vt @ p_toktab |\n toknames = ptr p_toknames,\n wordtab = ptr p_wordtab,\n toktab = ptr p_toktab\n }\n\nfn\nreserved_word_lookup\n (s : String,\n lookups : !lookups_vt,\n line_no : ullint,\n column_no : ullint) : tokentuple_t =\n if string_length s < 2 then\n (TOKEN_IDENTIFIER, s, line_no, column_no)\n else\n let\n macdef wordtab = !(lookups.wordtab)\n macdef toktab = !(lookups.toktab)\n val hashval =\n g1uint_mod (g1ofg0 (char2ui s[0] + char2ui s[1]),\n g1i2u RESERVED_WORD_HASHTAB_SIZE)\n val token = toktab[hashval]\n in\n if token = TOKEN_IDENTIFIER || s <> wordtab[hashval] then\n (TOKEN_IDENTIFIER, s, line_no, column_no)\n else\n (token, s, line_no, column_no)\n end\n\n(********************************************************************)\n(* Input allows pushback into a buffer. *)\n\ntypedef ch_t =\n @{\n ichar = int,\n line_no = ullint,\n column_no = ullint\n }\n\ntypedef inp_t (n : int) =\n [0 <= n]\n @{\n file = FILEref,\n pushback = list (ch_t, n),\n line_no = ullint,\n column_no = ullint\n }\ntypedef inp_t = [n : int] inp_t n\n\nfn\nget_ch (inp : inp_t) : (ch_t, inp_t) =\n case+ (inp.pushback) of\n | NIL =>\n let\n val c = fileref_getc (inp.file)\n val ch =\n @{\n ichar = c,\n line_no = inp.line_no,\n column_no = inp.column_no\n }\n in\n if c = char2i '\\n' then\n let\n val inp =\n @{\n file = inp.file,\n pushback = inp.pushback,\n line_no = succ (inp.line_no),\n column_no = 1ULL\n }\n in\n (ch, inp)\n end\n else\n let\n val inp =\n @{\n file = inp.file,\n pushback = inp.pushback,\n line_no = inp.line_no,\n column_no = succ (inp.column_no)\n }\n in\n (ch, inp)\n end\n end\n | ch :: pushback =>\n let\n val inp =\n @{\n file = inp.file,\n pushback = pushback,\n line_no = inp.line_no,\n column_no = inp.column_no\n }\n in\n (ch, inp)\n end\n\nfn\npush_back_ch (ch : ch_t,\n inp : inp_t) : [n : pos] inp_t n =\n let\n prval _ = lemma_list_param (inp.pushback)\n in\n @{\n file = inp.file,\n pushback = ch :: (inp.pushback),\n line_no = inp.line_no,\n column_no = inp.column_no\n }\n end\n\n(********************************************************************)\n\nexception unterminated_comment of (ullint, ullint)\nexception unterminated_character_literal of (ullint, ullint)\nexception multicharacter_literal of (ullint, ullint)\nexception unterminated_string_literal of (ullint, ullint, bool)\nexception unsupported_escape of (ullint, ullint, int)\nexception invalid_integer_literal of (ullint, ullint, String)\nexception unexpected_character of (ullint, ullint, int)\n\nfn\nscan_comment (inp : inp_t,\n line_no : ullint,\n column_no : ullint) : inp_t =\n let\n fun\n loop (inp : inp_t) : inp_t =\n let\n val (ch, inp) = get_ch inp\n in\n if (ch.ichar) < 0 then\n $raise unterminated_comment (line_no, column_no)\n else if (ch.ichar) = char2i '*' then\n let\n val (ch1, inp) = get_ch inp\n in\n if (ch.ichar) < 0 then\n $raise unterminated_comment (line_no, column_no)\n else if (ch1.ichar) = char2i '/' then\n inp\n else\n loop inp\n end\n else\n loop inp\n end\n in\n loop inp\n end\n\nfn\nskip_spaces_and_comments (inp : inp_t) : [n : pos] inp_t n =\n let\n fun\n loop (inp : inp_t) : [n : pos] inp_t n =\n let\n val (ch, inp) = get_ch inp\n in\n if isspace (ch.ichar) then\n loop inp\n else if (ch.ichar) = char2i '/' then\n let\n val (ch1, inp) = get_ch inp\n in\n if (ch1.ichar) = char2i '*' then\n loop (scan_comment (inp, ch.line_no, ch.column_no))\n else\n let\n val inp = push_back_ch (ch1, inp)\n val inp = push_back_ch (ch, inp)\n in\n inp\n end\n end\n else\n push_back_ch (ch, inp)\n end\n in\n loop inp\n end\n\nfn\nreverse_list_to_string\n {m : int}\n (lst : list (char, m)) : string m =\n let\n fun\n fill_array {n : nat | n <= m} ..\n (arr : &(@[char][m + 1]),\n lst : list (char, n),\n n : size_t n) : void =\n case+ lst of\n | NIL => ()\n | c :: tail =>\n begin\n arr[pred n] := c;\n fill_array (arr, tail, pred n)\n end\n\n prval _ = lemma_list_param lst\n val m : size_t m = i2sz (list_length lst)\n val (pf, pfgc | p) = array_ptr_alloc (succ m)\n val _ = array_initize_elt (!p, succ m, '\\0')\n val _ = fill_array (!p, lst, m)\n in\n $UN.castvwtp0 @(pf, pfgc | p)\n end\n\nextern fun {}\nsimple_scan$pred : int -> bool\nfun {}\nsimple_scan {u : nat}\n (lst : list (char, u),\n inp : inp_t) :\n [m : nat]\n [n : pos]\n (list (char, m), inp_t n) =\n let\n val (ch, inp) = get_ch inp\n in\n if simple_scan$pred (ch.ichar) then\n simple_scan<> (int2char0 (ch.ichar) :: lst, inp)\n else\n let\n val inp = push_back_ch (ch, inp)\n in\n (lst, inp)\n end\n end\n\nfn\nis_ident_start (c : int) :<> bool =\n isalpha (c) || c = char2i '_'\n\nfn\nis_ident_continuation (c : int) :<> bool =\n isalnum (c) || c = char2i '_'\n\nfn\nscan_identifier_or_reserved_word\n (inp : inp_t,\n lookups : !lookups_vt) :\n (tokentuple_t, [n : pos] inp_t n) =\n let\n val (ch, inp) = get_ch inp\n val _ = assertloc (is_ident_start (ch.ichar))\n\n implement simple_scan$pred<> c = is_ident_continuation c\n val (lst, inp) = simple_scan (int2char0 (ch.ichar) :: NIL, inp)\n\n val s = reverse_list_to_string lst\n val toktup =\n reserved_word_lookup (s, lookups, ch.line_no, ch.column_no)\n in\n (toktup, inp)\n end\n\nfn\nscan_integer_literal\n (inp : inp_t,\n lookups : !lookups_vt) :\n (tokentuple_t, [n : pos] inp_t n) =\n let\n val (ch, inp) = get_ch inp\n val _ = assertloc (isdigit (ch.ichar))\n\n implement simple_scan$pred<> c = is_ident_continuation c\n val (lst, inp) = simple_scan (int2char0 (ch.ichar) :: NIL, inp)\n\n val s = reverse_list_to_string lst\n\n fun\n check_they_are_all_digits\n {n : nat} ..\n (lst : list (char, n)) : void =\n case+ lst of\n | NIL => ()\n | c :: tail =>\n if isdigit c then\n check_they_are_all_digits tail\n else\n $raise invalid_integer_literal (ch.line_no, ch.column_no, s)\n\n val _ = check_they_are_all_digits lst\n in\n ((TOKEN_INTEGER, s, ch.line_no, ch.column_no), inp)\n end\n\nfn\nichar2integer_literal (c : int) : String0 =\n let\n var buf = @[char][100] ('\\0')\n val _ = $extfcall (int, \"snprintf\", addr@ buf, i2sz 99, \"%d\", c)\n val s = string1_copy ($UN.castvwtp0{String0} buf)\n in\n strnptr2string s\n end\n\nfn\nscan_character_literal_without_checking_end (inp : inp_t) :\n (tokentuple_t, inp_t) =\n let\n val (ch, inp) = get_ch inp\n val _ = assertloc ((ch.ichar) = '\\'')\n\n val (ch1, inp) = get_ch inp\n in\n if (ch1.ichar) < 0 then\n $raise unterminated_character_literal (ch.line_no, ch.column_no)\n else if (ch1.ichar) = char2i '\\\\' then\n let\n val (ch2, inp) = get_ch inp\n in\n if (ch2.ichar) < 0 then\n $raise unterminated_character_literal (ch.line_no,\n ch.column_no)\n else if (ch2.ichar) = char2i 'n' then\n let\n val s = ichar2integer_literal (char2i '\\n')\n in\n ((TOKEN_INTEGER, s, ch.line_no, ch.column_no), inp)\n end\n else if (ch2.ichar) = char2i '\\\\' then\n let\n val s = ichar2integer_literal (char2i '\\\\')\n in\n ((TOKEN_INTEGER, s, ch.line_no, ch.column_no), inp)\n end\n else\n $raise unsupported_escape (ch1.line_no, ch1.column_no,\n ch2.ichar)\n end\n else\n let\n val s = ichar2integer_literal (ch1.ichar)\n in\n ((TOKEN_INTEGER, s, ch.line_no, ch.column_no), inp)\n end\n end\n\nfn\nscan_character_literal (inp : inp_t) : (tokentuple_t, inp_t) =\n let\n val (tok, inp) =\n scan_character_literal_without_checking_end inp\n val line_no = (tok.2)\n val column_no = (tok.3)\n\n fun\n check_end (inp : inp_t) : inp_t =\n let\n val (ch, inp) = get_ch inp\n in\n if (ch.ichar) = char2i '\\'' then\n inp\n else\n let\n fun\n loop_to_end (ch1 : ch_t,\n inp : inp_t) : inp_t =\n if (ch1.ichar) < 0 then\n $raise unterminated_character_literal (line_no,\n column_no)\n else if (ch1.ichar) = char2i '\\'' then\n $raise multicharacter_literal (line_no, column_no)\n else\n let\n val (ch1, inp) = get_ch inp\n in\n loop_to_end (ch1, inp)\n end\n\n val inp = loop_to_end (ch, inp)\n in\n inp\n end\n end\n\n val inp = check_end inp\n in\n (tok, inp)\n end\n\nfn\nscan_string_literal (inp : inp_t) : (tokentuple_t, inp_t) =\n let\n val (ch, inp) = get_ch inp\n val _ = assertloc ((ch.ichar) = '\"')\n\n fun\n scan {u : pos}\n (lst : list (char, u),\n inp : inp_t) :\n [m : pos] (list (char, m), inp_t) =\n let\n val (ch1, inp) = get_ch inp\n in\n if (ch1.ichar) < 0 then\n $raise unterminated_string_literal (ch.line_no,\n ch.column_no, false)\n else if (ch1.ichar) = char2i '\\n' then\n $raise unterminated_string_literal (ch.line_no,\n ch.column_no, true)\n else if (ch1.ichar) = char2i '\"' then\n (lst, inp)\n else if (ch1.ichar) <> char2i '\\\\' then\n scan (int2char0 (ch1.ichar) :: lst, inp)\n else\n let\n val (ch2, inp) = get_ch inp\n in\n if (ch2.ichar) = char2i 'n' then\n scan ('n' :: '\\\\' :: lst, inp)\n else if (ch2.ichar) = char2i '\\\\' then\n scan ('\\\\' :: '\\\\' :: lst, inp)\n else\n $raise unsupported_escape (ch1.line_no, ch1.column_no,\n ch2.ichar)\n end\n end\n\n val lst = '\"' :: NIL\n val (lst, inp) = scan (lst, inp)\n val lst = '\"' :: lst\n val s = reverse_list_to_string lst\n in\n ((TOKEN_STRING, s, ch.line_no, ch.column_no), inp)\n end\n\nfn\nget_next_token (inp : inp_t,\n lookups : !lookups_vt) : (tokentuple_t, inp_t) =\n let\n val inp = skip_spaces_and_comments inp\n val (ch, inp) = get_ch inp\n val ln = ch.line_no\n val cn = ch.column_no\n in\n if ch.ichar < 0 then\n ((TOKEN_END_OF_INPUT, \"\", ln, cn), inp)\n else\n case+ int2char0 (ch.ichar) of\n | ',' => ((TOKEN_COMMA, \",\", ln, cn), inp)\n | ';' => ((TOKEN_SEMICOLON, \";\", ln, cn), inp)\n | '\\(' => ((TOKEN_LEFTPAREN, \"(\", ln, cn), inp)\n | ')' => ((TOKEN_RIGHTPAREN, \")\", ln, cn), inp)\n | '\\{' => ((TOKEN_LEFTBRACE, \"{\", ln, cn), inp)\n | '}' => ((TOKEN_RIGHTBRACE, \"}\", ln, cn), inp)\n | '*' => ((TOKEN_MULTIPLY, \"*\", ln, cn), inp)\n | '/' => ((TOKEN_DIVIDE, \"/\", ln, cn), inp)\n | '%' => ((TOKEN_MOD, \"%\", ln, cn), inp)\n | '+' => ((TOKEN_ADD, \"+\", ln, cn), inp)\n | '-' => ((TOKEN_SUBTRACT, \"-\", ln, cn), inp)\n | '<' =>\n let\n val (ch1, inp) = get_ch inp\n in\n if (ch1.ichar) = char2i '=' then\n ((TOKEN_LESSEQUAL, \"<=\", ln, cn), inp)\n else\n let\n val inp = push_back_ch (ch1, inp)\n in\n ((TOKEN_LESS, \"<\", ln, cn), inp)\n end\n end\n | '>' =>\n let\n val (ch1, inp) = get_ch inp\n in\n if (ch1.ichar) = char2i '=' then\n ((TOKEN_GREATEREQUAL, \">=\", ln, cn), inp)\n else\n let\n val inp = push_back_ch (ch1, inp)\n in\n ((TOKEN_GREATER, \">\", ln, cn), inp)\n end\n end\n | '=' =>\n let\n val (ch1, inp) = get_ch inp\n in\n if (ch1.ichar) = char2i '=' then\n ((TOKEN_EQUAL, \"==\", ln, cn), inp)\n else\n let\n val inp = push_back_ch (ch1, inp)\n in\n ((TOKEN_ASSIGN, \"=\", ln, cn), inp)\n end\n end\n | '!' =>\n let\n val (ch1, inp) = get_ch inp\n in\n if (ch1.ichar) = char2i '=' then\n ((TOKEN_NOTEQUAL, \"!=\", ln, cn), inp)\n else\n let\n val inp = push_back_ch (ch1, inp)\n in\n ((TOKEN_NOT, \"!\", ln, cn), inp)\n end\n end\n | '&' =>\n let\n val (ch1, inp) = get_ch inp\n in\n if (ch1.ichar) = char2i '&' then\n ((TOKEN_AND, \"&&\", ln, cn), inp)\n else\n $raise unexpected_character (ch.line_no, ch.column_no,\n ch.ichar)\n end\n | '|' =>\n let\n val (ch1, inp) = get_ch inp\n in\n if (ch1.ichar) = char2i '|' then\n ((TOKEN_OR, \"||\", ln, cn), inp)\n else\n $raise unexpected_character (ch.line_no, ch.column_no,\n ch.ichar)\n end\n | '\"' =>\n let\n val inp = push_back_ch (ch, inp)\n in\n scan_string_literal inp\n end\n | '\\'' =>\n let\n val inp = push_back_ch (ch, inp)\n in\n scan_character_literal inp\n end\n | _ when isdigit (ch.ichar) =>\n let\n val inp = push_back_ch (ch, inp)\n in\n scan_integer_literal (inp, lookups)\n end\n | _ when is_ident_start (ch.ichar) =>\n let\n val inp = push_back_ch (ch, inp)\n in\n scan_identifier_or_reserved_word (inp, lookups)\n end\n | _ => $raise unexpected_character (ch.line_no, ch.column_no,\n ch.ichar)\n end\n\nfn\nfprint_ullint_rightjust (outf : FILEref,\n num : ullint) : void =\n if num < 10ULL then\n fprint! (outf, \" \", num)\n else if num < 100ULL then\n fprint! (outf, \" \", num)\n else if num < 1000ULL then\n fprint! (outf, \" \", num)\n else if num < 10000ULL then\n fprint! (outf, \" \", num)\n else\n fprint! (outf, num)\n\nfn\nprint_token (outf : FILEref,\n toktup : tokentuple_t,\n lookups : !lookups_vt) : void =\n let\n macdef toknames = !(lookups.toknames)\n val name = toknames[toktup.0]\n val str = (toktup.1)\n val line_no = (toktup.2)\n val column_no = (toktup.3)\n\n val _ = fprint_ullint_rightjust (outf, line_no)\n val _ = fileref_puts (outf, \" \")\n val _ = fprint_ullint_rightjust (outf, column_no)\n val _ = fileref_puts (outf, \" \")\n val _ = fileref_puts (outf, name)\n in\n begin\n case+ toktup.0 of\n | TOKEN_IDENTIFIER => fprint! (outf, \" \", str)\n | TOKEN_INTEGER => fprint! (outf, \" \", str)\n | TOKEN_STRING => fprint! (outf, \" \", str)\n | _ => ()\n end;\n\n fileref_putc (outf, '\\n')\n end\n\nfn\nscan_text (outf : FILEref,\n inp : inp_t,\n lookups : !lookups_vt) : void =\n let\n fun\n loop (inp : inp_t,\n lookups : !lookups_vt) : void =\n let\n val (toktup, inp) = get_next_token (inp, lookups)\n in\n print_token (outf, toktup, lookups);\n if toktup.0 <> TOKEN_END_OF_INPUT then\n loop (inp, lookups)\n end\n in\n loop (inp, lookups)\n end\n\n(********************************************************************)\n\nfn\nmain_program (inpf : FILEref,\n outf : FILEref) : int =\n let\n (* Using a simple Scheme program, I found the following perfect\n hash for the reserved words, using the sum of the first two\n characters as the hash value. *)\n var reserved_words =\n @[String][RESERVED_WORD_HASHTAB_SIZE]\n (\"if\", \"print\", \"else\", \"\", \"putc\", \"\", \"\", \"while\", \"\")\n var reserved_word_tokens =\n @[token_t][RESERVED_WORD_HASHTAB_SIZE]\n (TOKEN_IF, TOKEN_PRINT, TOKEN_ELSE, TOKEN_IDENTIFIER,\n TOKEN_PUTC, TOKEN_IDENTIFIER, TOKEN_IDENTIFIER, TOKEN_WHILE,\n TOKEN_IDENTIFIER)\n\n var token_names =\n @[string][NUM_TOKENS]\n (\"Keyword_else\",\n \"Keyword_if\",\n \"Keyword_print\",\n \"Keyword_putc\",\n \"Keyword_while\",\n \"Op_multiply\",\n \"Op_divide\",\n \"Op_mod\",\n \"Op_add\",\n \"Op_subtract\",\n \"Op_negate\",\n \"Op_less\",\n \"Op_lessequal\",\n \"Op_greater\",\n \"Op_greaterequal\",\n \"Op_equal\",\n \"Op_notequal\",\n \"Op_not\",\n \"Op_assign\",\n \"Op_and\",\n \"Op_or\",\n \"LeftParen\",\n \"RightParen\",\n \"LeftBrace\",\n \"RightBrace\",\n \"Semicolon\",\n \"Comma\",\n \"Identifier\",\n \"Integer\",\n \"String\",\n \"End_of_input\")\n\n var lookups : lookups_vt =\n @{\n pf_toknames = view@ token_names,\n pf_wordtab = view@ reserved_words,\n pf_toktab = view@ reserved_word_tokens |\n toknames = addr@ token_names,\n wordtab = addr@ reserved_words,\n toktab = addr@ reserved_word_tokens\n }\n\n val inp =\n @{\n file = inpf,\n pushback = NIL,\n line_no = 1ULL,\n column_no = 1ULL\n }\n\n val _ = scan_text (outf, inp, lookups)\n\n val @{\n pf_toknames = pf_toknames,\n pf_wordtab = pf_wordtab,\n pf_toktab = pf_toktab |\n toknames = toknames,\n wordtab = wordtab,\n toktab = toktab\n } = lookups\n prval _ = view@ token_names := pf_toknames\n prval _ = view@ reserved_words := pf_wordtab\n prval _ = view@ reserved_word_tokens := pf_toktab\n in\n 0\n end\n\nmacdef lex_error = \"Lexical error: \"\n\nimplement\nmain (argc, argv) =\n let\n val inpfname =\n if 2 <= argc then\n $UN.cast{string} argv[1]\n else\n \"-\"\n val outfname =\n if 3 <= argc then\n $UN.cast{string} argv[2]\n else\n \"-\"\n in\n try\n let\n val inpf =\n if (inpfname : string) = \"-\" then\n stdin_ref\n else\n fileref_open_exn (inpfname, file_mode_r)\n\n val outf =\n if (outfname : string) = \"-\" then\n stdout_ref\n else\n fileref_open_exn (outfname, file_mode_w)\n in\n main_program (inpf, outf)\n end\n with\n | ~ unterminated_comment (line_no, column_no) =>\n begin\n fprintln! (stderr_ref, lex_error,\n \"unterminated comment starting at \",\n line_no, \":\", column_no);\n 1\n end\n | ~ unterminated_character_literal (line_no, column_no) =>\n begin\n fprintln! (stderr_ref, lex_error,\n \"unterminated character literal starting at \",\n line_no, \":\", column_no);\n 1\n end\n | ~ multicharacter_literal (line_no, column_no) =>\n begin\n fprintln! (stderr_ref, lex_error,\n \"unsupported multicharacter literal starting at \",\n line_no, \":\", column_no);\n 1\n end\n | ~ unterminated_string_literal (line_no, column_no,\n end_of_line) =>\n let\n val s =\n begin\n if end_of_line then\n \"end of line\"\n else\n \"end of input\"\n end : String\n in\n fprintln! (stderr_ref, lex_error,\n \"unterminated string literal (\", s,\n \") starting at \", line_no, \":\", column_no);\n 1\n end\n | ~ unsupported_escape (line_no, column_no, c) =>\n begin\n fprintln! (stderr_ref, lex_error,\n \"unsupported escape \\\\\",\n int2char0 c, \" starting at \",\n line_no, \":\", column_no);\n 1\n end\n | ~ invalid_integer_literal (line_no, column_no, s) =>\n begin\n fprintln! (stderr_ref, lex_error,\n \"invalid integer literal \", s,\n \" starting at \", line_no, \":\", column_no);\n 1\n end\n | ~ unexpected_character (line_no, column_no, c) =>\n begin\n fprintln! (stderr_ref, lex_error,\n \"unexpected character '\", int2char0 c,\n \"' at \", line_no, \":\", column_no);\n 1\n end\nend\n\n(********************************************************************)\n","language":"ATS"},{"code":"BEGIN {\n all_syms[\"tk_EOI\" ] = \"End_of_input\"\n all_syms[\"tk_Mul\" ] = \"Op_multiply\"\n all_syms[\"tk_Div\" ] = \"Op_divide\"\n all_syms[\"tk_Mod\" ] = \"Op_mod\"\n all_syms[\"tk_Add\" ] = \"Op_add\"\n all_syms[\"tk_Sub\" ] = \"Op_subtract\"\n all_syms[\"tk_Negate\" ] = \"Op_negate\"\n all_syms[\"tk_Not\" ] = \"Op_not\"\n all_syms[\"tk_Lss\" ] = \"Op_less\"\n all_syms[\"tk_Leq\" ] = \"Op_lessequal\"\n all_syms[\"tk_Gtr\" ] = \"Op_greater\"\n all_syms[\"tk_Geq\" ] = \"Op_greaterequal\"\n all_syms[\"tk_Eq\" ] = \"Op_equal\"\n all_syms[\"tk_Neq\" ] = \"Op_notequal\"\n all_syms[\"tk_Assign\" ] = \"Op_assign\"\n all_syms[\"tk_And\" ] = \"Op_and\"\n all_syms[\"tk_Or\" ] = \"Op_or\"\n all_syms[\"tk_If\" ] = \"Keyword_if\"\n all_syms[\"tk_Else\" ] = \"Keyword_else\"\n all_syms[\"tk_While\" ] = \"Keyword_while\"\n all_syms[\"tk_Print\" ] = \"Keyword_print\"\n all_syms[\"tk_Putc\" ] = \"Keyword_putc\"\n all_syms[\"tk_Lparen\" ] = \"LeftParen\"\n all_syms[\"tk_Rparen\" ] = \"RightParen\"\n all_syms[\"tk_Lbrace\" ] = \"LeftBrace\"\n all_syms[\"tk_Rbrace\" ] = \"RightBrace\"\n all_syms[\"tk_Semi\" ] = \"Semicolon\"\n all_syms[\"tk_Comma\" ] = \"Comma\"\n all_syms[\"tk_Ident\" ] = \"Identifier\"\n all_syms[\"tk_Integer\"] = \"Integer\"\n all_syms[\"tk_String\" ] = \"String\"\n\n ## single character only symbols\n symbols[\"{\" ] = \"tk_Lbrace\"\n symbols[\"}\" ] = \"tk_Rbrace\"\n symbols[\"(\" ] = \"tk_Lparen\"\n symbols[\")\" ] = \"tk_Rparen\"\n symbols[\"+\" ] = \"tk_Add\"\n symbols[\"-\" ] = \"tk_Sub\"\n symbols[\"*\" ] = \"tk_Mul\"\n symbols[\"%\" ] = \"tk_Mod\"\n symbols[\";\" ] = \"tk_Semi\"\n symbols[\",\" ] = \"tk_Comma\"\n\n key_words[\"if\" ] = \"tk_If\"\n key_words[\"else\" ] = \"tk_Else\"\n key_words[\"print\"] = \"tk_Print\"\n key_words[\"putc\" ] = \"tk_Putc\"\n key_words[\"while\"] = \"tk_While\"\n\n # Set up an array that emulates the ord() function.\n for(n=0;n<256;n++)\n ord[sprintf(\"%c\",n)]=n\n\n input_file = \"-\"\n if (ARGC > 1)\n input_file = ARGV[1]\n RS=FS=\"\" # read complete file into one line $0\n getline < input_file\n the_ch = \" \" # dummy first char - but it must be a space\n the_col = 0 # always points to the current character\n the_line = 1\n for (the_nf=1; ; ) {\n split(gettok(), t, SUBSEP)\n printf(\"%5s %5s %-14s\", t[2], t[3], all_syms[t[1]])\n if (t[1] == \"tk_Integer\") printf(\" %5s\\n\", t[4])\n else if (t[1] == \"tk_Ident\" ) printf(\" %s\\n\", t[4])\n else if (t[1] == \"tk_String\" ) printf(\" \\\"%s\\\"\\n\", t[4])\n else print(\"\")\n if (t[1] == \"tk_EOI\")\n break\n }\n}\n\n#*** show error and exit\nfunction error(line, col, msg) {\n print(line, col, msg)\n exit(1)\n}\n\n# get the next character from the input\nfunction next_ch() {\n the_ch = $the_nf\n the_nf ++\n the_col ++\n if (the_ch == \"\\n\") {\n the_line ++\n the_col = 0\n }\n return the_ch\n}\n\n#*** 'x' - character constants\nfunction char_lit(err_line, err_col) {\n n = ord[next_ch()] # skip opening quote\n if (the_ch == \"'\") {\n error(err_line, err_col, \"empty character constant\")\n } else if (the_ch == \"\\\\\") {\n next_ch()\n if (the_ch == \"n\")\n n = 10\n else if (the_ch == \"\\\\\")\n n = ord[\"\\\\\"]\n else\n error(err_line, err_col, \"unknown escape sequence \" the_ch)\n }\n if (next_ch() != \"'\")\n error(err_line, err_col, \"multi-character constant\")\n next_ch()\n return \"tk_Integer\" SUBSEP err_line SUBSEP err_col SUBSEP n\n}\n\n#*** process divide or comments\nfunction div_or_cmt(err_line, err_col) {\n if (next_ch() != \"*\")\n return \"tk_Div\" SUBSEP err_line SUBSEP err_col\n # comment found\n next_ch()\n while (1) {\n if (the_ch == \"*\") {\n if (next_ch() == \"/\") {\n next_ch()\n return gettok()\n } else if (the_ch == \"\") {\n error(err_line, err_col, \"EOF in comment\")\n }\n } else {\n next_ch()\n }\n }\n}\n\n#*** \"string\"\nfunction string_lit(start, err_line, err_col) {\n text = \"\"\n while (next_ch() != start) {\n if (the_ch == \"\")\n error(err_line, err_col, \"EOF while scanning string literal\")\n if (the_ch == \"\\n\")\n error(err_line, err_col, \"EOL while scanning string literal\")\n text = text the_ch\n }\n next_ch()\n return \"tk_String\" SUBSEP err_line SUBSEP err_col SUBSEP text\n}\n\n#*** handle identifiers and integers\nfunction ident_or_int(err_line, err_col) {\n is_number = 1\n text = \"\"\n while ((the_ch ~ /^[0-9a-zA-Z]+$/) || (the_ch == \"_\")) {\n text = text the_ch\n if (! (the_ch ~ /^[0-9]+$/))\n is_number = 0\n next_ch()\n }\n if (text == \"\")\n error(err_line, err_col, \"ident_or_int: unrecognized character: \" the_ch)\n if (text ~ /^[0-9]/) {\n if (! is_number)\n error(err_line, err_col, \"invalid number: \" text)\n n = text + 0\n return \"tk_Integer\" SUBSEP err_line SUBSEP err_col SUBSEP n\n }\n if (text in key_words)\n return key_words[text] SUBSEP err_line SUBSEP err_col\n return \"tk_Ident\" SUBSEP err_line SUBSEP err_col SUBSEP text\n}\n\n#*** look ahead for '>=', etc.\nfunction follow(expect, ifyes, ifno, err_line, err_col) {\n if (next_ch() == expect) {\n next_ch()\n return ifyes SUBSEP err_line SUBSEP err_col\n }\n if (ifno == tk_EOI)\n error(err_line, err_col, \"follow: unrecognized character: \" the_ch)\n return ifno SUBSEP err_line SUBSEP err_col\n}\n\n#*** return the next token type\nfunction gettok() {\n while (the_ch == \" \" || the_ch == \"\\n\" || the_ch == \"\\r\")\n next_ch()\n err_line = the_line\n err_col = the_col\n if (the_ch == \"\" ) return \"tk_EOI\" SUBSEP err_line SUBSEP err_col\n else if (the_ch == \"/\") return div_or_cmt(err_line, err_col)\n else if (the_ch == \"'\") return char_lit(err_line, err_col)\n else if (the_ch == \"<\") return follow(\"=\", \"tk_Leq\", \"tk_Lss\", err_line, err_col)\n else if (the_ch == \">\") return follow(\"=\", \"tk_Geq\", \"tk_Gtr\", err_line, err_col)\n else if (the_ch == \"=\") return follow(\"=\", \"tk_Eq\", \"tk_Assign\", err_line, err_col)\n else if (the_ch == \"!\") return follow(\"=\", \"tk_Neq\", \"tk_Not\", err_line, err_col)\n else if (the_ch == \"&\") return follow(\"&\", \"tk_And\", \"tk_EOI\", err_line, err_col)\n else if (the_ch == \"|\") return follow(\"|\", \"tk_Or\", \"tk_EOI\", err_line, err_col)\n else if (the_ch ==\"\\\"\") return string_lit(the_ch, err_line, err_col)\n else if (the_ch in symbols) {\n sym = symbols[the_ch]\n next_ch()\n return sym SUBSEP err_line SUBSEP err_col\n } else {\n return ident_or_int(err_line, err_col)\n }\n}\n","language":"AWK"},{"code":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#define NELEMS(arr) (sizeof(arr) / sizeof(arr[0]))\n\n#define da_dim(name, type) type *name = NULL; \\\n int _qy_ ## name ## _p = 0; \\\n int _qy_ ## name ## _max = 0\n#define da_rewind(name) _qy_ ## name ## _p = 0\n#define da_redim(name) do {if (_qy_ ## name ## _p >= _qy_ ## name ## _max) \\\n name = realloc(name, (_qy_ ## name ## _max += 32) * sizeof(name[0]));} while (0)\n#define da_append(name, x) do {da_redim(name); name[_qy_ ## name ## _p++] = x;} while (0)\n#define da_len(name) _qy_ ## name ## _p\n\ntypedef enum {\n tk_EOI, tk_Mul, tk_Div, tk_Mod, tk_Add, tk_Sub, tk_Negate, tk_Not, tk_Lss, tk_Leq,\n tk_Gtr, tk_Geq, tk_Eq, tk_Neq, tk_Assign, tk_And, tk_Or, tk_If, tk_Else, tk_While,\n tk_Print, tk_Putc, tk_Lparen, tk_Rparen, tk_Lbrace, tk_Rbrace, tk_Semi, tk_Comma,\n tk_Ident, tk_Integer, tk_String\n} TokenType;\n\ntypedef struct {\n TokenType tok;\n int err_ln, err_col;\n union {\n int n; /* value for constants */\n char *text; /* text for idents */\n };\n} tok_s;\n\nstatic FILE *source_fp, *dest_fp;\nstatic int line = 1, col = 0, the_ch = ' ';\nda_dim(text, char);\n\ntok_s gettok(void);\n\nstatic void error(int err_line, int err_col, const char *fmt, ... ) {\n char buf[1000];\n va_list ap;\n\n va_start(ap, fmt);\n vsprintf(buf, fmt, ap);\n va_end(ap);\n printf(\"(%d,%d) error: %s\\n\", err_line, err_col, buf);\n exit(1);\n}\n\nstatic int next_ch(void) { /* get next char from input */\n the_ch = getc(source_fp);\n ++col;\n if (the_ch == '\\n') {\n ++line;\n col = 0;\n }\n return the_ch;\n}\n\nstatic tok_s char_lit(int n, int err_line, int err_col) { /* 'x' */\n if (the_ch == '\\'')\n error(err_line, err_col, \"gettok: empty character constant\");\n if (the_ch == '\\\\') {\n next_ch();\n if (the_ch == 'n')\n n = 10;\n else if (the_ch == '\\\\')\n n = '\\\\';\n else error(err_line, err_col, \"gettok: unknown escape sequence \\\\%c\", the_ch);\n }\n if (next_ch() != '\\'')\n error(err_line, err_col, \"multi-character constant\");\n next_ch();\n return (tok_s){tk_Integer, err_line, err_col, {n}};\n}\n\nstatic tok_s div_or_cmt(int err_line, int err_col) { /* process divide or comments */\n if (the_ch != '*')\n return (tok_s){tk_Div, err_line, err_col, {0}};\n\n /* comment found */\n next_ch();\n for (;;) {\n if (the_ch == '*') {\n if (next_ch() == '/') {\n next_ch();\n return gettok();\n }\n } else if (the_ch == EOF)\n error(err_line, err_col, \"EOF in comment\");\n else\n next_ch();\n }\n}\n\nstatic tok_s string_lit(int start, int err_line, int err_col) { /* \"st\" */\n da_rewind(text);\n\n while (next_ch() != start) {\n if (the_ch == '\\n') error(err_line, err_col, \"EOL in string\");\n if (the_ch == EOF) error(err_line, err_col, \"EOF in string\");\n da_append(text, (char)the_ch);\n }\n da_append(text, '\\0');\n\n next_ch();\n return (tok_s){tk_String, err_line, err_col, {.text=text}};\n}\n\nstatic int kwd_cmp(const void *p1, const void *p2) {\n return strcmp(*(char **)p1, *(char **)p2);\n}\n\nstatic TokenType get_ident_type(const char *ident) {\n static struct {\n const char *s;\n TokenType sym;\n } kwds[] = {\n {\"else\", tk_Else},\n {\"if\", tk_If},\n {\"print\", tk_Print},\n {\"putc\", tk_Putc},\n {\"while\", tk_While},\n }, *kwp;\n\n return (kwp = bsearch(&ident, kwds, NELEMS(kwds), sizeof(kwds[0]), kwd_cmp)) == NULL ? tk_Ident : kwp->sym;\n}\n\nstatic tok_s ident_or_int(int err_line, int err_col) {\n int n, is_number = true;\n\n da_rewind(text);\n while (isalnum(the_ch) || the_ch == '_') {\n da_append(text, (char)the_ch);\n if (!isdigit(the_ch))\n is_number = false;\n next_ch();\n }\n if (da_len(text) == 0)\n error(err_line, err_col, \"gettok: unrecognized character (%d) '%c'\\n\", the_ch, the_ch);\n da_append(text, '\\0');\n if (isdigit(text[0])) {\n if (!is_number)\n error(err_line, err_col, \"invalid number: %s\\n\", text);\n n = strtol(text, NULL, 0);\n if (n == LONG_MAX && errno == ERANGE)\n error(err_line, err_col, \"Number exceeds maximum value\");\n return (tok_s){tk_Integer, err_line, err_col, {n}};\n }\n return (tok_s){get_ident_type(text), err_line, err_col, {.text=text}};\n}\n\nstatic tok_s follow(int expect, TokenType ifyes, TokenType ifno, int err_line, int err_col) { /* look ahead for '>=', etc. */\n if (the_ch == expect) {\n next_ch();\n return (tok_s){ifyes, err_line, err_col, {0}};\n }\n if (ifno == tk_EOI)\n error(err_line, err_col, \"follow: unrecognized character '%c' (%d)\\n\", the_ch, the_ch);\n return (tok_s){ifno, err_line, err_col, {0}};\n}\n\ntok_s gettok(void) { /* return the token type */\n /* skip white space */\n while (isspace(the_ch))\n next_ch();\n int err_line = line;\n int err_col = col;\n switch (the_ch) {\n case '{': next_ch(); return (tok_s){tk_Lbrace, err_line, err_col, {0}};\n case '}': next_ch(); return (tok_s){tk_Rbrace, err_line, err_col, {0}};\n case '(': next_ch(); return (tok_s){tk_Lparen, err_line, err_col, {0}};\n case ')': next_ch(); return (tok_s){tk_Rparen, err_line, err_col, {0}};\n case '+': next_ch(); return (tok_s){tk_Add, err_line, err_col, {0}};\n case '-': next_ch(); return (tok_s){tk_Sub, err_line, err_col, {0}};\n case '*': next_ch(); return (tok_s){tk_Mul, err_line, err_col, {0}};\n case '%': next_ch(); return (tok_s){tk_Mod, err_line, err_col, {0}};\n case ';': next_ch(); return (tok_s){tk_Semi, err_line, err_col, {0}};\n case ',': next_ch(); return (tok_s){tk_Comma,err_line, err_col, {0}};\n case '/': next_ch(); return div_or_cmt(err_line, err_col);\n case '\\'': next_ch(); return char_lit(the_ch, err_line, err_col);\n case '<': next_ch(); return follow('=', tk_Leq, tk_Lss, err_line, err_col);\n case '>': next_ch(); return follow('=', tk_Geq, tk_Gtr, err_line, err_col);\n case '=': next_ch(); return follow('=', tk_Eq, tk_Assign, err_line, err_col);\n case '!': next_ch(); return follow('=', tk_Neq, tk_Not, err_line, err_col);\n case '&': next_ch(); return follow('&', tk_And, tk_EOI, err_line, err_col);\n case '|': next_ch(); return follow('|', tk_Or, tk_EOI, err_line, err_col);\n case '\"' : return string_lit(the_ch, err_line, err_col);\n default: return ident_or_int(err_line, err_col);\n case EOF: return (tok_s){tk_EOI, err_line, err_col, {0}};\n }\n}\n\nvoid run(void) { /* tokenize the given input */\n tok_s tok;\n do {\n tok = gettok();\n fprintf(dest_fp, \"%5d %5d %.15s\",\n tok.err_ln, tok.err_col,\n &\"End_of_input Op_multiply Op_divide Op_mod Op_add \"\n \"Op_subtract Op_negate Op_not Op_less Op_lessequal \"\n \"Op_greater Op_greaterequal Op_equal Op_notequal Op_assign \"\n \"Op_and Op_or Keyword_if Keyword_else Keyword_while \"\n \"Keyword_print Keyword_putc LeftParen RightParen LeftBrace \"\n \"RightBrace Semicolon Comma Identifier Integer \"\n \"String \"\n [tok.tok * 16]);\n if (tok.tok == tk_Integer) fprintf(dest_fp, \" %4d\", tok.n);\n else if (tok.tok == tk_Ident) fprintf(dest_fp, \" %s\", tok.text);\n else if (tok.tok == tk_String) fprintf(dest_fp, \" \\\"%s\\\"\", tok.text);\n fprintf(dest_fp, \"\\n\");\n } while (tok.tok != tk_EOI);\n if (dest_fp != stdout)\n fclose(dest_fp);\n}\n\nvoid init_io(FILE **fp, FILE *std, const char mode[], const char fn[]) {\n if (fn[0] == '\\0')\n *fp = std;\n else if ((*fp = fopen(fn, mode)) == NULL)\n error(0, 0, \"Can't open %s\\n\", fn);\n}\n\nint main(int argc, char *argv[]) {\n init_io(&source_fp, stdin, \"r\", argc > 1 ? argv[1] : \"\");\n init_io(&dest_fp, stdout, \"wb\", argc > 2 ? argv[2] : \"\");\n run();\n return 0;\n}\n","language":"C"},{"code":"#include // std::from_chars\n#include // file_to_string, string_to_file\n#include // std::invoke\n#include // std::setw\n#include // std::left\n#include \n#include