Next: , Previous: SubStr, Up: Reference

### Succ

#### Synopsis

```     function Succ (i: ordinal_type): ordinal_type;
```

or

```     function Succ (i: ordinal_type; j: and_integer_type): ordinal_type;
```

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

```     function Succ (p: Pointer_type): Pointer_type;
```

or

```     function Succ (p: Pointer_type; j: and_integer_type): Pointer_type;
```

#### Description

Returns the successor of the ordinal_type value i, or, if the second argument j is given, its jth 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 (jth) 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 := 42;
a := Succ (a);     { 43 }
a := Succ (a, 7);  { 50 }
{\$X+}
p := @a;
p := Succ (p);     { points to `a' now }
p := Succ (p, 3);  { points to `a' now }
end.
```