home *** CD-ROM | disk | FTP | other *** search
/ back2roots/padua / padua.7z / padua / lang / perl4.035.V010.lzh / perl4.035 / cscript / cscript.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-09-19  |  8.1 KB  |  371 lines
  1. /*********************************************************************
  2.  
  3.     MODULE:      cscript.c
  4.  
  5.     DESCRIPTION: A program to turn a script into an executable
  6.  
  7.     AUTHOR:      Kent Dalton
  8.  
  9.     MODIFIED:
  10.  
  11.     Copyright 1991 by Kent Dalton, all rights reserved.
  12.  
  13. **********************************************************************/
  14.  
  15. /**************************** INCLUDES *******************************/
  16. #include <stdio.h>
  17. #include "macros.h"
  18. #include "cprogram.h"
  19.  
  20. /**************************** CONSTANTS ******************************/
  21. #define DEFINTERP "perl"
  22. #define DEFINTFLAGS  "-I/usr/lib/perl"
  23. #define DEFCOMPILER "gcc"
  24. #define DEFCFLAGS ""
  25. #ifndef TRUE
  26. #define TRUE   1
  27. #define FALSE  0
  28. #endif
  29. #define PROGRAM "cscript"
  30.  
  31. /**************************** TYPEDEFS *******************************/
  32.  
  33. /***************************** MACROS ********************************/
  34. #define vCHECKNEXT(index) {\
  35.      if(argv[index+1] == NULL || (argv[index+1])[0] == '-') { \
  36.         fprintf(stderr, "*** Error - option with missing argument\n"); \
  37.         exit(1); \
  38.   } \
  39. }
  40. /***************************** GLOBALS *******************************/
  41.  
  42. /**************************** EXTERNALS ******************************/
  43.  
  44.  
  45.  
  46. /*********************************************************************
  47.  
  48.     FUNCTION
  49.  
  50.     RETURNS:
  51.  
  52.     DESCRIPTION:
  53.  
  54.     SIDE EFFECTS:
  55.  
  56. **********************************************************************/
  57. int main(argc, argv) 
  58. int argc;
  59. char **argv;
  60. {
  61.     char *pcBuffer=NULL, *pcTmp;
  62.     int iFormBuf=FALSE;
  63.     int iVerbose = FALSE, iFiles = 0;
  64.     int iNoCompile = FALSE;
  65.     char *pcInterp = NULL;
  66.     char *pcFile = NULL;
  67.     char *pcCFile = NULL;
  68.     char *pcHead = NULL;
  69.     char *pcOutput = NULL;
  70.     char acTmp[BUFSIZ];
  71.     int i;
  72.  
  73.     /*** Functions ***/
  74.     void vCreateCFile();
  75.     char *pcUpdateString(),
  76.          *pcCreateHeader(),
  77.          *pcFormOut(),
  78.          *pcParseInterp();
  79.  
  80.     /*** -- ends parsing ***/
  81.     for(i=1; i<argc; i++) {
  82.     if(!iFormBuf && (strcmp(argv[i],"--") == 0)) {
  83.         iFormBuf = TRUE;
  84.     }
  85.     else if(!iFormBuf) {
  86.         if(*argv[i] != '-') {
  87.         iFiles++;
  88.         pcFile = argv[i];
  89.         }
  90.         else {
  91.         switch(*(argv[i]+1)) {
  92.  
  93.             case 'i':
  94.             vCHECKNEXT(i);
  95.             i++;
  96.             pcInterp = argv[i];
  97.             break;
  98.  
  99.             case 'o':
  100.             vCHECKNEXT(i);
  101.             i++;
  102.             pcOutput = argv[i];
  103.             break;
  104.             
  105.             case 'v':
  106.             iVerbose = TRUE;
  107.             break;
  108.             
  109.             case 'c':
  110.             iNoCompile = TRUE;
  111.             break;
  112.  
  113.             default:
  114.             sprintf(acTmp, "Unrecognized option: %s", argv[i]);
  115.             vERROR("Error", acTmp, TRUE, 1);
  116.             break;
  117.              
  118.         }
  119.         }
  120.     }
  121.     else {
  122.         /*** add to buffer ***/
  123.         pcBuffer = pcUpdateString(pcBuffer, argv[i], TRUE);
  124.     }
  125.     }
  126.     if(pcFile == NULL) {
  127.     vERROR("Error", "No file specified", TRUE, 1);
  128.     }
  129.     if(iFiles > 1) {
  130.     vERROR("Error", "Too many files specified", TRUE, 1);
  131.     }
  132.     if((pcOutput=pcFormOut(pcOutput,pcFile)) == NULL) {
  133.     vERROR("Error", "Can't form output name", TRUE, 1);
  134.     }
  135.  
  136.     pcInterp = pcParseInterp(pcFile,pcInterp);
  137.  
  138.     pcCFile = pcUpdateString(pcCFile, pcOutput, FALSE);
  139.     pcCFile = pcUpdateString(pcCFile, ".c", FALSE);
  140.  
  141.     pcHead = pcCreateHeader(pcOutput, pcFile);
  142.  
  143.     vCreateCFile(pcHead, pcCFile, pcOutput, pcInterp, DEFINTFLAGS, pcBuffer);
  144.     if(iNoCompile) exit(0);
  145.  
  146.     sprintf(acTmp, "%s %s -o %s %s", 
  147.         DEFCOMPILER, DEFCFLAGS, pcOutput, pcCFile);
  148.     if(iVerbose)
  149.     fprintf(stderr, "%s\n", acTmp);
  150.     ssystem(acTmp);
  151.     unlink(pcHead);
  152.     unlink(pcCFile);
  153. }
  154.  
  155. /*********************************************************************
  156.  
  157.     FUNCTION: vCreateCFile
  158.  
  159.     RETURNS: void
  160.  
  161.     DESCRIPTION: Creates the requested C File 
  162.  
  163.     SIDE EFFECTS:
  164.  
  165. **********************************************************************/
  166. void vCreateCFile(pcHead, pcCFile, pcOutput, pcInterp, pcFlags, pcArgs)
  167. char *pcHead,
  168.      *pcCFile,
  169.      *pcOutput,
  170.      *pcInterp,
  171.      *pcFlags,
  172.      *pcArgs;
  173. {
  174.     FILE *pFCFile;
  175.     int i;
  176.     char acTmp[BUFSIZ];
  177.  
  178.     vOPENFILE(pFCFile, pcCFile, "w");
  179.  
  180.     fprintf(pFCFile, "/*** C program generated by cscript ***/\n");
  181.     fprintf(pFCFile, "#include <stdio.h>\n");
  182.     fprintf(pFCFile, "#include \"%s\"\n\n\n", pcHead);
  183.     fprintf(pFCFile, "#define SCRIPT \"%s.tmp\"\n", pcOutput);
  184.     fprintf(pFCFile, "#define PROGRAM \"%s\"\n", pcOutput);
  185.     fprintf(pFCFile, "int main(argc, argv)\n  int argc;\n  char **argv;\n");
  186.     fprintf(pFCFile, "{\n  int i;");
  187.     for(i=0; gacCProgram[i] != NULL; i++)
  188.     fprintf(pFCFile, gacCProgram[i]);
  189.     fprintf(pFCFile, 
  190.         "   sprintf(acTmp, \"%s %s %s %%s %%s\", SCRIPT, ((pcArgs == (char *)NULL) ? (char *)\"\": pcArgs));\n", 
  191.         pcInterp,
  192.         ((pcInterp == DEFINTERP) ? pcFlags : " "),
  193.         ((pcArgs == NULL) ? " ":pcArgs));
  194.     fprintf(pFCFile, "   ssystem(acTmp);\n");
  195.     fprintf(pFCFile, "   unlink(SCRIPT);\n");
  196.     fprintf(pFCFile, "}\n");
  197.     fclose(pFCFile);
  198. }
  199.  
  200. /*********************************************************************
  201.  
  202.     FUNCTION
  203.  
  204.     RETURNS:
  205.  
  206.     DESCRIPTION:
  207.  
  208.     SIDE EFFECTS:
  209.  
  210. **********************************************************************/
  211. char *pcUpdateString(pcArgs, pcNew, iFlag)
  212. char *pcArgs;
  213. char *pcNew;
  214. int iFlag;
  215. {
  216.     char *pcTmp = NULL;
  217.  
  218.     if(pcArgs == NULL) {
  219.     if((pcArgs = (char *)malloc(strlen(pcNew)+1)) == NULL) {
  220.         vERROR("Error", "malloc failed", TRUE, 1);
  221.     }
  222.     strcpy(pcArgs, pcNew);
  223.     }
  224.     else {
  225.     if((pcTmp = (char *)malloc(strlen(pcNew)+strlen(pcArgs)+2)) == NULL) {
  226.         vERROR("Error", "malloc failed", TRUE, 1);
  227.     }
  228.     if(iFlag) sprintf(pcTmp,"%s %s", pcArgs, pcNew);
  229.     else      sprintf(pcTmp,"%s%s", pcArgs, pcNew);
  230.     free(pcArgs);
  231.     pcArgs = pcTmp;
  232.     }
  233.     return(pcArgs);
  234. }
  235.  
  236. /*********************************************************************
  237.  
  238.     FUNCTION
  239.  
  240.     RETURNS:
  241.  
  242.     DESCRIPTION:
  243.  
  244.     SIDE EFFECTS:
  245.  
  246. **********************************************************************/
  247. char *pcCreateHeader(pcProgram, pcScript)
  248. char *pcProgram;
  249. char *pcScript;
  250. {
  251.     FILE *pFScript = NULL;
  252.     FILE *pFHeader = NULL;
  253.     char *pcHead = NULL;
  254.     char c;
  255.     char *pcUpdateString();
  256.     
  257.     pcHead = pcUpdateString(pcProgram, ".h", FALSE);
  258.     vOPENFILE(pFHeader, pcHead, "w");
  259.     vOPENFILE(pFScript, pcScript, "r");
  260.    
  261.     fprintf(pFHeader, "char *gacScript[] = {\n\"");
  262.     while(!feof(pFScript)) {
  263.  
  264.     c=(char)fgetc(pFScript);
  265.     if(feof(pFScript)) continue;
  266.  
  267.     switch(c) {
  268.         case '%':
  269.         fputc('%',pFHeader);
  270.         fputc('%',pFHeader);
  271.         break;
  272.         case '\\':
  273.         fputc('\\',pFHeader);
  274.         fputc('\\',pFHeader);
  275.         break;
  276.         case '\"':
  277.         fputc('\\',pFHeader);
  278.         fputc('\"',pFHeader);
  279.         break;
  280.         case '\n':
  281.         fputc('\\',pFHeader);
  282.         fputc('n', pFHeader);
  283.         fputc('\"',pFHeader);
  284.         fputc(',', pFHeader);
  285.         fputc('\n',pFHeader);
  286.         fputc('\"',pFHeader);
  287.         break;
  288.         default:
  289.         fputc(c,pFHeader);
  290.     }
  291.     }
  292.     fprintf(pFHeader, "\\n\",\nNULL\n};");
  293.  
  294.     fclose(pFScript);
  295.     fclose(pFHeader);
  296.  
  297.     return(pcHead);
  298. }
  299.  
  300. /*********************************************************************
  301.  
  302.     FUNCTION
  303.  
  304.     RETURNS:
  305.  
  306.     DESCRIPTION:
  307.  
  308.     SIDE EFFECTS:
  309.  
  310. **********************************************************************/
  311. char *pcFormOut(pcOut, pcFile)
  312. char *pcOut;
  313. char *pcFile;
  314. {
  315.     char *pcTmp;
  316.     int i;
  317.  
  318.     if(pcOut != NULL) return;
  319.  
  320.     vSAVESTR(pcTmp, pcFile);
  321.  
  322.     /*** Try to form file name by stripping extension ***/
  323.     for(i=strlen(pcTmp); i>0; i--) {
  324.     if(pcTmp[i] == '.') {
  325.         pcTmp[i] = '\0';
  326.         return(pcTmp);
  327.     }
  328.     }
  329.     pcTmp = pcUpdateString(pcTmp, ".exe", FALSE);
  330. }
  331.      
  332.  
  333. /*********************************************************************
  334.  
  335.     FUNCTION
  336.  
  337.     RETURNS:
  338.  
  339.     DESCRIPTION:
  340.  
  341.     SIDE EFFECTS:
  342.  
  343. **********************************************************************/
  344. char *pcParseInterp(pcFile, pcInterp)
  345. char *pcFile;
  346. char *pcInterp;
  347. {
  348.     FILE *pF;
  349.     char *pcRet;
  350.     char acStr[BUFSIZ];
  351.     int i;
  352.  
  353.     if(pcInterp != NULL) return(pcInterp);
  354.     
  355.     vOPENFILE(pF, pcFile, "r");
  356.     
  357.     for(fgets(acStr, BUFSIZ, pF); !feof(pF); fgets(acStr, BUFSIZ, pF)) {
  358.     if((acStr[0] == '#') && (acStr[1] == '!')) {
  359.         vSAVESTR(pcRet, &(acStr[2]));
  360.         for(i=0; pcRet[i] != '\0'; i++) 
  361.           if(pcRet[i] == '\n') pcRet[i] = '\0';
  362.         fclose(pF);
  363.         return(pcRet);
  364.     }
  365.     }
  366.  
  367.     fclose(pF);
  368.     return(DEFINTERP);
  369. }
  370.  
  371.