Skip to content

GitLab

C
clean-libraries
Commit 6f476ac6 authored by cvs2snv's avatar cvs2snv
Browse files
Options

This commit was manufactured by cvs2svn to create branch 

'clean-2-0-1-branch'.
parent 6cd38a5f
Pipeline #18958 failed with stages
      in 45 seconds
      Expand all Hide whitespace changes
      Inline Side-by-side
      Showing with 0 additions and 167004 deletions
      ArgEnvUnix/ArgEnv.dcl deleted 100644 → 0
      View file @ 6cd38a5f
      /*
      Version 1.0.1
      Ronny Wichers Schreur
      ronny@cs.kun.nl
      */
      definition module ArgEnv
      :: EnvironmentVariable
      = EnvironmentVariableUndefined
      | EnvironmentVariable !.{#Char}
      // get the value of an environment variable
      getEnvironmentVariable :: !{#Char} -> *EnvironmentVariable
      // get the command line, first element is the command name,
      // arguments that are interpreted by the run-time system
      // (for example to set the heap size) are excluded
      // Clean 1.1: getCommandLine :: {{#Char}}
      getCommandLine :: {.{#Char}}
      ArgEnvUnix/ArgEnv.icl deleted 100644 → 0
      View file @ 6cd38a5f
      implementation module ArgEnv
      import StdEnv
      :: CString :== Int
      NULL :== 0
      :: EnvironmentVariable
      = EnvironmentVariableUndefined
      | EnvironmentVariable !.{#Char}
      getEnv :: !{#Char} -> (!Int, !CString)
      getEnv _
      = code {
      .inline getEnv
      ccall ArgEnvGetEnvironmentVariableC "S-II"
      .end
      }
      getEnvironmentVariable :: !{#Char} -> *EnvironmentVariable
      getEnvironmentVariable name
      | cString == NULL
      = EnvironmentVariableUndefined
      | otherwise
      = EnvironmentVariable (copy size cString)
      where
      (size, cString)
      = getEnv (name +++ "\0")
      copy :: !Int !CString -> {#.Char}
      copy length cString
      = code {
      .inline copy
      | Clean 1.1: use create_array
      | pushC '\000'
      | push_b 1
      | update_b 1 2
      | update_b 0 1
      | pop_b 1
      | create_array CHAR 0 1
      | Clean 1.2 and later: use create_array_
      create_array_ CHAR 0 1
      push_a 0
      ccall ArgEnvCopyCStringToCleanStringC "IS-I"
      pop_b 1
      .end
      }
      getCommandLineCount :: Int
      getCommandLineCount
      = code {
      .inline getCommandLineCount
      ccall ArgEnvGetCommandLineCountC "-I"
      .end
      }
      getCommandLineArgument :: !Int -> (!Int, !Int)
      getCommandLineArgument _
      = code {
      .inline getCommandLineArgument
      ccall ArgEnvGetCommandLineArgumentC "I-II"
      .end
      }
      getArg :: !Int -> {#.Char}
      getArg i
      = copy size cString
      where
      (size, cString)
      = getCommandLineArgument i
      // Clean 1.1: getCommandLine :: {{#Char}}
      getCommandLine :: {.{#Char}}
      getCommandLine
      = {getArg i \\ i <- [0 .. getCommandLineCount-1]}
      ArgEnvUnix/ArgEnvC.c deleted 100644 → 0
      View file @ 6cd38a5f
      /*
      Version 1.0.1
      Ronny Wichers Schreur
      ronny@cs.kun.nl
      */
      # define kVariableSize 1
      # ifndef NULL
      # define NULL ((void *) 0)
      # endif
      /* defined by the Clean run-time system */
      extern int global_argc;
      extern char **global_argv;
      # ifndef _WINDOWS_
      # include <stdlib.h>
      # endif
      typedef struct
      {
      int length;
      char characters [kVariableSize];
      } *CleanString;
      static int
      CStringLength (char *s)
      {
      char *begin;
      begin = s;
      while (*s != '\0')
      s++;
      return (s - begin);
      } /* CStringLength */
      # ifdef _WINDOWS_
      /* return size of environment variable's value (including null-terminator)
      zero if variable doesn't exist */
      int
      ArgEnvGetEnvironmentVariableSizeC (CleanString name)
      {
      char smallBuffer;
      /* Assume that name has been null-terminated in Clean */
      return (GetEnvironmentVariableA (name->characters, &smallBuffer, 0));
      } /* ArgEnvGetEnvironmentVariableSizeC */
      /* copy value of environment variable to Clean string
      return False if value had to be truncated */
      int
      ArgEnvGetEnvironmentVariableCharsC (CleanString value, CleanString name)
      {
      int size, length;
      length = value->length;
      /* Assume that name has been null-terminated in Clean */
      size = GetEnvironmentVariableA (name->characters, value->characters, length);
      if (size <= length)
      {
      size = CStringLength (value->characters);
      if (size <= length)
      value->length = size;
      }
      return (size >= value->length);
      } /* ArgEnvGetEnvironmentVariableCharsC */
      # else /* ifndef _WINDOWS_ */
      void
      ArgEnvGetEnvironmentVariableC (CleanString name, int *sizeP, char **stringP)
      {
      char *value;
      /* Assume that name has been null-terminated in Clean */
      value = getenv (name->characters);
      if (value == NULL)
      *sizeP = 0;
      else
      *sizeP = CStringLength (value);
      *stringP = value;
      } /* ArgEnvGetEnvironmentVariableCharsC */
      # endif /* _WINDOWS_ */
      int
      ArgEnvGetCommandLineCountC (void)
      {
      return (global_argc);
      } /* ArgEnvGetCommandLineCountC */
      void
      ArgEnvGetCommandLineArgumentC (int i, int *sizeP, char **stringP)
      {
      char *arg;
      /* Assume that i is within bounds */
      arg = global_argv [i];
      *sizeP = CStringLength (arg);
      *stringP = arg;
      } /* ArgEnvGetCommandLineArgumentC */
      /* copy C string to Clean string
      return False if string had to be truncated */
      int
      ArgEnvCopyCStringToCleanStringC (char *cString, CleanString cleanString)
      {
      int i, length;
      char *to;
      length = cleanString->length;
      to = cleanString->characters;
      i = 0;
      while (*cString != '\0' && i < length)
      {
      i++;
      *to++ = *cString++;
      }
      cleanString->length = i;
      return (i <= length);
      } /* ArgEnvCopyCStringToCleanStringC */
      ArgEnvUnix/Makefile deleted 100644 → 0
      View file @ 6cd38a5f
      #
      # Version 1.0.1
      # Ronny Wichers Schreur
      # ronny@cs.kun.nl
      #
      CLM=clm
      CC=gcc
      COPTIONS=-Wall -pedantic
      printenv : printenv.o ArgEnv.o ArgEnvC.o
      $(CLM) -b -nt -l ArgEnvC.o printenv -o printenv
      ArgEnvC.o : ArgEnvC.c
      $(CC) $(COPTIONS) -c ArgEnvC.c
      ArgEnv.o : ArgEnv.icl ArgEnv.dcl
      $(CLM) -O ArgEnv
      printenv.o : printenv.icl ArgEnv.dcl
      $(CLM) -O printenv
      cleanup :
      $(RM) printenv *.o *.abc
      ArgEnvUnix/README deleted 100644 → 0
      View file @ 6cd38a5f
      ArgEnv
      Version 1.0.1
      Ronny Wichers Schreur
      ronny@cs.kun.nl
      The ArgEnv package provides a Clean interface to the command line
      arguments and the environment variables.
      This is the README for the Unix version. The Unix version has been
      tested on Solaris 5.5 and Clean 1.1 & 1.3, but it should work with all
      Unix versions with Clean 1.1 or better. To use the package with Clean
      version 1.1 you will have to make a few changes, which are documented
      in the source.
      FILES
      README
      This file
      ArgEnv.dcl
      Definition of the interface
      ArgEnv.icl
      Implementation of the interface
      ArgEnvC.c
      Implementation of the C side of the interface
      Makefile
      Makefile for the ArgEnv interface and the example program
      printenv.icl
      An example program that prints the value of an environment
      variable
      USAGE
      To use the ArgEnv interface you have to link the object module that
      is created from the module ArgEnvC.c.
      If you use clm you should specify this extra object file with the -l
      option:
      % clm -l ArgEnvC.o <your-main-module>
      In the CleanIDE you can add this extra object file to the Object
      Modules section in the Options->Link Options dialogue.
      If you forget this, you will get the link error:
      Undefined first referenced
      symbol in file
      ArgEnvCopyCStringToCleanStringC ArgEnv.o
      ArgEnvGetEnvironmentVariableC ArgEnv.o
      ArgEnvGetCommandLineArgumentC ArgEnv.o
      ArgEnvGetCommandLineCountC ArgEnv.o
      BUGS
      There is no way to stop the Clean run-time system from interpreting
      some of the command-line arguments.
      ArgEnvUnix/printenv.icl deleted 100644 → 0
      View file @ 6cd38a5f
      /*
      Version 1.0.1
      Ronny Wichers Schreur
      ronny@cs.kun.nl
      */
      module printenv
      import StdEnv, ArgEnv
      Start
      | argc == 1
      = format (getEnvironmentVariable argv.[1])
      | otherwise
      = "usage: " +++ argv.[0] +++ " <variable>\n"
      where
      argc
      = size argv - 1
      argv
      = getCommandLine
      format EnvironmentVariableUndefined
      = ""
      format (EnvironmentVariable value)
      = value +++ "\n"
      ArgEnvWindows/ArgEnv.dcl deleted 100644 → 0
      View file @ 6cd38a5f
      /*
      Version 1.0.1
      Ronny Wichers Schreur
      ronny@cs.kun.nl
      */
      definition module ArgEnv
      :: EnvironmentVariable
      = EnvironmentVariableUndefined
      | EnvironmentVariable !.{#Char}
      // get the value of an environment variable
      getEnvironmentVariable :: !{#Char} -> *EnvironmentVariable