root/tolp/branches/NameBlockClass/tol/OIS/oiscreator.cpp @ 520

Revision 520, 32.2 kB (checked in by vdebuen, 5 years ago)

New member BNameBlock::localName_ and related methods

  • Property svn:eol-style set to native
Line 
1/* oiscreator.cpp: main and init functions of TOL language.
2
3   Copyright (C) 2005-2007, Bayes Decision, SL (Spain [EU])
4
5   This program is free software; you can redistribute it and/or modify
6   it under the terms of the GNU General Public License as published by
7   the Free Software Foundation; either version 2, or (at your option)
8   any later version.
9
10   This program is distributed in the hope that it will be useful,
11   but WITHOUT ANY WARRANTY; without even the implied warranty of
12   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13   GNU General Public License for more details.
14
15   You should have received a copy of the GNU General Public License
16   along with this program; if not, write to the Free Software
17   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
18   USA.
19 */
20
21#if defined(_MSC_VER)
22#  include <win_tolinc.h>
23#endif
24
25#include <tol/tol_init.h>
26#include <tol/tol_oiscreator.h>
27#include <tol/tol_bdir.h>
28#include <tol/tol_bfilter.h>
29#include <tol/tol_btoken.h>
30#include <tol/tol_bscanner.h>
31#include <tol/tol_bparser.h>
32#include <tol/tol_btmsgrav.h>
33#include <tol/tol_btxtgra.h>
34#include <tol/tol_bdtegra.h>
35#include <tol/tol_bcmpgra.h>
36#include <tol/tol_bvmatgra.h>
37#include <tol/tol_bstruct.h>
38
39       
40BTraceInit("oiscreator.cpp");
41
42//#define TRACE_OIS_HIERARCHY
43#ifdef TRACE_OIS_HIERARCHY
44static FILE* logHrchyWrite_ = 
45  fopen((BSys::TolAppData()+"syslog/OisHierarchyLogWrite.log").String(),"w");
46#endif
47
48
49//--------------------------------------------------------------------
50// BOisCreator Functions
51//--------------------------------------------------------------------
52
53//--------------------------------------------------------------------
54  BOisCreator::BOisCreator() 
55//--------------------------------------------------------------------
56: BOis                   (),
57  data_                  (),
58  curHrchyEntry_         (0),
59  allSourcePath_         (),
60  tolEnvironment_        (),
61  saved_                 ()
62{ 
63}
64
65//--------------------------------------------------------------------
66 BOisCreator::~BOisCreator() 
67//--------------------------------------------------------------------
68{
69}
70
71
72//--------------------------------------------------------------------
73  void BOisCreator::Create(const BText& connection,
74                           BUserSet*    uData,
75                           const BSet*  address,
76                           const BSet*  doc,
77                           const BSet*  opt) 
78//--------------------------------------------------------------------
79{ 
80  SetConnection(connection);
81  SetAddress(address);
82  SetDoc    (doc);
83  SetControl();
84  SetOptions(opt);
85  SetData   (uData);
86}
87
88//--------------------------------------------------------------------
89  void BOisCreator::CreateModule(const BText& tolFile, BUserSet* data)
90//--------------------------------------------------------------------
91{ 
92  SetModulePath(tolFile);
93  BSet& defDoc = Set(defDoc_);
94  BText name_         = Text(defDoc["Name"]);
95  BText category_     = Text(defDoc["Category"]);
96  BText subject_      = Text(defDoc["Subject"]);
97  BText keys_         = Text(defDoc["Keys"]);
98  BText abstract_     = Text(defDoc["Abstract"]);
99  BText authors_      = Text(defDoc["Authors"]);
100  BText distribution_ = Text(defDoc["Distribution"]);
101  BText repository_   = Text(defDoc["Repository"]);
102  doc_.name_          = (name_.HasName()?name_+"::":BText(""))+tolFile;
103  doc_.category_      = "Code.Package";
104  doc_.subject_       = (subject_?subject_+". ":BText(""))+
105                        I2("Autogenerated TOL module from ",
106                          "Módulo TOL autogenerado a partir de ")+tolFile;
107  doc_.keys_          = (keys_?keys_+" ":BText(""))+"module";
108  doc_.abstract_      = abstract_;
109  doc_.authors_       = authors_;
110  doc_.abstract_      = abstract_;
111  doc_.distribution_  = distribution_;
112  doc_.repository_    = repository_;
113  SetControl();
114  SetData(data);
115}
116
117//--------------------------------------------------------------------
118  void BOisCreator::SetData(BUserSet* uData)
119//--------------------------------------------------------------------
120{ 
121  bool ok = false;
122  data_ = uData;
123  if(uData)
124  {
125    BSet& data  = data_->Contens();   
126    if(data.Card())
127    {
128      ok = true; 
129    }
130  }
131  if(doc_.name_.HasName())
132  {
133    if(doc_.category_=="Code.Package")
134    {
135      if(ok)
136      {
137        Std(I2("OIS: Creating module ","OIS: Creando el módulo ")+
138            doc_.name_+"\n");
139      }
140      else
141      {
142        Std(I2("OIS: Cannot create empty module ","OIS: NO se puede crear el módulo vacío ")+
143            doc_.name_+"\n");
144      }
145    }
146  }
147}
148
149//--------------------------------------------------------------------
150  void BOisCreator::SetControl() 
151//--------------------------------------------------------------------
152{ 
153  static BText tolCurrentVersion_ = TOLVersion();
154  char* CppCompiler();
155
156  control_.oisEngine_.curDir_       = BDir::GetCurrent();
157  control_.oisEngine_.release_      = DteNow();
158  control_.oisEngine_.oisVersion_   = oisCurrentVersion_;
159 
160  control_.machine_.hostName_       = BSys::HostName();
161  control_.machine_.isLittleEndian_ = isLittleEndian_;
162  control_.machine_.osName_         = SYSTEM;
163
164  control_.tolEngine_.cppCompiler_  = CppCompiler();
165  control_.tolEngine_.tolVersion_   = tolCurrentVersion_;
166  control_.tolEngine_.tolRelease_   = BText(__DATE__)+" "+__TIME__;
167  control_.tolEngine_.tolUserLang_  = I2("ENGLISH","CASTELLANO");
168
169
170}
171
172//--------------------------------------------------------------------
173  void BOisCreator::SetDoc(const BSet* doc)
174//--------------------------------------------------------------------
175{
176  if(doc && (doc->Struct()==BOis::docStr_))
177  {
178    doc_.name_         = Text(doc->Field("Name"));
179    doc_.category_     = Text(doc->Field("Category"));
180    doc_.subject_      = Text(doc->Field("Subject"));
181    doc_.keys_         = Text(doc->Field("Keys"));
182    doc_.distribution_ = Text(doc->Field("Distribution"));
183    doc_.abstract_     = Text(doc->Field("Abstract"));
184    doc_.authors_      = Text(doc->Field("Authors"));
185    doc_.repository_   = Text(doc->Field("Repository"));
186  }
187  else
188  {
189    doc_.name_         = "";
190    doc_.category_     = "";
191    doc_.subject_      = "";
192    doc_.keys_         = "";
193    doc_.distribution_ = "";
194    doc_.abstract_     = "";
195    doc_.authors_      = "";
196    doc_.repository_   = "";
197  }
198}
199
200
201#define EnsureDirExist(dir)                               \
202if(!BDir::CheckIsDir(dir)) { BSys::Mkdir(dir,true); }     \
203if(!BDir::CheckIsDir(dir))                                \
204{                                                         \
205  return(Error(BText("Cannot create directory ")+dir));   \
206}
207
208
209#define EnsureFileOpenW(fn,T,N)                        \
210  if(! ( fn = streamHandler_->Open(T,SubPath()+N) ) )  \
211{                                                      \
212  return(false);                                       \
213}
214
215
216//--------------------------------------------------------------------
217  bool BOisCreator::Open()
218//--------------------------------------------------------------------
219{
220  streamHandler_ = BStreamHandler::GetConnect
221  (
222    connection_, 
223    BStreamHandler::BSHOM_WRITE, 
224    true
225  );
226  if(streamHandler_)
227  {
228    RemoveImage();
229    EnsureFileOpenW(header_,      "header",      "header.xml"   );
230    EnsureFileOpenW(tolref_,      "tolref",      ".tolref"      );
231    EnsureFileOpenW(oisref_,      "oisref",      ".oisref"      );
232    EnsureFileOpenW(object_,      "object",      ".object"      );
233    EnsureFileOpenW(set_,         "set",         ".set"         );
234    EnsureFileOpenW(serie_,       "serie",       ".serie"       );
235    EnsureFileOpenW(timeset_,     "timeset",     ".timeset"     );
236    EnsureFileOpenW(matrix_,      "matrix",      ".matrix"      );
237    EnsureFileOpenW(polyn_,       "polyn",       ".polyn"       );
238    EnsureFileOpenW(ratio_,       "ratio",       ".ratio"       );
239    EnsureFileOpenW(code_,        "code",        ".code"        );
240    EnsureFileOpenW(hrchyDetail_, "hrchyDetail", ".hrchyDetail" );
241    EnsureFileOpenW(hrchyOffset_, "hrchyOffset", ".hrchyOffset" );
242    EnsureFileOpenW(hrchyOrder_,  "hrchyOrder",  ".hrchyOrder"  );
243    EnsureFileOpenW(export_,      "export",      "export.csv"   );
244
245    BText address = SubPath();
246    EWrite(address+"/.tolref>\n",      tolref_);
247    EWrite(address+"/.oisref>\n",      oisref_);
248    EWrite(address+"/.object>\n",      object_);
249    EWrite(address+"/.set>\n",         set_);
250    EWrite(address+"/.serie>\n",       serie_);
251    EWrite(address+"/.timeset>\n",     timeset_);
252    EWrite(address+"/.matrix>\n",      matrix_);
253    EWrite(address+"/.polyn>\n",       polyn_);
254    EWrite(address+"/.ratio>\n",       ratio_);
255    EWrite(address+"/.code>\n",        code_);
256    EWrite(address+"/.hrchyDetail>\n", hrchyDetail_);
257    EWrite(address+"/.hrchyOffset>\n", hrchyOffset_);
258    EWrite(address+"/.hrchyOrder>\n",  hrchyOrder_);
259    export_->Print("ModeId;GrammarId;Name;Mode;Grammar;\n");
260    enable_BSE_ = true;
261  }
262  else
263  {
264    Error("Cannot create image");
265  }
266  SetAllFiles();
267  return(streamHandler_!=NULL);
268}
269
270//--------------------------------------------------------------------
271  bool BOisCreator::WriteSource(int n, int size, const BText& path)
272//--------------------------------------------------------------------
273{
274  if(!streamHandler_) { return(false); }
275  FILE* file=fopen(path.String(),"rb");
276  if(!file) { return(false); }
277  char* contens = new char[size+1];
278  int r = fread(contens,1,size,file); 
279  contens[r]='\0';
280  fclose(file);
281  assert(r==size);
282  BText name = BText("._tol_source_/")+PlainPath(path);
283  BStream* fn = streamHandler_->Open(name,name);
284  Write(contens,1,size,fn);
285  delete [] contens;
286  fn->Flush();
287  source_.Add(fn);
288  return(true);
289}
290
291//--------------------------------------------------------------------
292  bool BOisCreator::RemoveSource() 
293//--------------------------------------------------------------------
294{
295  if(!streamHandler_) { return(false); }
296  BArray<BText> all(allSourcePath_.Size());
297  BText path;
298  for(int n=0; n<allSourcePath_.Size(); n++)
299  {
300    path = allSourcePath_[n];
301    path = ReplaceSlash(BText("._tol_source_/")+PlainPath(path)); 
302    all[n]=path;
303  };
304  streamHandler_->RemoveFiles(all);
305  return(true);
306}
307
308//--------------------------------------------------------------------
309  bool BOisCreator::DoStat()
310//--------------------------------------------------------------------
311{
312  stat_.buildingTime_ = double(elapsed_.MSec())/1000.0;
313  stat_.fileStat_[0].entries_ = -1;
314  stat_.fileStat_[0].bytes_   = -1;
315  for(int n=1; n<allFiles_.Size(); n++) 
316  { 
317    stat_.fileStat_[n].entries_ = allFiles_[n]->Entries(); 
318    stat_.fileStat_[n].bytes_   = allFiles_[n]->Bytes(); 
319  }
320  return(true);
321}
322
323//--------------------------------------------------------------------
324  bool BOisCreator::Write(const BText& v, BStream* stream)
325//--------------------------------------------------------------------
326{
327  int sz = v.Size();
328  EWrite(sz,stream);
329  Ensure(Write((const void*)v.String(),1,sz, stream));
330  return(true);
331};
332
333//--------------------------------------------------------------------
334  bool BOisCreator::Write(const BDat& v, BStream* stream)
335//--------------------------------------------------------------------
336{
337  double x = v.Value();
338  EWrite(x, stream);
339  return(true);
340};
341
342//--------------------------------------------------------------------
343  bool BOisCreator::Write(const BComplex& v, BStream* stream)
344//--------------------------------------------------------------------
345{
346  EWrite(v.X(), stream);
347  EWrite(v.Y(), stream);
348  return(true);
349};
350
351//--------------------------------------------------------------------
352  bool BOisCreator::Write(const BDate& v, BStream* stream)
353//--------------------------------------------------------------------
354{
355  double h = v.Hash();
356  return(Write(h,stream));
357};
358
359//--------------------------------------------------------------------
360  bool BOisCreator::Write(const BDat* buf, int s, BStream* stream)
361//--------------------------------------------------------------------
362{
363  Ensure(Write(buf,sizeof(BDat),s,stream));
364  return(true);
365};
366
367//--------------------------------------------------------------------
368  bool BOisCreator::Write(const BPol& x, BStream* stream)
369//--------------------------------------------------------------------
370{
371  int s = x.Size();
372  EWrite(s, stream);
373  BCoefDeg* buf = new BCoefDeg[x.Size()];
374  for(int i=0; i<x.Size(); i++)
375  {
376    buf[i].degree_      = x(i).Degree();
377    buf[i].coefficient_ = x(i).Coef  ();
378  }
379  Ensure(Write(buf,sizeof(BCoefDeg),x.Size(),stream));
380  delete [] buf;
381  return(true);
382};
383
384
385//--------------------------------------------------------------------
386  bool BOisCreator::Write(const BMemberOwner& owner, 
387                          const BMemberOwner::BClassByNameHash& x, 
388                          BStream* stream)
389//--------------------------------------------------------------------
390{
391  BMemberOwner::BClassByNameHash::const_iterator iterC;
392  int n = 0;
393  int s = x.size();
394  EWrite(s,stream);
395  for(iterC=x.begin(); iterC!=x.end(); iterC++, n++)
396  {
397    EWrite(iterC->second->Name(),stream);
398  }
399  return(true);
400}
401
402//--------------------------------------------------------------------
403  bool BOisCreator::Write(const BClass& cls, BStream* stream)
404//--------------------------------------------------------------------
405{
406  Ensure(Write(cls, *(cls.parentHash_), object_));
407  Ensure(Write(cls, *(cls.ascentHash_), object_));
408  int n = 0;
409  int s = cls.member_.Size();
410  EWrite(s,stream);
411  for(n=0; n<cls.member_.Size(); n++)
412  {
413    const BMember& mbr = *(cls.member_[n]->member_);
414    EWrite(mbr.parent_->getName(), stream);
415    EWrite(mbr.name_             , stream);
416    if(mbr.parent_==&cls)
417    {
418      char isMethod = mbr.isMethod_;
419      Ensure(WriteTree(mbr.branch_, stream));
420      EWrite(mbr.declaration_     , stream);
421      EWrite(mbr.definition_      , stream);
422      EWrite(isMethod             , stream);
423    }
424  }
425  return(true);
426}
427
428
429//--------------------------------------------------------------------
430  bool BOisCreator::WriteToken(const BToken& token, 
431                               BArray<char>& streamBuf,
432                               unsigned int& pos)
433//--------------------------------------------------------------------
434{
435  const BText& name = token.Name();
436  char  tt = token.TokenType ();
437  short pr = token.Precedence();
438  char  cl = GetIdFromTokenClose(token.Close());
439  unsigned short len = name.Length();
440  int needed = 
441    pos+ 
442    sizeof(unsigned short)+
443    len+
444    sizeof(char)+
445    sizeof(short)+
446    sizeof(char);
447  if(streamBuf.MaxSize()<=needed+10)
448  {
449    streamBuf.ReallocBuffer(needed*2);
450  }
451  memcpy(streamBuf.GetBuffer()+pos,&len,sizeof(unsigned short));
452  pos+=sizeof(unsigned short);
453  memcpy(streamBuf.GetBuffer()+pos,name.String(),len);
454  pos+=len;
455  memcpy(streamBuf.GetBuffer()+pos,&tt,sizeof(char));
456  pos+=sizeof(char);
457  memcpy(streamBuf.GetBuffer()+pos,&pr,sizeof(short));
458  pos+=sizeof(short);
459  memcpy(streamBuf.GetBuffer()+pos,&cl,sizeof(char));
460  pos+=sizeof(char);
461#ifdef TRACE_OIS_TOKEN
462  BText aux0 = Compact(name);
463  BText aux1 = Replace(aux0,'\"','|');
464  BText aux2 = Replace(aux1,'\'','|');
465  fprintf(tokWrite_,"\n%ld\t%ld\t%ld\t%s",(int)tt,(int)pr,(int)cl,aux2.String());
466  fflush(tokWrite_);
467#endif
468  return(true);
469};
470
471//--------------------------------------------------------------------
472  bool BOisCreator::WriteTree(const List* tre, 
473                              BArray<char>& streamBuf,
474                              unsigned int& pos)
475//--------------------------------------------------------------------
476{
477  char cl = 0; 
478  if(!tre)
479  {
480    memcpy(streamBuf.GetBuffer()+pos,&cl,sizeof(char));
481    pos+=sizeof(char);
482  }
483  else
484  {
485    cl = tre->car()->IsListClass()?2:1; 
486    memcpy(streamBuf.GetBuffer()+pos,&cl,sizeof(char));
487    pos+=sizeof(char);
488    if(cl==1)
489    {
490      BToken* tok = (BToken*)tre->car();
491      Ensure(WriteToken(*tok,streamBuf,pos));
492    }
493    else
494    {
495      List* lst= (List*)tre->car();
496      Ensure(WriteTree(lst, streamBuf,pos));
497    }
498    Ensure(WriteTree(tre->cdr(),streamBuf,pos));
499  }
500  return(true);
501};
502
503
504//--------------------------------------------------------------------
505  bool BOisCreator::WriteTree(const List* tre, BStream* stream)
506//--------------------------------------------------------------------
507{
508  BArray<char> streamBuf(1024*32);
509  unsigned int pos = 0;
510  WriteTree(tre, streamBuf, pos);
511  EWrite(pos,stream);
512  Write(streamBuf.Buffer(),1,pos,stream);
513  return(true);
514};
515
516
517//--------------------------------------------------------------------
518  bool BOisCreator::Write(BSyntaxObject* v)
519//--------------------------------------------------------------------
520{
521  if(!v)
522  {
523    return(Error("FATAL BOisCreator::Write(NULL)"));
524  }
525  BGrammar* gra  = v->Grammar();
526  if(v->System() && 
527     ( 
528       (gra==GraReal()) ||
529       (gra==GraDate()) ||
530       (gra==GraText())
531     ))
532  {
533    tolEnvironment_.AddUniqueSorted(v,CompareAddress);
534  }
535//If object has already offset no insert it
536  if(v->OisOffset()) { return(true); }
537  char  format = 0;
538  const BText& name   = v->Name();
539  char         system = v->System();
540  char         mode   = v->Mode();
541  if(mode == BBUILTINFUNMODE) { return(true); }
542  if( (mode != BSTRUCTMODE)  &&
543      (mode != BCLASSMODE)  &&
544      (mode != BOBJECTMODE) )
545  {
546    Warning(I2("Cannot add special objects",
547               "No se pueden añadir objetos especiales")+
548            ".\n "+v->ModeName()+" "+name+" "+
549            I2("will be ignored.","será ignorado."));
550    return(true);
551  } 
552  if(!system)
553  {
554    BText path = GetStandardAbsolutePath(v->SourcePath());
555    if(path.HasName())
556    {
557      allSourcePath_.AddUniqueSorted(path,BTextOrderCriterium);
558    }
559  }
560  BUserFunction* usf = NULL;
561  if(gra==GraCode())
562  {
563    BUserCode* code = UCode(v);
564    BCode&     cod  = code->Contens();
565    BOperator* opr  = cod.Operator();
566    if(!opr) { return(Error("FATAL BOisCreator::Write NULL Code operator")); }
567    if(opr->Mode()==BUSERFUNMODE)
568    {
569      mode   = opr->Mode   ();
570      gra    = opr->Grammar();
571      system = opr->System ();
572      usf = (BUserFunction*)opr;
573    }
574  }
575  char tol_type         = gra->Gid(); 
576  char is_referenceable = !system && 
577                          name.HasName() && 
578                          BParser::DefaultParser()->Filter()->IsIdentifier(name) &&
579                          (v->Level()<=BGrammar::Level());
580
581  object_->GetPos();
582  v->PutOisOffset(object_->Offset());
583  if(saved_.Size()>=saved_.MaxSize()) { saved_.ReallocBuffer(2*saved_.MaxSize()); }
584  saved_.Add(v);
585  if(is_referenceable)
586  {
587    EWrite(object_->Offset(), tolref_);
588    tolref_->IncEntries();
589  }
590  EWrite(object_->Offset(), oisref_);
591  oisref_->IncEntries();
592
593  EWrite(system,           object_);
594  EWrite(is_referenceable, object_);
595  EWrite(mode,             object_);
596  EWrite(tol_type,         object_);
597  EWrite(name,             object_);
598
599//System objects save no more information
600  if(!system)
601  {
602    int n, s;
603    if(mode==BSTRUCTMODE)
604    {
605      BStruct& str = *((BStruct*) v);
606      s = str.Size();
607      EWrite(s, object_);
608      for(n=0; n<s; n++)
609      {
610        char gid = str[n].Grammar()->Gid();
611        EWrite(str[n].Name(), object_);
612        EWrite(gid, object_);
613        if(str[n].Grammar()==GraSet())
614        {
615          if(str[n].Struct())
616          {
617            EWrite(str[n].Struct()->Name(), object_);
618          }
619          else
620          {
621            EWrite("", object_);
622          }
623        } 
624      } 
625    }
626    else if(mode==BCLASSMODE)
627    {
628      BClass& cls = *((BClass*) v);
629      Ensure(Write(cls, object_));
630    }
631    else
632    {
633      EWrite(v->Description(), object_);
634      EWrite(format, object_);
635      if(mode==BUSERFUNMODE)
636      {
637        const List* dec = usf->Declaration();
638        const List* def = usf->Definition ();
639        EWrite(code_->GetPos(), object_);
640        Ensure(WriteTree(dec, code_));
641        Ensure(WriteTree(def, code_));
642      //EWrite(BParser::Unparse(dec,"  ","\n"), code_);
643      //EWrite(BParser::Unparse(def,"  ","\n"), code_);
644      }
645      else //if(mode==BOBJECTMODE)
646      {
647        Ensure(WriteData(v, tol_type));
648      }
649    }
650  }
651  if(is_referenceable)
652  {
653    int gid = gra->Gid();
654    int m   = mode;
655    BText modeTxt = GetModeName(m);
656    export_->Print("%ld;%ld;%s;%s;%s;\n",
657                   m,gid,name.String(),gra->Name().String(),modeTxt.String());
658  }
659  return(true);
660}
661
662
663//--------------------------------------------------------------------
664  bool BOisCreator::WriteData(BSyntaxObject* v, char tol_type)
665//--------------------------------------------------------------------
666{
667       if(tol_type == BGI_Real      ) { return(Write(UDat (v)->Contens(), object_)); }
668  else if(tol_type == BGI_Date      ) { return(Write(UDate(v)->Contens(), object_)); }
669  else if(tol_type == BGI_Text      ) { return(Write(UText(v)->Contens(), object_)); }
670  else if(tol_type == BGI_Date      ) { return(Write(UDate(v)->Contens(), object_)); }
671  else if(tol_type == BGI_Complex   ) { return(Write(UCmp (v)->Contens(), object_)); }
672  else if(tol_type == BGI_Code      ) { return(WriteData(UCode      (v))); }
673  else if(tol_type == BGI_Set       ) { return(WriteData(USet       (v))); }
674  else if(tol_type == BGI_NameBlock ) { return(WriteData(UNameBlock (v))); }
675  else if(tol_type == BGI_Serie     ) { return(WriteData(Tsr        (v))); }
676  else if(tol_type == BGI_TimeSet   ) { return(WriteData(Tms        (v))); }
677  else if(tol_type == BGI_Matrix    ) { return(WriteData(UMat       (v))); }
678  else if(tol_type == BGI_VMatrix   ) { return(WriteData(UVMat      (v))); }
679  else if(tol_type == BGI_Polyn     ) { return(WriteData(UPol       (v))); }
680  else if(tol_type == BGI_Ratio     ) { return(WriteData(URat       (v))); }
681  return(true);
682}
683
684//--------------------------------------------------------------------
685  bool BOisCreator::WriteData(BUserCode* v)
686//--------------------------------------------------------------------
687{
688  BCode& code = v->Contens();
689  BOperator* opr = code.Operator();
690  assert(opr);
691  char oprType = opr->Grammar()->Gid();
692  EWrite(oprType, object_);
693  EWrite(opr->Name(), object_);
694  return(true);
695}
696
697//--------------------------------------------------------------------
698  bool BOisCreator::Write(const BSet& x)
699//--------------------------------------------------------------------
700{
701  char sbt = x.SubType();
702  int h, n, s = x.Card(), hrchyEntry=curHrchyEntry_++;
703  BArray<BOis::BIndexElement   > idx;
704  BArray<BOis::BGlossaryElement> glo;
705  if(options_.oisConfig_.buildHierarchy_)
706  {
707    idx.ReallocBuffer(s); 
708    glo.ReallocBuffer(s); 
709    glo.ReallocBuffer(0); 
710  }
711
712  EWrite(set_->GetPos(), object_);
713  EWrite(s, set_);
714  EWrite(sbt, set_);
715  char isNameBlock = x.GetNameBlock()!=NULL;
716  EWrite(isNameBlock,set_);
717  if(isNameBlock)
718  {
719    EWrite(x.GetNameBlock()->Name(),     set_);
720    EWrite(x.GetNameBlock()->LocalName(),set_);
721  } 
722  else if(doc_.category_.BeginWith("Code.") && 
723         (x.SubType()>=BSet::MODFile)&&(x.SubType()<=BSet::BMIFile))
724  {
725    assert(x.SourcePath());
726    BText tolPath = x.SourcePath()->Set()->TolPath();
727    EWrite(tolPath, set_);
728  }
729  if(!x.Struct())
730  {
731    assert(sbt!=BSet::Structured);
732    BINT64 offset = 0;
733    EWrite(offset, set_);
734  }
735  else
736  {
737    assert(sbt==BSet::Structured);
738    BINT64 offset = x.Struct()->OisOffset();
739    if(!offset) { offset = object_->GetPos(); }
740    EWrite(offset, set_);
741    Ensure(Write(x.Struct()));
742  }
743  h=0;
744  for(n=1; n<=s; n++)
745  {
746    if(!x[n]) 
747    {
748      Error(I2("Cannot add NULL objects",
749               "No se pueden añadir objetos nulos"));
750      return(false);
751    }
752    if((x[n]->Mode() == BUSERFUNMODE   ) ||
753       (x[n]->Mode() == BSTRUCTMODE    ) ||
754       (x[n]->Mode() == BCLASSMODE     ) ||
755       (x[n]->Mode() == BOBJECTMODE    ) ||
756       (x[n]->Mode() == BBUILTINFUNMODE)   )
757    {
758      BINT64 offset = x[n]->OisOffset();
759      if(!offset) { offset = object_->GetPos(); }
760      if(options_.oisConfig_.buildHierarchy_)
761      {
762        idx[h].gid_          = x[n]->Grammar()->Gid();
763        idx[h].mode_         = x[n]->Grammar()->Mode();
764        idx[h].objectOffset_ = offset;
765        idx[h].hrchyEntry_   = curHrchyEntry_;
766#       ifdef TRACE_OIS_HIERARCHY
767        fprintf(logHrchyWrite_,"\nidx[%ld,%ld,%"_LLD64_",(idx:%ld,glo:%ld)]->%s '%s'",
768                h,
769                idx[h].objectOffset_,
770                idx[h].hrchyEntry_, 
771                hi.hrchyOffset_,
772                x[n]->Grammar()->Name(),
773                x[n]->Identify());
774                fflush(logHrchyWrite_);
775#       endif
776        if(x[n]->Name().HasName())
777        {
778          BOis::BGlossaryElement ge;
779          ge.name_     = x[n]->Name();
780          ge.position_ = n-1;
781          glo.Add(ge);
782        }
783      }
784      EWrite(offset, set_);
785      Ensure(Write(x[n]));
786      h++;             
787    }
788    else 
789    {
790      Error(I2("Cannot add special objects",
791               "No se pueden añadir objetos especiales")+
792               ".\n "+x[n]->ModeName()+" "+x[n]->Name()+" "+
793               I2("will be ignored.","será ignorado."));
794      return(false);
795    }
796  } 
797  if(options_.oisConfig_.buildHierarchy_)
798  {
799    hrchyOffset_->GetPos();
800    hrchyDetail_->GetPos();
801    int sz = hierarchyIndex_.Size();
802    if(sz>=hierarchyIndex_.MaxSize())
803    {
804      hierarchyIndex_.ReallocBuffer(2*sz);
805      hierarchyIndex_.ReallocBuffer(sz);
806    }
807    BHierarchyIndex hi;
808    hi.hrchyOrder_ = sz;
809    hi.hrchyEntry_ = hrchyEntry;
810    hi.hrchyOffset_= hrchyDetail_->Offset();
811    hierarchyIndex_.Add(hi);
812  # ifdef TRACE_OIS_HIERARCHY
813    fprintf(logHrchyWrite_,"\nhrchyEntry[%ld,%ld,%"_LLD64_",(idx:%ld,glo:%ld)]->'%s'", 
814      sz,
815      hi.hrchyEntry_, 
816      hi.hrchyOffset_,
817      idx.Size(),
818      glo.Size(),
819      v->Name());
820      fflush(logHrchyWrite_);
821  # endif
822    glo.Sort(CompareGlossaryElement);
823    EWrite(hi.hrchyEntry_,  hrchyOffset_);
824    EWrite(hi.hrchyOffset_, hrchyOffset_);
825    Ensure(WriteHierarchy(idx,glo,hrchyDetail_))
826  }
827  return(true);
828};
829
830//--------------------------------------------------------------------
831  bool BOisCreator::WriteData(BUserSet* v)
832//--------------------------------------------------------------------
833{
834  return(Write(v->Contens()));
835};
836
837//--------------------------------------------------------------------
838  bool BOisCreator::WriteData(BUserNameBlock* v)
839//--------------------------------------------------------------------
840{
841  BNameBlock& nb = v->Contens();
842  Ensure(Write(nb.Set()));
843  char hasClass = nb.Class()!=NULL;
844  Ensure(Write(hasClass, object_));
845  if(hasClass)
846  {
847    Ensure(Write(nb.Class()->Name(), object_));
848  }
849  return(true);
850};
851
852//--------------------------------------------------------------------
853  bool BOisCreator::WriteData(BUserTimeSerie* v)
854//--------------------------------------------------------------------
855{
856  EWrite(serie_->GetPos(), object_);
857  if(!v->Dating())
858  {
859    BINT64 offset = 0;
860    BDat d = (*v)[DteToday()];
861    EWrite(offset, serie_);
862    EWrite(d,      serie_);
863  }
864  else
865  { 
866    BINT64 offset = v->Dating()->OisOffset();
867    if(!offset) { offset = object_->GetPos(); }
868    EWrite(offset, serie_);
869    Ensure(Write(v->Dating()));
870    EWrite(v->FirstDate(), serie_);
871    EWrite(v->LastDate (), serie_);
872    BHash h; v->Dating()->GetHashBetween(h, v->FirstDate(), v->LastDate());
873    BDate beginCache = HashToDte(h[0]);
874    BDate endCache   = HashToDte(h[h.Size()-1]);
875    BData d; v->GetData(d, beginCache, endCache);
876    EWrite(beginCache, serie_);
877    EWrite(endCache,   serie_);
878    EWrite(d.Size(), serie_);
879    Ensure(Write(d.Buffer(),d.Size(),serie_));
880
881    char saveTree = false;
882    if(!v->FirstDate().HasValue() || !v->LastDate().HasValue())
883    {
884      const List* tree = v->GetOisTree(); 
885      if(!tree)
886      {
887        EWrite(saveTree,serie_); 
888        #ifdef WARNING_NON_TREE_NOR_BOUNDED
889        Warning(I2("Cannot save virtual definition non bounded Serie ",
890                   "No se puede salvar la definición virtual de la Serie ")+v->Identify()+
891                I2(" due to its expression is unknown at this evaluation level.",
892                   " no acotado porque su expresión es desconocida en este nivel de evaluación."));     
893        #endif
894      } 
895      saveTree = true;
896      EWrite(saveTree,serie_);
897      Ensure(WriteTree(tree,serie_)); 
898    //BText expr = BParser::Unparse(tree,"  ","\n");
899    //EWrite(expr,serie_);
900    }
901    else
902    {
903      EWrite(saveTree,serie_);
904    }
905  //for(int n=0; n<d.Size(); n++) { EWrite(d[n], serie_); } 
906  }
907  return(true);
908}
909
910
911//--------------------------------------------------------------------
912  bool BOisCreator::WriteData(BUserTimeSet* v)
913//--------------------------------------------------------------------
914{
915  EWrite(timeset_->GetPos(), object_);
916  v->ForceCache();
917  BDate inf = v->Inf();
918  BDate sup = v->Sup();
919  BDate bc  = v->BeginCache();
920  BDate ec  = v->EndCache  ();
921  BDate a = inf.HasValue()?inf:(bc.HasValue()?bc:BDate::DefaultFirst());
922  BDate b = sup.HasValue()?sup:(ec.HasValue()?ec:BDate::DefaultLast ());
923  BHash h; v->GetHashBetween(h, a, b);
924  BDate beginCache = v->BeginCache();
925  BDate endCache   = v->EndCache  ();
926  EWrite(inf,        timeset_);
927  EWrite(sup,        timeset_);
928  EWrite(beginCache, timeset_);
929  EWrite(endCache,   timeset_);
930  EWrite(h.Size(),   timeset_);
931  Ensure(Write(h.Buffer(),sizeof(double),h.Size(),timeset_));
932//for(int n=0; n<h.Size(); n++) { EWrite(h[n], timeset_); } 
933  char saveTree = false;
934  if(!inf.HasValue() || !sup.HasValue())
935  {
936    const List* tree = v->GetOisTree(); 
937    if(!tree)
938    {
939      EWrite(saveTree,timeset_); 
940      #ifdef WARNING_NON_TREE_NOR_BOUNDED
941      Warning(I2("Cannot save virtual definition non bounded TimeSet ",
942                 "No se puede salvar la definición virtual del TimeSet ")+v->Identify()+
943              I2(" due to its expression is unknown at this evaluation level.",
944                 " no acotado porque su expresión es desconocida en este nivel de evaluación.")); 
945      #endif
946    } 
947    saveTree = true;
948    EWrite(saveTree,timeset_);
949    Ensure(WriteTree(tree,timeset_)); 
950  //BText expr = BParser::Unparse(tree,"  ","\n");
951  //EWrite(expr,timeset_);
952  }
953  else
954  {
955    EWrite(saveTree,timeset_);
956  }
957  return(true);
958}
959
960
961//--------------------------------------------------------------------
962  bool BOisCreator::WriteData(BUserMat* v)
963//--------------------------------------------------------------------
964{
965  EWrite(matrix_->GetPos(), object_);
966  BMat& x = v->Contens();
967  int r = x.Rows(), c =  x.Columns();
968  EWrite(r, matrix_);
969  EWrite(c, matrix_);
970  if(x.Data().Size()==r*c)
971  {
972    Ensure(Write(x.Data().Buffer(),r*c,matrix_));
973  }
974  else
975  {
976    BDat* buf = new BDat[r*c];
977    int i, j, k;
978    for(i=k=0; i<r; i++) { for(j=0; j<c; j++) { buf[k++] = x(i,j); } }
979    Ensure(Write(buf,r*c,matrix_));
980    delete [] buf;
981  }
982  return(true);
983};
984
985//--------------------------------------------------------------------
986  bool BOisCreator::WriteData(BUserVMat* v)
987//--------------------------------------------------------------------
988{
989  EWrite(matrix_->GetPos(), object_);
990  BVMat& x = v->Contens();
991  return(x.Write(*this, matrix_));
992};
993
994
995//--------------------------------------------------------------------
996  bool BOisCreator::WriteData(BUserPol* v)
997//--------------------------------------------------------------------
998{
999  EWrite(polyn_->GetPos(), object_);
1000  EWrite(v->Contens(), polyn_);
1001  return(true);
1002};
1003
1004
1005//--------------------------------------------------------------------
1006  bool BOisCreator::WriteData(BUserRat* v)
1007//--------------------------------------------------------------------
1008{
1009  EWrite(ratio_->GetPos(), object_);
1010  BRat& x = v->Contens();
1011  EWrite(x.Numerator  (), ratio_);
1012  EWrite(x.Denominator(), ratio_);
1013  return(true);
1014};
1015
1016//--------------------------------------------------------------------
1017  bool BOisCreator::Build()
1018//--------------------------------------------------------------------
1019{
1020  saved_.AllocBuffer(16);
1021  saved_.AllocBuffer(0);
1022  Ensure(BuilTolEnv    ());
1023  Ensure(Open          ());
1024  Ensure(Write         (data_));
1025  Ensure(SortHierarchy ());
1026  Ensure(Flush         ());
1027  Ensure(WriteHeader());
1028  Ensure(Close         ());
1029  return(true);
1030}
1031
1032//--------------------------------------------------------------------
1033  bool BOisCreator::Flush()
1034//--------------------------------------------------------------------
1035{
1036  int n;
1037  for(n=1; n<allFiles_.Size(); n++) 
1038  { 
1039    allFiles_[n]->Flush(); 
1040  }
1041  return(true);
1042}
1043
1044//--------------------------------------------------------------------
1045  bool BOisCreator::Close()
1046//--------------------------------------------------------------------
1047{
1048  if(closed_) { return(false); }
1049  int n;
1050  for(n=0; n<saved_.Size(); n++)
1051  {
1052    if(saved_[n])
1053    {
1054      saved_[n]->PutOisOffset(0);
1055    }
1056  }
1057  BOis::Close();
1058  return(true);
1059}
1060
Note: See TracBrowser for help on using the browser.