Warning, /frameworks/ktexteditor/autotests/input/indent/pascal/longtest3/origin is written in an unsupported language. File is not indexed.

 // kate: space-indent on; indent-width 3; replace-tabs on; remove-trailing-spaces all;
 // kate: syntax pascal; indent-mode pascal;
 
 // these variables are understood by the pascal indenter ...
 // kate: cfgIndentCase true;          // indent elements in a case statement
 // kate: cfgIndentBegin 2;            // indent 'begin' this many spaces
 // kate: debugMode false;              // show how indent is determined
 // kate: cfgAutoInsertStar true;      // auto insert '*' in (* ... *)-comments
 // kate: cfgSnapParen true;           // snap ')' to '*)' in comments
 
 
 function f1( var z: integer;
 var p,q : real;
 t : boolean        ) : integer; // indentation should line up
 
 type   tArray = array[0..17] of real;
 
 r= record a: integer; c: char; end;
 
 // nested variant record - too hard to get right. tough
 MyRec = Record
 X : Longint;
 Case byte of
 1,2,8 : (Y : Longint;
                case byte of
                3 : (Z : Longint);   // CHECK: parens inside parens aligned correctly
          );
 end;
 
                                                    commands = (    crsupp,crbefore,blinbefore,
                                                                   dindonkey,dindent,spbef,
 spaft,gobsym,
 inbytab,   { indent current margin (was indent from symbol pos) }
 crafter,
 finl            { force symbol to follow on same line as previous symbol }
 );
 
 tR = record
 i: integer;  // should indent after record
 r: real;
 a: array[1..11] of char;
 
 case boolean of
 true:( a: int);
 dontKnow:
 (z: real;
  fred : real;       // should be indented after case value
 joe  : integer;
 );
 false:
 (  ted : array[
                   1..16
 ] of boolean;
 moe: char; // should align to ''ted''
 );
 end; // end of case + end of record
 
 commandset = set of commands;       // should be aligned to 'record', not 'case'
 
 begin { f1 }
 case currsym^.name of
 
    { for procs, etc just record that we have one, wait for name }
 progsym, procsym, funcsym: begin
 symbol_seen := procsym;
 proc_state := proc_header;
 annotate_push( procsym );
 end;
 s1;                   // coding error, a case value should be here
    { remember we are in the declaraions part }
                         varsym, typesym, constsym, labelsym:
                            proc_state := proc_declarations;
 
                            { if it's a proc, there will be no begin/end ==> pop info we just saved
                            if it's an external var ==> do nothing  }
                         forwardsym, externalsym:
 if proc_state = proc_header then begin
 sym := annotate_pop;
 tok := annotate_pop_tok;
 if annotate_trace in traceFlags then
 writeln( 'undo ', tok.val:tok.len );
 end;
 
 { if a proc has just occurred, this is its name
 otherwise, remember it, just in case it's a record name }
 othersym: begin
 if symbol_seen = procsym then begin
 tok.val := currsym^.value;
 tok.len := currsym^.length;
 annotate_push_tok( tok );
 symbol_seen := othersym;
 end
 else begin
 annotate_temp_tok.val := currsym^.value;
 annotate_temp_tok.len := currsym^.length;
 end;
 end;
 
 { we have the name, push it so the end symbol can get it back }
 recordsym: begin
 annotate_push_tok(annotate_temp_tok);
 annotate_push( recordsym );
 symbol_seen := recordsym;
 end;
 
 { we must remember these so they can pushed if the begin symbol occurs }
 ifsym, forsym, whilesym, withsym: begin
 symbol_seen := currsym^.name;
 end;
 
 { this is the second part of an if statement }
 elsesym:
 symbol_seen := ifsym;
 
 { if in a declaration ==> ignore
 if in a statement (assume case statement) ==> prepare for possible begin following }
 colon:
 if proc_state = proc_statements then
    symbol_seen := colon;
 
 { reset symbol_seen }
 semicolon:
 symbol_seen := semicolon;
 
 { could be the begin of a proc
 ==> get value, leaving it for the corresponding end symbol
 or it could be part of an if, etc,
 ==> push the symbol so the end symbol knows what to do  }
 beginsym: begin
 proc_state := proc_statements;
 if symbol_seen in [ifsym, forsym, whilesym, withsym, elsesym, colon] then begin
 annotate_push( symbol_seen );
 end
 else begin
 sym := annotate_peek;
 if sym = procsym then begin
    { this is a proc begin, add annotation }
 annotate_pending_tok := true;
 annotate_temp_tok := annotate_peek_tok;
 end
 else begin
 if annotate_trace in traceFlags then
 writeln( infilename,' line ', inlines, ': orphaned begin found' );
 annotate_push( nosymbol );
 end
 end;
 end;
 
 { push the symbol so the end symbol can get it back }
                                  casesym: annotate_push( casesym );
 
                                     { end of proc, end of record  ==> pop name
                                     end of if, etc statement    ==> pop symbol
                                     end of case item (colon)    ==> ignore
                                     end of record ==> check if named record  }
 endsym: begin
 symbol_seen := endsym;
 sym := annotate_pop;
 if sym = recordsym then begin
    annotate_temp_tok := annotate_pop_tok;
    if annotate_temp_tok.val[1] in ['A'..'Z','a'..'z'] then
       annotate_pending_tok := true;
 end
 else if sym = procsym then begin
    annotate_pending_tok := true;
    annotate_temp_tok := annotate_pop_tok;
 end
 else if sym = ifsym then begin
    { if there's an else part, don't do an annotation here }
    if nextsym^.name <> elsesym then begin
       annotate_pending := true;
       annotate_temp := sym;
    end
 end
 else if sym in [forsym, whilesym, withsym, casesym] then begin
    annotate_pending := true;
    annotate_temp := sym;
 end
 else if sym = colon then begin
          if annotate_trace in traceFlags then
             writeln( 'case item not annotated' );
       end
       else begin
          if annotate_trace in traceFlags then
             writeln( infilename,' line: ', inlines, ' end symbol found but not handled' );
       end;
    end;
 end; { case }
 
 if annotate_pending then begin
 if nextsym^.crsbefore > 0 then begin
    { rest of line is empty }
                               insert_annotation(annotate_temp);
                               annotate_pending := false;
                            end else if nextsym^.name in [opencomment, closecomment] then begin
                               { there's another comment already on the same line }
 if annotate_trace in traceFlags then
 writeln( infilename,' line: ', inlines, ' annotate ', keyword[annotate_temp], ' abandoned' );
 annotate_pending := false;
 end
 else if (nextsym^.name <> semicolon) then begin
 insert_annotation(annotate_temp);
 annotate_pending := false;
 end;
 end;
 
 if annotate_pending_tok then begin
 if nextsym^.crsbefore > 0 then begin
    { rest of line is empty }
    insert_annotation_tok( annotate_temp_tok );
    annotate_pending_tok := false;
 end
 else if nextsym^.name in [opencomment, closecomment] then begin
    { there's another comment already on the same line }
 if annotate_trace in traceFlags then
 writeln( infilename,
          ' line: ', inlines,
 ' annotate ', annotate_temp_tok.val:annotate_temp_tok.len, ' abandoned'
 );
 annotate_pending_tok := false;
 end
 else if not (nextsym^.name in [semicolon, period]) then begin
    insert_annotation_tok( annotate_temp_tok );
    annotate_pending_tok := false;
 end;
 end;
 end; { f1 }
 
 
 function f2( p: boolean;
              var q: real;
 var x: ttype;              // should line up with first param
 var c: char;
 
 var i1, i2: integer;
 
 ch: char;
 z: boolean
 ) : real;
 
 var
 a: integer;
 b: boolean;
 
 begin { f2 }
 
 with floodlePtr^ do
 begin name := '        '; id := nil; next := nil; floodleAddr := 0;
 cow := grass + floodle  // should be indented
 end;
 
 case e of
 1: s1;   // CHECK: cr here should go to new case value!
 88:
 s3;
 
 2:  begin
 s2;
 s3;
 end;
 
 3: s3;
 4,5,6..9: s6;
 
 otherwise
 writeln('lots');
 writeln(' and lots');
 end; {case}
 
 if c then begin
 s1;
 a := func( 12,
 fffff( 89,
 t
 ),
 a // should align with '12'
 );
 end; // this must be aligned to the 'if' statement
 
 
 fredzarmplezzzzzzzzzzzz(       arg1,
 arg1,
 arg2,
 arg3
 );
 
 x := f(a) + f(b);
 
 
 if (e111) + e2 then fffffffffffff(    func0(  func1(    func2( f3(       arg1,
 
 
                                                                          arg2,
    arg3,
    arg4
 ),
 
 
 a1,  // should be aligned with arg f3, not '('
 a2,
 a3,
 a4
 ),
 
 aa2,
 aa3,
 aa4,
 aa5
 ),
 bb1,
 bb2,
 bb3,
 bb4
 ),
 cc1,
 cc2,
 cc3,
 cc4
 )
 else if c1 then begin
 s1;
 end;
 
 nextStmt := 13;
 
 while c1 do
 if q then
 s1
 else if qq then begin
 s2;
 s3
 end;
 
 
 if c1
 and c2 then begin // this can be aligned manually
 a := 12;
 s1;
 f(x)
 end;
 
 if cc1 then
 while c2 do
 f(x);
 
 while c1 do f(  arg1,
 arg2  // this should line up with arg1
 );
 
 if c4 then f( arg1,
 arg2
 );
 
 f1        ( arg1,
 arg2
 );
 fred      (  arg1,
 arg2
 arg3
 arg4,
 
 arg5
 );
 
 ff( arg1,
 arg2
 );
 
 a[1] := 13;
 repeat
 s1;
 while c3 do begin
 s3;
 while c2 do begin
 s4;
 while c4 do begin
 if c3 then
 begin
 s1;
 s2;
 end else
 s3;
 if c3 then begin
 s1
 end else
 
 if a then b
 else
 if c then d
 else
 
 s2;
 if c3 then
 if c4 then
 s5;
 
 s3
 end;
 end
 end
 until c3;
 
 
 s5;
 
 s3;
 while c7 do begin
 s3;
 s4
 end;
 
 s4
 end;
 
 s2
 until c1;  // there is no matching repeat here
 
 end;  { f2 }