Node:Succ, Next:Text, Previous:SubStr, Up:Reference

### Succ

#### Synopsis

    function Succ (i: ordinal_type): ordinal_type;

or

    function Succ (i: ordinal_type; j: Integer): ordinal_type;

or, with extended syntax (`--extended-syntax` or `{$X+}`),

    function Succ (p: Pointer_type): Pointer_type;

or

    function Succ (p: Pointer_type; j: Integer): Pointer_type;

#### Description

Returns the successor of the ordinal_type value `i`, or, if the second argument `j` is given, its `j`th successor. For integer values `i`, this is `i + 1` (or `i + j`). (No, `Succ` does not work faster than plain addition. Both are optimized the same way, often to a single machine instruction.)

If extended syntax is on, the argument may also be a pointer value. In this case, the address is incremented by the size of the variable pointed to, or, if `j` is given, by `j` times the size of the variable pointed to. If `p` points to an element of an array, the returned pointer will point to the (`j`th) next element of the array.

#### Conforming to

The `Succ` function is defined in ISO 7185 Pascal. The optional second parameter is defined in ISO 10206 Extended Pascal. Application of `Succ` to pointers is defined in Borland Pascal. The combination of the second argument with application to pointers is a GNU Pascal extension.

#### Example

    program SuccDemo;

    type
      Metasyntactical = (foo, bar, baz);

    var
      m: Metasyntactical;
      c: Char;
      a: array [1 .. 7] of Integer;
      p: ^Integer;

    begin
      m := Succ (foo);     { bar }
      c := Succ ('A', 4);  { 'E' }
      a[1] := 42;
      a[2] := Succ (a[1]);     { 43 }
      a[5] := Succ (a[2], 7);  { 50 }
      {$X+}
      p := @a[1];
      p := Succ (p);     { points to `a[2]' now }
      p := Succ (p, 3);  { points to `a[5]' now }
    end.

#### See also

Pred, Inc, Pointer Arithmetics.