Pascal/Turbo Pascal - actualizar un stock con listas.

Buenas tardes, Lo vi a simple vista y no veo bien en que me estoy equivocando en el modulo inciso_A

este es el problema:
Una empresa de Materiales para la Construcción dispone de una lista con los productos que
comercializa. Dicha lista posee: código y nombre de producto, stock actual, stock mínimo y precio
unitario. Además la empresa posee una sucursal que diariamente envía la información de sus ventas.
De cada venta se conoce número de venta, el código de producto y cantidad vendida. Toda la
información se encuentra ordenada por código de producto.
a) Se solicita realizar el proceso que recibe la información de ventas de un día y actualiza el stock
actual de la lista de productos.

Ya generé las estructuras que disponen de la información, parece que funcionan bien, almenos para los casos en que las probé. Mi problema es en el modulo inciso_A, almenos eso creo.

program ejercicio5;
type
info_productos = record
cod_pro : integer;
nom_pro : string;
stock_actual : integer;
stock_minimo : integer;
precio_unitario : real;
end;
lista_productos = ^nodo_pro;
nodo_pro = record
elemen_pro : info_productos;
dirSig_pro : lista_productos;
end;
info_ventas = record
num_venta : integer;
cod_pro: integer;
cant_vendida : integer;
end;
lista_ventas = ^nodo_vent;
nodo_vent = record
elemen_vent : info_ventas;
dirSig_vent : lista_ventas;
end;
info_arbol = record
cod_pro : integer;
stock_a_reponer : integer;
end;
T_arbol = ^nodo_arbol;
nodo_arbol = record
hijo_der : T_arbol;
elemen_arbol : info_arbol;
hijo_izq : T_arbol;
end;
procedure crear_lista_pro (var L : lista_productos);
begin
L:= nil;
end;
procedure crear_lista_vent(var L : lista_ventas);
begin
L := nil;
end;
procedure crear_arbol(var a: T_arbol);
begin
a:= nil;
end;
procedure leer_info_pro(var reg_pro : info_productos);
begin
with (reg_pro) do
begin
write('Ingrese el código del producto: ');
readln(cod_pro);
if (cod_pro <> -1) then
begin
write('Ingrese el nombre del producto: ');
readln(nom_pro);
write('Ingrese el stock actual del producto: ');
readln(stock_actual);
write('Ingrese el stock minimo producto: ');
readln(stock_minimo);
write('Ingrese el precio unitario del producto: ');
readln(precio_unitario);
end;
end;
end;
procedure insertar_ord_pro(var pri_nodo: lista_productos; reg: info_productos);
var
nue, aux, ant : lista_productos;
begin
new(nue);
nue^.elemen_pro := reg;
nue^.dirSig_pro := nil;
if (reg.cod_pro < pri_nodo^.elemen_pro.cod_pro) then
begin
nue^.dirSig_pro := pri_nodo;
pri_nodo := nue;
end
else
begin
aux:= pri_nodo;
ant := aux;
while ((aux <> nil) and (reg.cod_pro >= aux^.elemen_pro.cod_pro)) do
begin
ant := aux;
aux := aux^.dirSig_pro;
end;
ant^.dirSig_pro := nue;
if not(aux = nil) then
nue^.dirSig_pro := aux;
end;
end;
procedure cargar_lista_productos(var list_pro : lista_productos);
var
reg_pro : info_productos;
begin
leer_info_pro(reg_pro);
if (reg_pro.cod_pro <> -1) then
begin
new(list_pro);
list_pro^.elemen_pro := reg_pro;
list_pro^.dirSig_pro := nil;
leer_info_pro(reg_pro);
while (reg_pro.cod_pro <> -1) do
begin
insertar_ord_pro(list_pro, reg_pro);
leer_info_pro(reg_pro);
end;
end;
end;
procedure leer_info_vent(var reg_vent: info_ventas);
begin
with (reg_vent) do
begin
write('Ingrese el código del producto: ');
readln(cod_pro);
if (cod_pro <> -1) then
begin
write('Ingrese el número de venta: ');
readln(num_venta);
write('Ingrese la cantidad vendida: ');
readln(cant_vendida);
end;
end;
end;
procedure insertar_ord_vent(var pri_nodo: lista_ventas; reg: info_ventas);
var
nue, aux, ant : lista_ventas;
begin
new(nue);
nue^.elemen_vent := reg;
nue^.dirSig_vent := nil;
if (reg.cod_pro < pri_nodo^.elemen_vent.cod_pro) then
begin
nue^.dirSig_vent := pri_nodo;
pri_nodo := nue;
end
else
begin
aux:= pri_nodo;
ant := aux;
while ((aux <> nil) and (reg.cod_pro >= aux^.elemen_vent.cod_pro)) do
begin
ant := aux;
aux := aux^.dirSig_vent;
end;
ant^.dirSig_vent := nue;
if not(aux = nil) then
nue^.dirSig_vent := aux;
end;
end;
procedure cargar_lista_ventas(var list_vent: lista_ventas);
var
reg_vent : info_ventas;
begin
leer_info_vent(reg_vent);
if (reg_vent.cod_pro <> -1) then
begin
new(list_vent);
list_vent^.elemen_vent := reg_vent;
list_vent^.dirSig_vent := nil;
leer_info_vent(reg_vent);
while (reg_vent.cod_pro <> -1) do
begin
insertar_ord_vent(list_vent, reg_vent);
leer_info_vent(reg_vent);
end;
end;
end;
procedure imprimir_lista_productos(L : lista_productos);
begin
while (L <> nil) do
begin
writeln('Código del producto: ', L^.elemen_pro.cod_pro);
writeln('Nombre del producto: ', L^.elemen_pro.nom_pro);
writeln('Stock actual del producto: ', L^.elemen_pro.stock_actual);
writeln('Stock minimo del producto: ', L^.elemen_pro.stock_minimo);
writeln('Precio unitario del producto: ', L^.elemen_pro.precio_unitario);
writeln();
L := L^.dirSig_pro;
end;
end;
procedure imprimir_lista_ventas(L : lista_ventas);
begin
while (L <> nil) do
begin
writeln('Código del producto: ', L^.elemen_vent.cod_pro);
writeln('Número de venta del producto: ', L^.elemen_vent.num_venta);
writeln('Cantidad vendida del producto: ', L^.elemen_vent.cant_vendida);
writeln();
L := L^.dirSig_vent;
end;
end;
procedure encontrar_cod(var list_pro: lista_productos; cod : integer);
var
ok : boolean;
begin
ok := false;
if (list_pro <> nil) then
while (ok <> true) do
begin
if (list_pro^.elemen_pro.cod_pro = cod) then
ok := true;
list_pro:= list_pro^.dirSig_pro;
end;
end;
procedure actualizar_stock(var stock_actual : integer; ventas: integer);
begin
stock_actual := stock_actual - ventas;
end;
procedure inciso_A(list_pro : lista_productos; list_vent: lista_ventas);
var
cod_actual : integer;
begin
if (list_vent <> nil) then
begin
cod_actual := list_vent^.elemen_vent.cod_pro;
encontrar_cod(list_pro, list_vent^.elemen_vent.cod_pro);
actualizar_stock(list_pro^.elemen_pro.cod_pro, list_vent^.elemen_vent.cant_vendida);
list_vent := list_vent^.dirSig_vent;
while (list_vent <> nil) do
begin
while (list_vent^.elemen_vent.cod_pro = cod_actual) do
begin
actualizar_stock(list_pro^.elemen_pro.cod_pro, list_vent^.elemen_vent.cant_vendida);
list_vent := list_vent^.dirSig_vent;
end;
encontrar_cod(list_pro, list_vent^.elemen_vent.cod_pro);
cod_actual := list_vent^.elemen_vent.cod_pro;
end;
end;
end;

