home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / hdf / unix / hdf3_2r2.lha / HDF3.2r2 / util / he_file.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-10-28  |  14.9 KB  |  724 lines
  1. /***************************************************************************
  2. *
  3. *
  4. *                         NCSA HDF version 3.2r2
  5. *                            October 30, 1992
  6. *
  7. * NCSA HDF Version 3.2 source code and documentation are in the public
  8. * domain.  Specifically, we give to the public domain all rights for future
  9. * licensing of the source code, all resale rights, and all publishing rights.
  10. *
  11. * We ask, but do not require, that the following message be included in all
  12. * derived works:
  13. *
  14. * Portions developed at the National Center for Supercomputing Applications at
  15. * the University of Illinois at Urbana-Champaign, in collaboration with the
  16. * Information Technology Institute of Singapore.
  17. *
  18. * THE UNIVERSITY OF ILLINOIS GIVES NO WARRANTY, EXPRESSED OR IMPLIED, FOR THE
  19. * SOFTWARE AND/OR DOCUMENTATION PROVIDED, INCLUDING, WITHOUT LIMITATION,
  20. * WARRANTY OF MERCHANTABILITY AND WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE
  21. *
  22. ****************************************************************************
  23. */
  24.  
  25. #ifdef RCSID
  26. static char RcsId[] = "@(#)$Revision: 1.5 $";
  27. #endif
  28. /*
  29. $Header: /hdf/hdf/v3.2r2/util/RCS/he_file.c,v 1.5 1992/10/13 20:30:23 koziol beta koziol $
  30.  
  31. $Log: he_file.c,v $
  32.  * Revision 1.5  1992/10/13  20:30:23  koziol
  33.  * Updates for v3.2r2 release
  34.  * .,
  35.  *
  36.  * Revision 1.1  1992/09/18  14:56:22  koziol
  37.  * Initial revision
  38.  *
  39.  * Revision 1.5  1992/09/11  18:32:51  chouck
  40.  * Assorted MAC mungings
  41.  *
  42.  * Revision 1.4  1992/08/26  16:28:28  sxu
  43.  * Fixed a typo, eitor --> editor
  44.  *
  45.  * Revision 1.3  1992/08/24  22:00:44  sxu
  46.  * Added TPU$EDIT as default editor for VMS
  47.  *
  48.  * Revision 1.2  1992/07/15  21:48:48  sxu
  49.  * No change.
  50.  *
  51.  * Revision 1.1  1992/07/06  22:54:16  mlivin
  52.  * Initial revision
  53.  *
  54. */
  55. /* --- he-file.c  --- file and annotation manipulation routines */
  56. #include "he.h"
  57. #ifdef VMS
  58. #   include descrip
  59. #endif
  60.  
  61. #ifdef PROTOTYPE
  62. int HEannotate(HE_CMD *cmd)
  63. #else
  64. int HEannotate(cmd)
  65.     HE_CMD *cmd;
  66. #endif
  67. {
  68.     register int i;
  69.     char *editor = NULL;
  70.     int ann = HE_LABEL;
  71.  
  72.     for (i = 1; i < cmd->argc; i++)
  73.     if (cmd->argv[i][0] == '-')
  74.         switch (findOpt(cmd->argv[i] + 1))
  75.         {
  76.         case HE_HELP:
  77.         puts("annotate [-label|-descriptor] [-editor <editor>]");
  78.         puts("\tEdit an annotation");
  79.         puts("\t-label\t\tEdit label (default)");
  80.         puts("\t-descriptor\tEdit descriptor");
  81.         puts("\t-editor\t\tUse editor (default EDITOR env value)");
  82.         return HE_OK;
  83.         case HE_LABEL:
  84.         ann = HE_LABEL;
  85.         break;
  86.         case HE_DESCRIPTOR:
  87.         ann = HE_DESCRIPTOR;
  88.         break;
  89.         case HE_EDITOR:
  90.         if (++i < cmd->argc) editor = cmd->argv[i];
  91.         break;
  92.         case HE_NOTFOUND:
  93.         unkOpt(cmd->argv[i]);
  94.         return HE_FAIL;
  95.         case HE_AMBIG:
  96.         ambigOpt(cmd->argv[i]);
  97.         return HE_FAIL;
  98.         default:
  99.         irrOpt(cmd->argv[i]);
  100.         return HE_FAIL;
  101.         }
  102.     else
  103.     {
  104.         unkArg(cmd->argv[i]);
  105.         return HE_FAIL;
  106.     }
  107.     return annotate(editor, ann);
  108. }
  109.  
  110. /* Edit annontations (labels and descriptions) for the
  111.  * current data element */
  112. #ifdef PROTOTYPE
  113. int annotate(char *editor, int ann)
  114. #else
  115. int annotate(editor, ann)
  116.     char *editor;        /* editor to use */
  117.     int ann;            /* HE_LABEL  or HE_DESCRIPTOR */
  118. #endif
  119. {
  120.  
  121. #ifndef MAC
  122.  
  123.     int32 len;            /* length of annotation */
  124.     char *buf;            /* annotation buffer */
  125.     char *file;            /* tmp file name */
  126.     register int i;
  127.     int ret;
  128.  
  129.     /* check if any hdf file is open
  130.      */
  131.     if (!fileOpen())
  132.     {
  133.     noFile();
  134.     return HE_FAIL;
  135.     }
  136.  
  137.     /* Get the annotation from hdf file
  138.      */
  139.     len = getAnn(ann, currTag(), he_desc[he_currDesc].ref, &buf);
  140.  
  141.     /* make sure some editor will be used
  142.      * defaults to /usr/bin/ex
  143.      * but should be made a compile time option
  144.      */
  145. /*    if (editor == NULL)
  146.     {
  147.     char *getenv();
  148.     editor = getenv("EDITOR");
  149.     if (editor == NULL) editor = "/usr/bin/ex";
  150.     }
  151. */
  152.     (void) getTmpName(&file);
  153.  
  154.     /* if there is prior annotation, put it into the tmp file
  155.      */
  156.     if (len > 0 && buf != NULL)
  157.     {
  158.     /* doctor the buffer a little for the editors
  159.      */
  160.     if (ann == HE_LABEL)
  161.         buf[len] = '\n';
  162.     else
  163.         len--;
  164.     writeToFile(file, buf, len+1);
  165.     free(buf);
  166.     }
  167.  
  168. #ifndef VMS
  169.    /* make sure some editor will be used
  170.      * defaults to /usr/bin/ex
  171.      * but should be made a comple time option
  172.      */
  173.     if (editor == NULL)
  174.     {
  175.         char *getenv();
  176.         editor = getenv("EDITOR");
  177.         if (editor == NULL) editor = "/usr/bin/ex";
  178.     }
  179.     if (fork() == 0)
  180.     {
  181.     /* this is the child */
  182.     if (execl(editor, editor, file, 0) == -1)
  183.         fprintf(stderr, "Error while editing label.\n");
  184.  
  185.     /* return control to the parent if exec fails
  186.      */
  187.     exit(0);
  188.     }
  189. #else    /* VMS  */
  190.     if (vfork() == 0)
  191.         /* this is the child */
  192.     {
  193.      intn ret_status;
  194.      static $DESCRIPTOR (input_file, file);
  195.      static $DESCRIPTOR (output_file, file);
  196.      ret_status = TPU$EDIT(&input_file, &output_file);
  197.      fprintf( "TPU$EDIT return status: %d. \n",ret_status);
  198.      exit(0);
  199.     }
  200. #endif
  201.     
  202.     /* the parent waits for the child to die */
  203.     wait(0);
  204.  
  205.     /* read in edited annotation
  206.      */
  207.     len = readFromFile(file, &buf);
  208.     if (len <= 0 || buf == NULL) return len;
  209.  
  210.     /* doctor the buffer for standard format
  211.      */
  212.     if (ann == HE_LABEL)
  213.     {
  214.     /* take out control characters from the end */
  215.     for (i = len; i >= 0 && !isgraph(buf[i]); i--)
  216.         ;
  217.     buf[i+1] = '\0';
  218.     }
  219.  
  220.     /* forget the tmp file
  221.      */
  222.     removeFile(file);
  223.  
  224.     /* write annotation to the hdf file
  225.      */
  226.     ret = putAnn(ann, currTag(), he_desc[he_currDesc].ref, buf, len);
  227.     updateDesc();
  228.  
  229.     /* clean up
  230.      */
  231.     free(buf);
  232.     return ret;
  233.  
  234. #else
  235.  
  236.     return 1;
  237.     
  238. #endif /* ndef MAC */    
  239.  
  240. }
  241.  
  242. extern int he_backup;
  243.  
  244. #ifdef PROTOTYPE
  245. int HEopen(HE_CMD *cmd)
  246. #else
  247. int HEopen(cmd)
  248.      HE_CMD *cmd;
  249. #endif
  250. {
  251.   int backup = YES;
  252.   register int i;
  253.   char *file = NULL;
  254.   
  255.   for (i = 1; i < cmd->argc; i++)
  256.     if (cmd->argv[i][0] != '-') {
  257.       if (!file)
  258.         file = cmd->argv[i];
  259.       else
  260.         {
  261.           fprintf(stderr, "Only one file allowed.\n");
  262.           return FAIL;
  263.         }
  264.     }
  265.     else
  266.       switch (findOpt(cmd->argv[i] + 1))
  267.         {
  268.         case HE_HELP:
  269.           puts("open <file> [-nobackup]");
  270.           puts("\t-nobackup\tDon't make a backup for this file.");
  271.           return HE_OK;
  272.         case HE_NOBACKUP:
  273.           backup = 0;
  274.           break;
  275.         case HE_NOTFOUND:
  276.           unkOpt(cmd->argv[i]);
  277.           return FAIL;
  278.         case HE_AMBIG:
  279.           ambigOpt(cmd->argv[i]);
  280.           return FAIL;
  281.         default:
  282.           irrOpt(cmd->argv[i]);
  283.           return FAIL;
  284.         }
  285.   
  286.   if (!file) {
  287.     fprintf(stderr, "Please specify a file name.\n");
  288.     return FAIL;
  289.   }
  290.   
  291.   return openFile(file, backup);
  292. }
  293.  
  294.  
  295. /* openFile -- Internal open file routine. */
  296. /* Called by:    HEopen, main */
  297. /* Returns:    HE_OK and FAIL */
  298. #ifdef PROTOTYPE
  299. int openFile(char *file, int backup)
  300. #else
  301. int openFile(file, backup)
  302.     char *file;
  303.     int backup;
  304. #endif
  305. {
  306.     ASSERT(file);
  307.  
  308.     /* only allow one file at a time */
  309.     if (fileOpen())
  310.     {
  311.     fprintf(stderr,"File: %s is still open. Close before reopening.\n",
  312.         he_file);
  313.     return FAIL;
  314.     }
  315.  
  316.     /* Make backup first if necessary */
  317.     if (backup) {
  318.       if (backupFile(file) < 0)
  319.         return FAIL;
  320.       he_backup = 1;
  321.     }
  322.     else
  323.       he_backup = 0;
  324.     
  325.     if (initFile(file) < 0)
  326.       return FAIL;
  327.     
  328.     return HE_OK;
  329.   }
  330.  
  331.  
  332. /* HEclose -- close current file*/
  333. /* Called by HEdoCmd */
  334. #ifdef PROTOTYPE
  335. int HEclose(HE_CMD *cmd)
  336. #else
  337. int HEclose(cmd)
  338.     HE_CMD *cmd;
  339. #endif
  340. {
  341.     register int i;
  342.     int keep = NO;
  343.  
  344.     for (i = 1; i < cmd->argc; i++)
  345.     if (cmd->argv[i][0] != '-')
  346.     {
  347.         unkArg(cmd->argv[i]);
  348.         return FAIL;
  349.     }
  350.     else
  351.         switch (findOpt(cmd->argv[i] + 1))
  352.         {
  353.         case HE_HELP:
  354.         puts("close [-keep]");
  355.         puts("\t-keep\t\tDon't delete the backup file.");
  356.         return HE_OK;
  357.         case HE_KEEP:
  358.         keep = YES;
  359.         break;
  360.         case HE_NOTFOUND:
  361.         unkOpt(cmd->argv[i]);
  362.         return FAIL;
  363.         case HE_AMBIG:
  364.         ambigOpt(cmd->argv[i]);
  365.         return FAIL;
  366.         default:
  367.         irrOpt(cmd->argv[i]);
  368.         return FAIL;
  369.         }
  370.  
  371.     return closeFile(keep);
  372. }
  373.  
  374. #ifdef PROTOTYPE
  375. int HErevert(HE_CMD *cmd)
  376. #else
  377. int HErevert(cmd)
  378.     HE_CMD *cmd;
  379. #endif
  380. {
  381.     if (cmd->argc < 2)
  382.     return revert();
  383.  
  384.     if (cmd->argv[1][0] != '-' || findOpt(cmd->argv[1]+1) == HE_HELP)
  385.     {
  386.     puts("revert");
  387.     puts("\tDiscard all changes.");
  388.     return HE_OK;
  389.     }
  390.     return HE_FAIL;
  391. }
  392.  
  393. #ifdef PROTOTYPE
  394. int HEwrite(HE_CMD *cmd)
  395. #else
  396. int HEwrite(cmd)
  397.     HE_CMD *cmd;
  398. #endif
  399. {
  400.     register int i;
  401.     char *file;
  402.     uint16 ref = 0;
  403.     uint16 tag = 0;
  404.  
  405.     if (cmd->argc < 2 ||
  406.     (cmd->argv[1][0] == '-' && findOpt(cmd->argv[1]+1) == HE_HELP))
  407.     {
  408.     puts("write <file> [-attachto <atag> <aref>]");
  409.     puts("\tWrite an element or group into another HDF file");
  410.     puts("\t-attchto\tONLY for writing annontations");
  411.     puts("\t\t\tWhat element to attach annotation to");
  412.     return HE_OK;
  413.     }
  414.  
  415.     file = cmd->argv[1];
  416.     for (i = 2; i < cmd->argc; i++)
  417.     if (cmd->argv[i][0] != '-')
  418.         file = cmd->argv[i];
  419.     else
  420.         switch (findOpt(cmd->argv[i] + 1))
  421.         {
  422.         case HE_ATTACHTO:
  423.         tag = (uint16) atoi(cmd->argv[++i]);
  424.         ref = (uint16) atoi(cmd->argv[++i]);
  425.         break;
  426.         case HE_NOTFOUND:
  427.         unkOpt(cmd->argv[i]);
  428.         return HE_FAIL;
  429.         case HE_AMBIG:
  430.         ambigOpt(cmd->argv[i]);
  431.         return HE_FAIL;
  432.         default:
  433.         irrOpt(cmd->argv[i]);
  434.         return HE_FAIL;
  435.         }
  436.     return writ(file, tag, ref);
  437. }
  438.  
  439. #ifdef PROTOTYPE
  440. int writ(char *file, uint16 tag, uint16 ref)
  441. #else
  442. int writ(file, tag, ref)
  443.     char *file;
  444.     uint16 tag;
  445.     uint16 ref;
  446. #endif
  447. {
  448.     int ret;
  449.     uint16 ref1;
  450.  
  451.     if (!fileOpen())
  452.     {
  453.     noFile();
  454.     return HE_FAIL;
  455.     }
  456.     if (!strcmp(file, he_file))
  457.     {
  458.     fprintf(stderr,"Cannot write to self.\n");
  459.     return HE_FAIL;
  460.     }
  461.  
  462.     /* handle special cases */
  463.     if (isAnnot(currTag()))
  464.     return writeAnnot(file, tag, ref);
  465.     if (isGrp(currTag()))
  466.     return writeGrp(file);
  467.  
  468.     if (getNewRef(file, &ref1) < 0)
  469.     return HE_FAIL;
  470.  
  471.     ret = writeElt(file, ref1, he_currDesc);
  472.     return ret;
  473. }
  474.  
  475. /* --------------------------- get a r8 from a file ----------------------- */
  476.  
  477. #ifdef PROTOTYPE
  478. int HEgetR8(HE_CMD *cmd)
  479. #else
  480. int HEgetR8(cmd)
  481.     HE_CMD *cmd;
  482. #endif
  483. {
  484.     register int i;
  485.     int xdim = 0, ydim = 0;
  486.     char *image, *pal = NULL;
  487.     int compress = 0;
  488.  
  489.     if (cmd->argc < 4 || 
  490.     (cmd->argv[1][0] == '-' && findOpt(cmd->argv[1]+1) == HE_HELP))
  491.     {
  492.     puts("getr8 <image> <xdim> <ydim> [-palette <palette>] [-raster|-rle|-imcomp]");
  493.     puts("\tGet a r8 group from raw files");
  494.     puts("\t-palette\tRaw palette file");
  495.     puts("\t-raster\t\tNo compression (default)");
  496.     puts("\t-rle\t\tRun-length compression");
  497.     puts("\t-imcomp\t\tImcomp compression");
  498.     return HE_OK;
  499.     }
  500.     image = cmd->argv[1];
  501.     xdim = atoi(cmd->argv[2]);
  502.     ydim = atoi(cmd->argv[3]);
  503.  
  504.     for (i = 4; i < cmd->argc; i++)
  505.     if (cmd->argv[i][0] == '-')
  506.         switch(findOpt(cmd->argv[i]+1))
  507.         {
  508.         case HE_PALETTE:
  509.         pal = cmd->argv[++i];
  510.         break;
  511.         case HE_RASTER:
  512.         compress = 0;
  513.         break;
  514.         case HE_RLE:
  515.         compress = HE_RLE;
  516.         break;
  517.         case HE_IMCOMP:
  518.         compress = HE_IMCOMP;
  519.         break;
  520.         case HE_NOTFOUND:
  521.         unkOpt(cmd->argv[i]);
  522.         return FAIL;
  523.         case HE_AMBIG:
  524.         ambigOpt(cmd->argv[i]);
  525.         return FAIL;
  526.         default:
  527.         irrOpt(cmd->argv[i]);
  528.         return FAIL;
  529.         }
  530.     else
  531.     {
  532.         unkArg(cmd->argv[i]);
  533.         return FAIL;
  534.     }
  535.  
  536.     if (!image)
  537.     {
  538.     fprintf(stderr,"No image file specified.\n");
  539.     return FAIL;
  540.     }
  541.     if (xdim == 0 || ydim == 0)
  542.     {
  543.     fprintf(stderr,"No dimensions specified.\n");
  544.     return FAIL;
  545.     }
  546.     return getR8(xdim, ydim, image, pal, compress);
  547. }
  548.  
  549. /* --------------- generic put routines ---------------------- */
  550.  
  551. #ifdef PROTOTYPE
  552. int HEput(HE_CMD *cmd)
  553. #else
  554. int HEput(cmd)
  555.     HE_CMD *cmd;
  556. #endif
  557. {
  558.     register int i;
  559.     int verbose = NO;
  560.     char *template = "elt#.@";
  561.  
  562.     for (i = 1; i < cmd->argc; i++)
  563.     if (cmd->argv[i][0] == '-')
  564.         switch (findOpt(cmd->argv[i] + 1))
  565.         {
  566.         case HE_HELP:
  567.         puts("put [-file <file>] [-verbose]");
  568.         puts("\tPut the raw binary of this element in a file");
  569.         puts("\t-file\t\tOut file name (default \"elt#.@\")");
  570.         puts("\t-verbose\tOutput diagnostic info");
  571.         return HE_OK;
  572.         case HE_FILE:
  573.         template = cmd->argv[++i];
  574.         break;
  575.         case HE_VERBOSE:
  576.         verbose = YES;
  577.         break;
  578.         case HE_NOTFOUND:
  579.         unkOpt(cmd->argv[i]);
  580.         return HE_FAIL;
  581.         case HE_AMBIG:
  582.         ambigOpt(cmd->argv[i]);
  583.         return HE_FAIL;
  584.         default:
  585.         irrOpt(cmd->argv[i]);
  586.         return HE_FAIL;
  587.         }
  588.     else
  589.     {
  590.         unkArg(cmd->argv[i]);
  591.         return HE_FAIL;
  592.     }
  593.     return put(template, verbose);
  594. }
  595.  
  596. #ifdef PROTOTYPE
  597. int put(char *template, int verbose)
  598. #else
  599. int put(template, verbose)
  600.     char *template;
  601.     int verbose;
  602. #endif
  603. {
  604.     int length;
  605.     char *data;
  606.     int ret;
  607.  
  608.     length = getElement(he_currDesc, &data);
  609.     if ((length <= 0) || (data == NULL)) return HE_FAIL;
  610.     ret = putWithTempl(template, he_currDesc, length, 1, data, length,
  611.                verbose);
  612.     free(data);
  613.  
  614.     return ret;
  615. }
  616.  
  617. /* ------------------ routines to put an r8 into a file --------------------- */
  618.  
  619. #ifdef PROTOTYPE
  620. int HEputR8(HE_CMD *cmd)
  621. #else
  622. int HEputR8(cmd)
  623.     HE_CMD *cmd;
  624. #endif
  625. {
  626.     register int i;
  627.     int verbose = NO;
  628.     char *image = "img#.@.%";
  629.     char * pal = "pal#";
  630.  
  631.     for (i = 1; i < cmd->argc; i++)
  632.     if (cmd->argv[i][0] == '-')
  633.         switch (findOpt(cmd->argv[i] + 1))
  634.         {
  635.         case HE_HELP:
  636.         puts("putr8 [-image <img>] [-palette <pal>] [-verbose]");
  637.         puts("\tPut an r8 group into raw image and palette files");
  638.         puts("\t-image\t\tImage file name template (default \"img#.@.%\")");
  639.         puts("\t-palette\tPalette file name template (default \"pal#\")");
  640.         puts("\t-verbose\tTo give output of steps taken");
  641.         return HE_OK;
  642.         case HE_IMAGE:
  643.         image = cmd->argv[++i];
  644.         break;
  645.         case HE_PALETTE:
  646.         pal = cmd->argv[++i];
  647.         break;
  648.         case HE_VERBOSE:
  649.         verbose = YES;
  650.         break;
  651.         case HE_NOTFOUND:
  652.         unkOpt(cmd->argv[i]);
  653.         return HE_FAIL;
  654.         case HE_AMBIG:
  655.         ambigOpt(cmd->argv[i]);
  656.         return HE_FAIL;
  657.         default:
  658.         irrOpt(cmd->argv[i]);
  659.         return HE_FAIL;
  660.         }
  661.     else
  662.     {
  663.         unkArg(cmd->argv[i]);
  664.         return HE_FAIL;
  665.     }
  666.     return putR8(image, pal, verbose);
  667. }
  668.  
  669. #ifdef PROTOTYPE
  670. int putR8(char *image, char *pal, int verbose)
  671. #else
  672. int putR8(image, pal, verbose)
  673.     char *image;
  674.     char *pal;
  675.     int verbose;
  676. #endif
  677. {
  678.     int ret;
  679.     int32 xdim, ydim;
  680.     char *palette;
  681.     char *raster;
  682.  
  683.     if (!fileOpen())
  684.     {
  685.     noFile();
  686.     return HE_FAIL;
  687.     }
  688.     if (!isRig(currTag()))
  689.     {
  690.     fprintf(stderr,"Current element not an image group.");
  691.     return HE_FAIL;
  692.     }
  693.     getCurrRig(&xdim, &ydim, &palette, &raster);
  694.     if (raster == NULL)
  695.     {
  696.     fprintf(stderr,"Cannot find raster.\n");
  697.     return HE_FAIL;
  698.     }
  699.     ret = putWithTempl(image, he_currDesc, xdim, ydim, raster, xdim*ydim,
  700.                verbose);
  701.     free(raster);
  702.     if (ret < 0) return HE_FAIL;
  703.     if (palette != NULL)
  704.     {
  705.     register int i;
  706.     char p[HE_PALETTE_SZ];
  707.  
  708.     for (i = 0; i < HE_COLOR_SZ; i++)
  709.     {
  710.         p[i] = *palette++;
  711.         p[HE_COLOR_SZ + i] = *palette++;
  712.         p[2 * HE_COLOR_SZ + i] = *palette++;
  713.     }
  714.     ret = putWithTempl(pal, he_currDesc, xdim, ydim, p,
  715.                HE_PALETTE_SZ, verbose);
  716.     free(palette);
  717.     if (ret < 0) return HE_FAIL;
  718.     }
  719.  
  720.     return HE_OK;
  721. }
  722.  
  723. /* end of he-file.c */
  724.