Bon désolé je vais surement me faire jeter et a mon avis personne repondra, mais ça me broute trop là. Ce message est tel une bouteille a la mer avec un message dedans.
 
Bon le prog est un projet de fac sur les listes generales et polynomes, au final assez horrible et cette fonction encore plus car j'ai rajouté des writes pour debuger.
Et donc quand dans cette fonction lorsque la fonction supprime_cel_listegen est appellée dans le si, et bien apres la fonction cons qui est appellée foire au moment de faire un new. J'ai deja fait des trucs pires que ça niveau recursivité et là je vois pas pkoi il crash au moment de faire un new .  
Je comprend pas pourquoi dans la fonction creer_cel_variable le new de la fonction cons foire seulement lorsque la fonction supprime_cel_listegen est appelée :??:  :??:
d'autant plus que ce cons ne prend pas en parametre de variable resultant de l'appel de supprime_cel_listegen .
Bon j'espere pas vraiment que qqun reponde en fait :lol:
 
 
 
function cons(l1,l2 : listegen):listegen;
var auxlistegen : listegen;
   auxl : Liste;
begin  
   writeln('cons1');
   new(auxl);  
   writeln('cons2');
   auxl^.premier:=l1;
   auxl^.suivant:=l2;
 
 
   {writeln(listegenversstring(l1));}
 
   new(auxlistegen);  
   auxlistegen^.estliste:=true;
   auxlistegen^.val:=auxl;
 
   cons:=auxlistegen;
   
end; { cons }
 
function creer_cel_variable(l : listegen;variable:char;valeur:integer):listegen;
var x : integer;
   r,t,u,f,w,h  :listegen;
begin  
   r:=trouve_variable(l,variable);
   if r<>nil then h:=supprime_cel_listegen(l,r);
   writeln(listegenversstring(l));
   writeln('pouet');
   w:=atome2listegen(int2atome(valeur));
   writeln(valeur);
   f:=cons(w,listevide);
   writeln('pouacheeet');
   u:=atome2listegen(string2atome(variable));
   t:=cons(u,f);
   l:=cons(t ,l);
 
   creer_cel_variable:=l;
 
end;  
 
 
 
 
 
 
 
*********************************
 
 
 
 
program listgen;
 
type Atome  = ^CelAtome;
   CelAtome = record        
   T_elem : integer;  
   elem : pointer;      
       end;  
 
 
       
type listegen  = ^CelListegen;
   CelListegen = record
      estliste : boolean;
      val      : pointer;
   end;      
       
type Liste  = ^CelListe;
   CelListe = record
   premier : listegen;
   suivant : listegen;
       end;  
 
type comparaisonlistegen = function(a,b: listegen):boolean;
type calcullistegen = function(a,b: listegen):listegen;
 
type reference = record
      alpha  : char;
      numero : integer;
   end;    
         
const lettre_min = 'A';
const lettre_max = 'Z';  
const nombre_min = 1;
const nombre_max = 26 ;  
   
 
Function IntToStr (I : Longint) : String;
 
Var S : String;
 
begin
 Str (I,S);
 IntToStr:=S;
end;
 
 
function listegenversstring(l : listegen):string;forward;
 
{************  atomes *****************}
   
const T_int   = 1;
const T_string   = 2;
const T_reference = 3;
       
function estatome(l : listegen):boolean;
begin
   estatome:=not(l^.estliste);
end; { estatome }
 
function atome2listegen(a : Atome):listegen;
var  aux : listegen;
begin    
   new(aux);
   aux^.estliste:=false;
   aux^.val:=a;
   atome2listegen:=aux;
end; { atome2listegen }
 
function getatome(l : listegen):Atome;
begin
   getatome:=l^.val;
end;
 
function detruitatome(a : Atome):Atome;
var Pint      : ^integer;
   Pstring    : ^string;
   Preference : ^reference;