var
list_pro : lista_productos;
list_vent : lista_ventas;
begin
crear_lista_pro(list_pro);
crear_lista_vent(list_vent);
writeln('---------------Lista de Productos--------------');
cargar_lista_productos(list_pro);
writeln('------------------------X----------------------');
writeln();
writeln('---------------Lista de Ventas--------------');
cargar_lista_ventas(list_vent);
writeln('------------------------X----------------------');
writeln();
writeln('---------------Lista de Productos--------------');
imprimir_lista_productos(list_pro);
writeln('------------------------X----------------------');
writeln();
writeln('---------------Lista de Ventas--------------');
imprimir_lista_ventas(list_vent);
writeln('------------------------X----------------------');
writeln();
writeln('----------------Inciso A------------------');
inciso_A(list_pro, list_vent);
imprimir_lista_productos(list_pro);
readln();
readln();
end.

Gracias, pero todavía tengo dudas en el modulo inciso_A, suponiendo que las estructuras estén bien generadas, nose si el modulo inciso_A funcoina bien, porque cuando lo ejecuto me da error, pero no veo claramente porque, De todos modos gracia por decirme el insertar ordenado, voy probar mi insertar ordenado para ver si funciona bien con más casos a ver si funciona bien con todos.

A ver en el procedimiento encontrar_cod que quieres realizar puesto que aunque lo encuentre no
podrás verlo fuera de el puesto que el ok no puedes tomarlo en el exterior.
Tendrías que ponerlo como función no como procedimiento o sea.


Ahora si puedes saber si existe o no para ejecutar el resto.

Gracias, voy a revisar bien esa parte, de todos modos, el encontrar_codigo es solamente para avanzar en la lista de productos, se asume que los datos que ingresan los usuarios siempre los ingresan bien,{eso no dijeron de parte de la catedra}, asi que no haria falta indicar si existe o no ese codigo, ya que no se puede vender algo que no existe.
Justo ahora lo estoy empezando a revisar, voy a ver bien en que me estoy equivocando. Quizás me equivoque en la carga de los datos, jajja, ojala sea eso.
Nuevamente gracias. En una horas escribo si lo resolví o sigo con el problema.
Gracias.

Gracias, ya lo acabo de resolver, modularizé un poco más para darme cuenta de los errores, parece que cuando tenia que actualizar porque era el mismo codigo, no verificaba si al avanzar en la lista de ventas llegué a nil, tambien como pascal es de respuesta rapida,en la conjunción pirmero tenia que poner en la lista de ventas sea diferente de nil y luego que los codigos sean iguales.
Lo arreglé haciendo estos modulos: