home *** CD-ROM | disk | FTP | other *** search
/ Aminet 18 / aminetcdnumber181997.iso / Aminet / text / hyper / hsc_source.lha / hsc / source / hscprj / document.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-01-08  |  8.5 KB  |  428 lines
  1. /*
  2.  * hsclib/document.c
  3.  *
  4.  * document routines for hsc
  5.  *
  6.  * Copyright (C) 1996  Thomas Aglassinger
  7.  *
  8.  * This program is free software; you can redistribute it and/or modify
  9.  * it under the terms of the GNU General Public License as published by
  10.  * the Free Software Foundation; either version 2 of the License, or
  11.  * (at your option) any later version.
  12.  *
  13.  * This program is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  * GNU General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU General Public License
  19.  * along with this program; if not, write to the Free Software
  20.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  *
  22.  * updated:  8-Jan-1997
  23.  * created:  7-Jul-1996
  24.  */
  25.  
  26. #include <stdio.h>
  27. #include <string.h>
  28.  
  29. #include "hscprj/document.h"
  30.  
  31. /* debuggin define */
  32. #ifdef D
  33. #undef D
  34. #endif
  35. #if DEBUG
  36. #define D(x) x
  37. #else
  38. #define D(x)                    /* nufin */
  39. #endif
  40.  
  41. /*
  42.  * del/new_document
  43.  */
  44.  
  45. /* del_document: remove document */
  46. VOID del_document(APTR data)
  47. {
  48.     if (data)
  49.     {
  50.         HSCDOC *document = (HSCDOC *) data;
  51.  
  52.         ufreestr(document->docname);
  53.         ufreestr(document->sourcename);
  54.         del_estr(document->title);
  55.         del_dllist(document->iddefs);
  56.         del_dllist(document->includes);
  57.         del_dllist(document->references);
  58.         ufree(document);
  59.     }
  60. }
  61.  
  62. /* new_document: create new document */
  63. HSCDOC *new_document(STRPTR docname)
  64. {
  65.     HSCDOC *newdoc = (HSCDOC *) umalloc(sizeof(HSCDOC));
  66.  
  67. #if 0
  68.     DP(fprintf(stderr, DHP "new document `%s'\n", docname));
  69. #endif
  70.     newdoc->docname = strclone(docname);
  71.     newdoc->sourcename = NULL;
  72.     newdoc->title = init_estr(0);
  73.     newdoc->iddefs = init_dllist(del_iddef);
  74.     newdoc->includes = init_dllist(del_include);
  75.     newdoc->references = init_dllist(del_reference);
  76.  
  77.     return (newdoc);
  78. }
  79.  
  80. /*
  81.  * cmp_document: compare document
  82.  */
  83. int cmp_document(APTR cmp_data, APTR list_data)
  84. {
  85.     HSCDOC *document = (HSCDOC *) list_data;
  86.     STRPTR fname1 = NULL;
  87.     STRPTR fname2 = (STRPTR) cmp_data;
  88.  
  89. #if DEBUG
  90.     if (!document)
  91.     {
  92.         panic("documant = NULL");
  93.     }
  94.     else if (!document->docname)
  95.     {
  96.         panic("fname1 = NULL");
  97.     }
  98.     if (!fname2)
  99.     {
  100.         panic("fname2 = NULL");
  101.     }
  102. #endif
  103.     fname1 = document->docname;
  104.  
  105.     if (!strcmp(fname1, fname2))
  106.     {
  107.         return (-1);
  108.     }
  109.     else
  110.     {
  111.         return (0);
  112.     }
  113. }
  114.  
  115. /* find_document_node: scans document list for a specific document */
  116. DLNODE *find_document_node(DLLIST * list, STRPTR name)
  117. {
  118.     return (find_dlnode(dll_first(list), (APTR) name, cmp_document));
  119. }
  120.  
  121. /* find_document: scans document list for a specific document */
  122. HSCDOC *find_document(DLLIST * list, STRPTR name)
  123. {
  124.     DLNODE *nd = find_document_node(list, name);
  125.     HSCDOC *document = NULL;
  126.  
  127.     if (nd)
  128.         document = (HSCDOC *) dln_data(nd);
  129.  
  130.     return (document);
  131. }
  132.  
  133. /*
  134.  * functions for caller
  135.  */
  136. CALLER *new_caller(STRPTR name, ULONG posx, ULONG posy)
  137. {
  138.     CALLER *caller = (CALLER *) umalloc(sizeof(CALLER));
  139.  
  140.     caller->name = strclone(name);
  141.     caller->posx = posx;
  142.     caller->posy = posy;
  143.  
  144.     return (caller);
  145. }
  146.  
  147. VOID del_caller(APTR data)
  148. {
  149.     if (data)
  150.     {
  151.         CALLER *caller = (CALLER *) data;
  152.         ufreestr(caller->name);
  153.         ufree(caller);
  154.     }
  155. }
  156.  
  157. CALLER *fpos2caller(INFILEPOS * fpos)
  158. {
  159.     CALLER *cal = NULL;
  160.  
  161.     if (fpos)
  162.     {
  163.         cal = new_caller(ifp_get_fname(fpos),
  164.                          ifp_get_x(fpos), ifp_get_y(fpos));
  165.     }
  166.     else
  167.         cal = new_caller("", 0, 0);
  168.  
  169.     return (cal);
  170. }
  171.  
  172. /*
  173.  * functions for references
  174.  */
  175.  
  176. /* del_reference: remove a reference */
  177. VOID del_reference(APTR data)
  178. {
  179.     HSCREF *ref = (HSCREF *) data;
  180.  
  181.     ufreestr(ref->name);
  182.     del_caller(ref->caller);
  183.     ufree(ref);
  184.     /* NOTE: ref->fpos is removed whith the
  185.      * corresponding file automatically */
  186. }
  187.  
  188. /* new_reference: create a new reference */
  189. HSCREF *new_reference(STRPTR newname)
  190. {
  191.     HSCREF *ref = (HSCREF *) umalloc(sizeof(HSCREF));
  192.  
  193.     if (ref)
  194.     {
  195.         ref->name = strclone(newname);
  196.         ref->caller = NULL;
  197.     }
  198.     return (ref);
  199. }
  200.  
  201. /*
  202.  * cmp_reference: compare reference
  203.  */
  204. int cmp_reference(APTR cmp_data, APTR list_data)
  205. {
  206.     HSCREF *reference = (HSCREF *) list_data;
  207.     STRPTR fname1 = NULL;
  208.     STRPTR fname2 = (STRPTR) cmp_data;
  209.  
  210. #if DEBUG
  211.     if (!reference)
  212.     {
  213.         panic("reference = NULL");
  214.     }
  215.     else if (!reference->name)
  216.     {
  217.         panic("fname1 = NULL");
  218.     }
  219.     if (!fname2)
  220.     {
  221.         panic("fname2 = NULL");
  222.     }
  223. #endif
  224.     fname1 = reference->name;
  225.  
  226.     if (!strcmp(fname1, fname2))
  227.     {
  228.         return (-1);
  229.     }
  230.     else
  231.     {
  232.         return (0);
  233.     }
  234. }
  235.  
  236. /*
  237.  * app_reference: append new reference to reflist of a document;
  238.  *   if reference already exists, no new ref is added
  239.  */
  240. HSCREF *app_reference(HSCDOC * document, STRPTR ref_name)
  241. {
  242.     HSCREF *ref = NULL;
  243.  
  244.     /* append new reference */
  245.     ref = new_reference(ref_name);
  246.     app_dlnode(document->references, (APTR) ref);
  247. #if 0
  248.     DP(fprintf(stderr, DHP "new reference `%s'\n", ref_name));
  249. #endif
  250.  
  251.     return (ref);
  252. }
  253.  
  254. /*
  255.  * functions for includes
  256.  */
  257.  
  258. /* del_include: remove a include */
  259. VOID del_include(APTR data)
  260. {
  261.     HSCINC *inc = (HSCINC *) data;
  262.  
  263.     ufreestr(inc->name);
  264.     del_caller(inc->caller);
  265.     ufree(inc);
  266. }
  267.  
  268. /* new_include: create a new include */
  269. HSCINC *new_include(STRPTR newname)
  270. {
  271.     HSCINC *inc = (HSCINC *) umalloc(sizeof(HSCINC));
  272.  
  273.     if (inc)
  274.     {
  275.         inc->name = strclone(newname);
  276.         inc->caller = NULL;
  277.     }
  278.     return (inc);
  279. }
  280.  
  281. /*
  282.  * cmp_include: compare include
  283.  */
  284. int cmp_include(APTR cmp_data, APTR list_data)
  285. {
  286.     HSCINC *include = (HSCINC *) list_data;
  287.     STRPTR fname1 = NULL;
  288.     STRPTR fname2 = (STRPTR) cmp_data;
  289.  
  290. #if DEBUG
  291.     if (!include)                {
  292.         panic("include = NULL");  }
  293.     else if (!include->name)       {
  294.         panic("fname1 = NULL");     }
  295.     if (!fname2)                     {
  296.         panic("fname2 = NULL");       }
  297. #endif
  298.     fname1 = include->name;
  299.  
  300.     if (!strcmp(fname1, fname2))
  301.         return (-1);
  302.     else
  303.         return (0);
  304. }
  305.  
  306. /*
  307.  * app_include: append new include to inclist of a document;
  308.  *   even append multiple instancies of the same include
  309.  */
  310. HSCINC *app_include(HSCDOC * document, STRPTR inc_name)
  311. {
  312.     DLNODE *nd = NULL;
  313.     /* append new include */
  314.     HSCINC *inc = new_include(inc_name);
  315.     nd = app_dlnode(document->includes, (APTR) inc);
  316.  
  317.     return (inc);
  318. }
  319.  
  320. /*
  321.  * functions for id-definitions
  322.  */
  323.  
  324. /* del_iddef: remove an id-definition */
  325. VOID del_iddef(APTR data)
  326. {
  327.     HSCIDD *iddef = (HSCIDD *) data;
  328.  
  329.     ufreestr(iddef->name);
  330.     del_caller(iddef->caller);
  331.     if (iddef->fpos)
  332.         del_infilepos(iddef->fpos);
  333.     ufree(iddef);
  334. }
  335.  
  336. /* new_iddef: create a new id-definition */
  337. HSCIDD *new_iddef(STRPTR newname)
  338. {
  339.     HSCIDD *iddef = (HSCIDD *) umalloc(sizeof(HSCIDD));
  340.  
  341.     if (iddef)
  342.     {
  343.         iddef->name = strclone(newname);
  344.         iddef->caller = NULL;
  345.         iddef->fpos = NULL;
  346.     }
  347.     return (iddef);
  348. }
  349.  
  350. /*
  351.  * debugging printf functions
  352.  */
  353. VOID prt_iddef(FILE * stream, APTR data)
  354. {
  355.     HSCIDD *iddef = (HSCIDD *) data;
  356.     INFILEPOS *fpos = iddef->fpos;
  357.  
  358.     fprintf(stream, "`%s' at (%lu,%lu)\n",
  359.             iddef->name, ifp_get_y(fpos), ifp_get_x(fpos));
  360. }
  361.  
  362. /*
  363.  * cmp_iddef: compare id-definition
  364.  */
  365. int cmp_iddef(APTR cmp_data, APTR list_data)
  366. {
  367.     HSCIDD *iddef = (HSCIDD *) list_data;
  368.     STRPTR fname1 = NULL;
  369.     STRPTR fname2 = (STRPTR) cmp_data;
  370.  
  371. #if DEBUG
  372.     if (!iddef)
  373.     {
  374.         panic("id-definition = NULL");
  375.     }
  376.     else if (!iddef->name)
  377.     {
  378.         panic("fname1 = NULL");
  379.     }
  380.     if (!fname2)
  381.     {
  382.         panic("fname2 = NULL");
  383.     }
  384. #endif
  385.     fname1 = iddef->name;
  386.  
  387.     if (!strcmp(fname1, fname2))
  388.     {
  389.         return (-1);
  390.     }
  391.     else
  392.     {
  393.         return (0);
  394.     }
  395. }
  396.  
  397. /* find_iddef: scans document list for a specific id */
  398. HSCIDD *find_iddef(HSCDOC * document, STRPTR name)
  399. {
  400.     DLNODE *nd = find_dlnode(dll_first(document->iddefs),
  401.                              (APTR) name, cmp_iddef);
  402.     HSCIDD *iddef = NULL;
  403.  
  404.     if (nd)
  405.     {
  406.         iddef = (HSCIDD *) dln_data(nd);
  407.     }
  408.  
  409.     return (iddef);
  410. }
  411.  
  412. /*
  413.  * app_iddef: append new id-definition to iddef-list of a document
  414.  */
  415. HSCIDD *app_iddef(HSCDOC * document, STRPTR iddef_name)
  416. {
  417.     HSCIDD *iddef = NULL;
  418.  
  419.     /* append new id-definition */
  420.     iddef = new_iddef(iddef_name);
  421.     app_dlnode(document->iddefs, (APTR) iddef);
  422. #if 0
  423.     DP(fprintf(stderr, DHP "new id-definition `%s'\n", iddef_name));
  424. #endif
  425.  
  426.     return (iddef);
  427. }
  428.