parser_bits.cpp

Go to the documentation of this file.

#ifndef PARSER_BITS_IMPLEMENTATION_FILE
#define PARSER_BITS_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : parser_bits                                                       *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 2000-$now By Author.  This program is free software; you can  *
* redistribute it and/or modify it under the terms of the GNU General Public  *
* License as published by the Free Software Foundation; either version 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include "parser_bits.h"

#include <basis/function.h>
#include <basis/istring.h>
#include <basis/log_base.h>
#include <basis/portable.h>

#include <ctype.h>

#undef LOG
#define LOG(s) STAMPED_EMERGENCY_LOG(program_wide_logger(), s)

bool parser_bits::is_printable_ascii(char to_check)
{ return (to_check >= 32) && (to_check <= 126); }

bool parser_bits::white_space_no_cr(char to_check)
{ return (to_check == ' ') || (to_check == '\t'); }

bool parser_bits::is_eol(char to_check)
{ return (to_check == '\n') || (to_check == '\r'); }

bool parser_bits::white_space(char to_check)
{ return white_space_no_cr(to_check) || is_eol(to_check); }

void parser_bits::translate_CR_for_platform(istring &to_translate)
{
  log_base::line_ending plat_eol = log_base::pick_ending_for_platform();
  bool last_was_lf = false;
  for (int i = 0; i <= to_translate.end(); i++) {
    if (to_translate[i] == '\r') {
      if (last_was_lf) continue;  // ignore two in a row.
      last_was_lf = true;
    } else if (to_translate[i] == '\n') {
      if (last_was_lf) {
        if (plat_eol != log_base::CRLF_AT_END) {
          // fix it, since there was not supposed to be an LF.
          to_translate.zap(i - 1, i - 1);
          i--;
        }
      } else {
        if (plat_eol == log_base::CRLF_AT_END) {
          // fix it, since we're missing an LF that we want.
          to_translate.insert(i, "\r");
          i++;
        }
      }
      last_was_lf = false;
    } else {
      // not the two power characters.
      last_was_lf = false;
    }
  }
}

bool parser_bits::is_hexadecimal(char look_at)
{
  return range_check(look_at, 'a', 'f')
      || range_check(look_at, 'A', 'F')
      || range_check(look_at, '0', '9');
}

bool parser_bits::is_hexadecimal(const char *look_at, int len)
{
  for (int i = 0; i < len; i++)
    if (!is_hexadecimal(look_at[i])) return false;
  return true;
}

bool parser_bits::is_hexadecimal(const istring &look_at, int len)
{ return is_hexadecimal(look_at.observe(), len); }

bool parser_bits::is_alphanumeric(char look_at)
{
  return range_check(look_at, 'a', 'z')
      || range_check(look_at, 'A', 'Z')
      || range_check(look_at, '0', '9');
}

bool parser_bits::is_alphanumeric(const char *look_at, int len)
{
  for (int i = 0; i < len; i++)
    if (!is_alphanumeric(look_at[i])) return false;
  return true;
}

bool parser_bits::is_alphanumeric(const istring &look_at, int len)
{ return is_alphanumeric(look_at.observe(), len); }

bool parser_bits::is_identifier(char look_at)
{
  return range_check(look_at, 'a', 'z')
      || range_check(look_at, 'A', 'Z')
      || range_check(look_at, '0', '9')
      || (look_at == '_');
}

bool parser_bits::is_identifier(const char *look_at, int len)
{
  if (is_numeric(look_at[0])) return false;
  for (int i = 0; i < len; i++)
    if (!is_identifier(look_at[i])) return false;
  return true;
}

bool parser_bits::is_identifier(const istring &look_at, int len)
{ return is_identifier(look_at.observe(), len); }

bool parser_bits::is_numeric(char look_at)
{
  return range_check(look_at, '0', '9') || (look_at == '-');
}

bool parser_bits::is_numeric(const char *look_at, int len)
{
  for (int i = 0; i < len; i++) {
    if (!is_numeric(look_at[i])) return false;
    if ( (i > 0) && (look_at[i] == '-') ) return false;
  }
  return true;
}

bool parser_bits::is_numeric(const istring &look_at, int len)
{ return is_numeric(look_at.observe(), len); }

istring parser_bits::substitute_env_vars(const istring &to_process,
    bool leave_unknown)
{
  istring editing = to_process;

  int indy;  // index of the dollar sign in the string.
  while (true) {
    indy = editing.find('$');
    if (negative(indy)) break;  // all done.
    int q;
    for (q = indy + 1; q < editing.length(); q++) {
      if (!parser_bits::is_identifier(editing[q]))
        break;  // done getting variable name.
    }
    if (q != indy + 1) {
      // we caught something in our environment variable trap...
      istring var_name = editing.substring(indy + 1, q - 1);
//LOG(istring("var name ") + var_name);
      istring value_found = portable::env_string(var_name);
//LOG(istring("val found ") + value_found);
      if (value_found.t()) {
        editing.zap(indy, q - 1);
        editing.insert(indy, value_found);
      } else {
        if (leave_unknown) {
          // that lookup failed.  let's mark it.
          editing[indy] = '?';
            // simple replacement, shows variables that failed.
        } else {
          // replace it with blankness.
          editing.zap(indy, q - 1);
        }
      }
    } else {
      // well, we didn't see a valid variable name, but we don't want to leave
      // the dollar sign in there.
      editing[indy] = '!';  // simple replacement, marks where syntax is bad.
    }

  }

  return editing;
}


#endif //PARSER_BITS_IMPLEMENTATION_FILE

---