begin        
   case a^.T_elem of
     1 : begin
     Pint:=a^.elem;
     dispose(Pint);
  end;
     2 : begin
     Pstring:=a^.elem;
     dispose(Pstring);
  end;
     3 : begin
     Preference:=a^.elem;
     dispose(Preference);
  end;
   end;
   dispose(a);
   detruitatome:=nil;
end;
 
function atomeversstring(a : Atome):string;
var Pint      : ^integer;
   Pstring    : ^string;
   Preference : ^reference;
   s       : string;
begin        
   case a^.T_elem of
     1 : begin
     Pint:=a^.elem;
     s:=inttostr(Pint^);
  end;
     2 : begin
     Pstring:=a^.elem;
     s:=Pstring^;
  end;
     3 : begin
     Preference:=a^.elem;
     s:=Preference^.alpha+IntToStr(Preference^.numero);
  end;
   end;  
   atomeversstring:=s;
end;
 
 
 
{************ atome int ***************}
 
function int2atome(i : integer):Atome;
var aux : Atome;
   ptr : ^integer;
begin
   new(ptr);
   ptr^:=i;
   new(aux);
   aux^.T_elem:=T_int;
   aux^.elem:=ptr;
   int2atome:=aux;
end; { int2atome }
   
function Is_int(a : atome):boolean;  
begin
   Is_int:=a^.T_elem=T_int;
end; { Is_int }
 
function atome2int(a : Atome):integer;
var ptr : ^integer;
begin  
   ptr:=a^.elem;
   atome2int:=ptr^;
end; { atom2int }
 
{************** atome string ****************}
 
function string2atome(s : string):Atome;
var aux : Atome;
   ptr : ^string;
begin  
   new(ptr);
   ptr^:=s;
   new(aux);
   aux^.T_elem:=T_string;
   aux^.elem:=ptr;
   string2atome:=aux;
end; { string2atome }
   
function Isstring(a : atome):boolean;  
begin
   Isstring:=a^.T_elem=T_string;
end; { Isstring }
 
function atome2string(a : Atome):string;
var ptr : ^string;
begin
   ptr:=a^.elem;
   atome2string:=ptr^;
end; { atome2string }
 
{********** Atome reference **********}
 
function Isreference(a : atome):boolean;  
begin
   Isreference:=a^.T_elem=T_reference;
end; { Isreference }
 
function reference2atome(ref : reference):Atome;
var aux : Atome;
   ptr : ^reference;
begin  
   new(ptr);
   ptr^:=ref;
   new(aux);
   aux^.T_elem:=T_reference;
   aux^.elem:=ptr;
   reference2atome:=aux;
end; { reference2atome }
 
function atome2reference(a :atome):reference;
var ptr : ^reference;
begin  
   ptr:=a^.elem;
   atome2reference:=ptr^;
end; { reference2atome }
 
{******************* reste ************}
function ispoly(a : atome ):boolean;
begin
   ispoly:=isString(a) and ('poly'=atome2string(a));
end; { ispoly }
 
function isaddition(a : atome ):boolean;
begin
   isaddition:=isString(a) and ('+'=atome2string(a));
end; { estaddition }
 
{***************** liste generales, listegen  ************}
 
function listevide:listegen;
begin
   listevide:=nil;
end; { listevide }
 
function premier(l : listegen ):listegen;
var trans : Liste;
begin
   trans:=l^.val;
   premier:=trans^.premier;
end; { premier }
 
function suite(l : listegen ):listegen;
var trans : liste;  
begin
   trans:=l^.val;
   suite:=trans^.suivant;
end; { suite }
 
function estlistevide(l :  listegen):boolean;
begin
   estlistevide:=l=nil;
end; { est_vide }
 
function estliste(l : listegen):boolean;
begin
   estliste:= (l=nil) or l^.estliste;
end; { est_listegen }
 
{remplace premier l par la listegen lg }
procedure affectepremier(l,lg : listegen);
var c : liste;
begin
   c:=l^.val;
   c^.premier:=lg;
