I have some misunderstanding of primitive restart index value use with adjacent primitives inside geometry shaders. An example below will show what I mean:

Motivation:
Code :
float vtx1[] = {{-1.0, 0.0, 0.0}, {+1.0, 0.0, 0.0}, {0.0, +1.0, 0.0}};
unsigned int idx1[] = {0, 0xFFFFFFFF, 1, 0xFFFFFFFF, 2, 0xFFFFFFFF};
 
//
// ... all necessary is made here: buffers created, enabled and bound, shaders loaded, compiled and used, attributes pointed and enabled.
//
 
glDisable(GL_PRIMITIVE_RESTART); // i don't need primitive restart, i need just some index value off the scope 
glPrimitiveRestartIndex(0xFFFFFFFF);
glDrawElements(GL_TRIANGLES_ADJACENCY, ...);
 
//
// ... and here we go - the triangle on the screen
//

Question:
Code :
#version 330 core
 
layout (triangles_adjacency) in;
layout (triangle_strip, max_vertices = 3) out;
 
void main()
{
   //
   // minimal geometry shader for triangles
   gl_Position = gl_in[0].gl_Position;
   EmitVertex();
   gl_Position = gl_in[2].gl_Position;
   EmitVertex();
   gl_Position = gl_in[4].gl_Position;
   EmitVertex();
   EmitPrimitive();
 
   //
   // ... and NOW there is the QUESTION: what values are in gl_in[1].*, gl_in[3].* and gl_in[5].*?
   // 
   // And how can I detect that inside the GS the primitive restart index value was used on these vertices?
   //
}

Am I missing some important information in OpenGL specs? I can't find no explanation for this ... here is similar discussion, but no proper answer.

Also needs to be noted: please do not answer that I should use GL_TRIANGLES instead GL_TRIANGLES_ADJACENCY when drawing single triangle. This is just the simplified illustrative example and there are many serious examples in real world: such a situation occurs on the edge of every triangle mesh that you run out of excessive neighboring vertices to the triangle you are right drawing ...

Thank you for your suggestions!