end; { affectepremier }
 
{remplace suite l par la listegen lg }
procedure affectesuite(l,lg : listegen);
var c : liste;
begin
   c:=l^.val;
   c^.suivant:=lg;
end; { affectesuite }
 
function cons(l1,l2 : listegen):listegen;
var auxlistegen : listegen;
   auxl : Liste;
begin  
   writeln('cons1');
   new(auxl);  
   writeln('cons2');
   auxl^.premier:=l1;
   auxl^.suivant:=l2;
 
 
   {writeln(listegenversstring(l1));}
 
   new(auxlistegen);  
   auxlistegen^.estliste:=true;
   auxlistegen^.val:=auxl;
 
   cons:=auxlistegen;
   
end; { cons }
 
function concatene(l1,l2 : listegen):listegen;
begin
   if l1=nil
      then concatene:=l2
   else
      if estlistevide(suite(l1))
  then
      begin
  affectesuite(l1,l2);
  concatene:=l1;
      end  
      else
      begin
  concatene(suite(l1),l2);
  concatene:=l1;
      end;
end; { concatene }
 
function cons_fin(l1,l2 :listegen ):listegen;
begin
   cons_fin:=concatene(l2,cons(l1,listevide));
end; { cons_fin }
 
 
function detruitlistegen(l : listegen):listegen;
var transatome : atome;
   transliste  : liste;
   aux        : listegen;
   
begin
   if not(estlistevide(l))
      then
   begin
      if not(estlistevide(premier(l)))
  then
      begin
  if estatome(premier(l))
     then
  begin
     transatome:=(premier(l))^.val;
     detruitatome(transatome);
  end
  else detruitlistegen(premier(l));
  aux:=premier(l);
  dispose(aux);
      end;
      detruitlistegen(suite(l));
      transliste:=l^.val;
      dispose(transliste);
      dispose(l);
   end;
   detruitlistegen:=nil;
end; { detruitlistegen }
 
procedure echange(var a,b : listegen);
var c : listegen;
begin
   c:=a;
   a:=b;
   b:=c;
end;
 
 
{echange les deux premiers elements d'une liste}
{precondition : non(estlistevide(suite(l))) }  
procedure echange1et2(l : listegen);
var a,b : listegen;
begin  
   a:=premier(l);
   b:=premier(suite(l));
   affectepremier(l,b);
   affectepremier(suite(l),a);    
end; { echange1et2 }
 
{deplace un element dans la liste en fonction de f}
procedure bougebulle(l : listegen;f:comparaisonlistegen);
var a,b : listegen;
begin
   if not(estlistevide(l))
      then
      if not(estlistevide(suite(l)))
  then
      begin
  bougebulle(suite(l),f);
  a:=premier(l);
  b:=premier(suite(l));
  if  f(a,b)
     then
  begin
     affectepremier(l,b);
     affectepremier(suite(l),a);
  end;
      end;
end; { bougebulle }
 
{trie toute la liste en utilisant remonte sur suite de l recursivement}
procedure tribullelistegen(l : listegen; f:comparaisonlistegen);
var a,b : listegen;
begin
   if not(estlistevide(l))
      then
      if not(estlistevide(suite(l)))
  then
      begin
  bougebulle(l,f);
  tribullelistegen(suite(l),f);
      end;
end; { tribullelistegen }
 
 
procedure traitelistegen(l : listegen;calcul:calcullistegen;condition:comparaisonlistegen);
var nouveau  : listegen;
   ancienpremier : listegen;
   anciensuite  : listegen;
begin
   if not(estlistevide(l))
      then
      if not(estlistevide(suite(l)))
  then
  if condition(premier(l),premier(suite(l)))
     then
  begin
     ancienpremier:=premier(l);
     anciensuite:=suite(l);
 
     nouveau:=calcul(ancienpremier,premier(anciensuite));
 
     affectesuite(l,suite(anciensuite));
     affectesuite(anciensuite,listevide);
     affectepremier(l,nouveau);
     
     detruitlistegen(anciensuite);
     detruitlistegen(ancienpremier);
   
     traitelistegen(l,calcul,condition);
  end
  else traitelistegen(suite(l),calcul,condition);
end; { traitelistegen }
 
 
 
 
function listegenversstring2(l : listegen):string;
var s : string;
begin
   if not(estlistevide(l))
      then
      if estatome(l)
  then  s:=atomeversstring(getatome(l))
      else
      begin
  s:=listegenversstring(premier(l));
  if not(estlistevide(suite(l)))
     then
  begin
     s:=s+' ';
     s:=s+listegenversstring2(suite(l));
  end;
      end;
   listegenversstring2:=s;
end;
 
function listegenversstring(l : listegen):string;
var s : string;
begin
   s:='';
   if not(estlistevide(l))
      then
      if estatome(l)
  then s:=atomeversstring(getatome(l))
      else
      begin
  s:='(';
  s:=s+listegenversstring(premier(l));
  if not(estlistevide(suite(l)))
     then
  begin
     s:=s+' ';
     s:=s+listegenversstring2(suite(l));
  end;
  s:=s+')';
      end;
   listegenversstring:=s;
end;
 
function supprime_cel_listegen(l,x : listegen):listegen;
var aux : listegen;
begin
   if estlistevide(l)
      then supprime_cel_listegen:=listevide
   else
      if x<>l
  then
      begin
  affectesuite(l,supprime_cel_listegen(suite(l),x));
  supprime_cel_listegen:=l;
      end
      else
      begin
  aux:=suite(l);
  affectesuite(l,listevide);
  l:=detruitlistegen(l);
  supprime_cel_listegen:=aux;
      end;
end;
 
{***********************************************************************}
{***********************************************************************}
{***********************************************************************}
 
{**************************** monomes **********************************}
function getpuissx(A : listegen):integer;
begin
   getpuissx:=atome2int(getatome(premier(suite(A)))) ;
end; { getpuissx }
 
function getpuissy(A : listegen):integer;
begin
   getpuissy:=atome2int(getatome(premier(suite(suite(A))))) ;
end; { getpuissy }
 
function getfacteur(A : listegen):integer;
begin
   getfacteur:=atome2int(getatome(premier(A)));  
end; { getfacteur }
 
function monomeApluspetitB(A,B : listegen):boolean;
begin
   monomeApluspetitB:=( getpuissx(A) <   getpuissx(B) )
   or
   (
    (  getpuissx(A) = getpuissx(B) )
    and
    (  getpuissy(A) <  getpuissy(B) )
    );
end; { monomeApluspetitB }
 
function monomeAplusgrandB(A,B : listegen):boolean;
begin
   monomeAplusgrandB:=( getpuissx(A) >   getpuissx(B) )
   or
   (
    (  getpuissx(A) = getpuissx(B) )
    and
    (  getpuissy(A) >  getpuissy(B) )
    );
end; { monomeAplusgrandB }
 
function monomepuissancesegales(A,B : listegen):boolean;
begin
   monomepuissancesegales:=( getpuissx(A) =  getpuissx(B) )
   and  (  getpuissy(A) =  getpuissy(B) ) ;
end; { monomepuissancesegales }
 
function addmonomes(A,B : listegen):listegen;
var aux : listegen;
begin
   aux:=listevide;
   aux:=cons(atome2listegen(int2atome(getpuissy(A))),aux);
   aux:=cons(atome2listegen(int2atome(getpuissx(A))),aux);
   aux:=cons(atome2listegen(int2atome( getfacteur(A) + getfacteur(B) ) ),aux);
   addmonomes:=aux;
end; { addmonomes }
 
 
procedure canonique(l : listegen);
begin
   tribullelistegen(l,@monomeAplusgrandB);
   traitelistegen(l,@addmonomes,@monomepuissancesegales);
end;
 
function evaluemonomes(x,y : integer;lm:listegen):integer;
begin
   if estlistevide(lm) or (x=0) or (y=0)
      then evaluemonomes:=0
   else evaluemonomes:=getfacteur(premier(lm))*(x**getpuissx(premier(lm)))*(y**getpuissy(premier(lm))) + evaluemonomes(x,y,suite(lm));
end; { evaluemonomes }
 
 
{******************* cons integer **************************}
function ci(i:integer;l:listegen):listegen;
begin
   ci:=cons(atome2listegen(int2atome(i)),l);
end; { ci }
 
 
{******************* cons integer **************************}
function cs(i:string;l:listegen):listegen;
begin
   cs:=cons(atome2listegen(string2atome(i)),l);
end; { cs }
 
{*************** integer to listegen ***********************}
function il(i:integer):listegen;
begin
   il:=atome2listegen(int2atome(i));
end; { il }
 
{*************** string to listegen ***********************}
function sl(s:string):listegen;
begin
   sl:=atome2listegen(string2atome(s));
end; { sl }
 
function saisie_monome:listegen;
var l    : listegen;
   f,px,py : integer;
begin
   writeln('//saisie de monome');
   writeln('/saisir le facteur');
   readln(f);
   writeln('/saisir la puissance de x');
   readln(px);
   writeln('/saisir le puissance de y');
   readln(py);
   l:=cons(il(f),cons(il(px),cons(il(py),listevide)));
   saisie_monome:=l;
end; { saisie_monome }
 
function saisie_polynome:listegen;
var s : string;
   p  : listegen;
begin  
   p:=listevide;
   writeln('//saisie de polynome');
   repeat
      p:=cons(saisie_monome,p);
      writeln('voulez vous continuer ?');
      readln(s);
   until (s='n') or (s='non');
   canonique(p);
   p:=cons(sl('poly'),p);
   saisie_polynome:=p;
end; { saisie_polynome }
 
function saisie_elem_reference:reference;
 
var ref   : reference;
   lettre : char;
   nombre : integer;
begin
   writeln('//saisie de reference');
   repeat
      writeln('/saisie de la lettre');
      readln(lettre);
   until (lettre_min<=lettre) and (lettre<=lettre_max);  
   repeat
      writeln('/saisie du nombre');
      readln(nombre);
   until (nombre_min<=nombre) and (nombre<=nombre_max);  
   ref.alpha:=lettre;
   ref.numero:=nombre;
   saisie_elem_reference:=ref;
end; { saisie_elem_reference }
 
function saisie_cellule:listegen;forward;
   
function saisie_addition:listegen;
var l  : listegen;
 
begin
   writeln('//premier operande');
   l:=cons(saisie_cellule,listevide);
   writeln('//deuxieme operande');
   l:=cons_fin(saisie_cellule,l);
 
   l:=cons(sl('+'),l);
   saisie_addition:=l;
end; { saisie_addition }
 
function saisie_cellule:listegen;
var  choix : integer;c:listegen;
begin
   writeln('/que voulez vous saisir ? ');
   writeln('1/ une reference a une cellule');
   writeln('2/ un polynome');
   writeln('3/ une addition de polynomes');
   repeat
      readln(choix);
   until (choix=1) or (choix=2) or(choix=3);
   
   case choix of
     1 : c:=atome2listegen(reference2atome(saisie_elem_reference));
     2 : c:=saisie_polynome;
     3 : c:=saisie_addition;
   end;
   saisie_cellule:=c;
end;{ saisie_cellule }
 
function refegales(ref1,ref2:reference):boolean;
begin
   refegales:=(ref1.alpha=ref2.alpha) and (ref1.numero=ref2.numero);
end;
 
function est_cellule_ref_mat(l : listegen):boolean;
begin
   if estlistevide(l)
      then est_cellule_ref_mat:=false
   else
      if not(estliste(premier(l)))
  then est_cellule_ref_mat:=false
      else
  if not(estatome(premier(premier(l))))
     then est_cellule_ref_mat:=false
  else
     if not(isreference(getatome(premier(premier(l)))))
        then est_cellule_ref_mat:=false
     else est_cellule_ref_mat:=true;
end; { est_cellule_ref_mat }
 
function get_ref_cel_mat(l : listegen):reference;
begin
   get_ref_cel_mat:=atome2reference(getatome(premier(premier(l))));
end;
 
function trouve_ref(M : listegen;ref:reference):listegen;
begin
   if estlistevide(M)
      then trouve_ref:=M
   else
      if not(est_cellule_ref_mat(M))
  then trouve_ref:=trouve_ref(suite(M),ref)
      else
  if refegales(ref,get_ref_cel_mat(M))
     then trouve_ref:=M
  else trouve_ref:=trouve_ref(suite(M),ref);
end; { trouve_ref }
 
function reference_existante(l : listegen ;ref:reference):boolean;
begin
   if  est_cellule_ref_mat(l)
      then reference_existante:=refegales(ref,get_ref_cel_mat(l)) or reference_existante(suite(l),ref)
   else reference_existante:=false;
end; { reference_existante }
 
function creer_cellule(M : listegen):listegen;
var ref  : reference;
   pasok : boolean;
begin  
   writeln('saisissez la reference de la cellule');
   repeat
      ref:=saisie_elem_reference;
      pasok:=reference_existante(M,ref);
      if pasok then writeln('cellule deja occupee donnez une autre reference');
   until not(pasok);
   M:=cons(cons(atome2listegen(reference2atome(ref)),cons(saisie_cellule,listevide)),M);
   creer_cellule:=M;
end; { creer_cellule }
 
function get_contenu_cel_mat(l : listegen):listegen;
begin
   get_contenu_cel_mat:=premier(suite(premier(l)));
end;
 
function est_poly_cel(l : listegen):boolean;
begin
   if not(estliste(l))
      then est_poly_cel:=false
   else est_poly_cel:=ispoly(getatome(premier(l)));
   
end; { est_poly_cel }
 
function est_addition_cel(l : listegen):boolean;
begin
   if not(estliste(l))
      then est_addition_cel:=false
   else est_addition_cel:=isaddition(getatome(premier(l)));
   
end; { est_addition_cel }
 
function est_reference_cel(l : listegen):boolean;
begin
   if not(estatome(l))
      then est_reference_cel:=false
   else est_reference_cel:=isreference(getatome(l));
   
end; { est_reference_cel }
 
function est_cellule_variable(l : listegen;variable:string):boolean;
begin
   if estlistevide(l)
      then est_cellule_variable:=false
   else
      if not(estliste(premier(l)))
  then est_cellule_variable:=false
      else
  if not(estatome(premier(premier(l))))
     then est_cellule_variable:=false
  else
     if not(isstring(getatome(premier(premier(l)))))
        then est_cellule_variable:=false
     else est_cellule_variable:= variable=atome2string(getatome(premier(premier(l))))
end; { est_cellule_variable }
 
 
function trouve_variable(l : listegen;variable:string):listegen;
begin
   if estlistevide(l)
      then trouve_variable:=l
   else
      if not(est_cellule_variable(l,variable))
  then trouve_variable:=trouve_variable(suite(l),variable)
      else
  if atome2string(getatome(premier(premier(l))))=variable
     then trouve_variable:=l
  else trouve_variable:=trouve_variable(suite(l),variable);
end; { trouve_variable }
 
function get_valeur_cel_mat_variable(l : listegen):integer;
begin
   get_valeur_cel_mat_variable:=atome2int(getatome(premier(suite(premier(l)))));
end; { get_valeur_cel_mat_variable }
 
function creer_cel_variable(l : listegen;variable:char;valeur:integer):listegen;
var x : integer;
   r,t,u,f,w,h  :listegen;
begin  
   r:=trouve_variable(l,variable);
   if r<>nil then begin h:=supprime_cel_listegen(l,r); end;
   writeln(listegenversstring(l));
   writeln('pouet');
   w:=atome2listegen(int2atome(valeur));
   writeln(valeur);
   f:=cons(w,listevide);
   writeln('pouacheeet');
   u:=atome2listegen(string2atome(variable));
   t:=cons(u,f);
   l:=cons(t ,l);
 
 
   creer_cel_variable:=l;
 
   
end; { creer_cel_variable }
 
function evalue_contenu_cellule(M,l : listegen;x,y:integer):integer;forward;
 
function evalue_polynome(l : listegen;x,y:integer):integer;
begin
   evalue_polynome:=evaluemonomes(x,y,suite( premier(l)) );
end; { evalue_polynome }
 
function evalue_reference(M,l : listegen;x,y:integer):integer;
var o : listegen;
begin
   o:=trouve_ref(M,atome2reference(getatome(l)));
   if estlistevide(o)
      then evalue_reference:=0
   else evalue_reference:=evalue_contenu_cellule(M,get_contenu_cel_mat(o),x,y);
end; { evalue_reference }
 
function evalue_addition(M,l : listegen;x,y:integer):integer;
begin
   evalue_addition:=evalue_contenu_cellule(M,suite(premier(l)),x,y)+evalue_contenu_cellule(M,suite(suite(premier(l))),x,y);
end; { evalue_addition }
 
function evalue_contenu_cellule(M,l : listegen;x,y:integer):integer;
begin
   evalue_contenu_cellule:=0;
   if est_poly_cel(l) then evalue_contenu_cellule:=evalue_polynome(l,x,y);
   if est_reference_cel(l) then evalue_contenu_cellule:=evalue_reference(M,l,x,y);
   if est_addition_cel(l) then evalue_contenu_cellule:=evalue_addition(M,l,x,y);
end; { evalue_contenu_cellule }
 
function evalue_cel_mat(M,l : listegen;x,y:integer):integer;
begin
   evalue_cel_mat:=evalue_contenu_cellule(M,get_contenu_cel_mat(l),x,y);
end; { evalue_cel_mat }
 
 
 
 
var l : listegen;
i        :integer;
begin
   l:=listevide;
   l:=creer_cel_variable(l,'x',1);
   l:=creer_cel_variable(l,'e',2);
     l:=creer_cel_variable(l,'r',3);
   l:=creer_cel_variable(l,'t',4);
 
   {  writeln(listegenversstring(l));}
   
   l:=creer_cel_variable(l,'u',5);
   l:=creer_cel_variable(l,'x',6);
   writeln(listegenversstring(l));
   
   
   
end.

 
Trop long le code...
Vu ce que tu dis t'as un pb mémoire
soit tu touches à un truc que t'as pas alloué, soit tu libére un truc non alloué, enfin des trucs du genre... Donc vérif bien tout ça
Et met toutes les options de debuggages pour voir les msg du compilo

[SDF]Poire a écrit a écrit :     Trop long le code... Vu ce que tu dis t'as un pb mémoire soit tu touches à un truc que t'as pas alloué, soit tu libére un truc non alloué, enfin des trucs du genre... Donc vérif bien tout ça Et met toutes les options de debuggages pour voir les msg du compilo

 
oué je sais que c'est trop long
je sais pas comment on peut debugger avec le freepascal et pas non plus mettre des watchs pour les pointeurs.
 
le probleme resume a que dans quand la fonction bidule appelle l'autre et bien si je fait un new ensuite et quelque soit l'endroit du prog ou je le fait ça plante.
sinon independemment ça marche je capte pas    
 
 

j'peux pas tellement t'aider... j'aime pas suffisament les pbs mem pour me plonger ds ton code    
Mais tu dois bousiller la mem

oué.  

ayé ça marche    
J'ai refait une fonction, mais j'avoue que sais pas ce qui foirait dedans