Exemplos de Error_new em C++ (Cpp)

Exemplo n.º 1

Arquivo: datetime.c Projeto: SilversphereInc/solunar_cmdline

/*=======================================================================
DateTime_new_parse
=======================================================================*/
DateTime *DateTime_new_parse (const char *str, Error **error, const char *tz,
    BOOL utc)
  {
  struct tm tm;
  time_t utime = 0;
  char *oldtz = NULL;

  if (DateTime_parse (str, "%e/%m/%Y %H:%M", &tm)) goto success;
  if (DateTime_parse (str, "%e/%m/%Y", &tm)) goto success;
  if (DateTime_parse (str, "%e/%m %M:M", &tm)) goto success;
  if (DateTime_parse (str, "%e/%m", &tm)) goto success;
  if (DateTime_parse (str, "%b %e %Y %H:%M", &tm)) goto success;
  if (DateTime_parse (str, "%b %e %H:%M", &tm)) goto success;
  if (DateTime_parse (str, "%b %e %Y", &tm)) goto success;
  if (DateTime_parse (str, "%b %e", &tm)) goto success;
  if (DateTime_parse (str, "%H:%M", &tm)) goto success;
  if (DateTime_parse (str, "%j#%Y", &tm)) goto success;

  // Failed
  *error = Error_new ("Can't parse date");
  return NULL;

  success:
  if (utc) tz = "UTC0";
  if (tz)
    {
    oldtz = getenv_dup ("TZ");
    my_setenv ("TZ", tz, 1);
    tzset ();
    }
  utime = mktime (&tm);
  if (tz)
    {
    ////if (oldtz)
      {
      my_setenv ("TZ", oldtz, 1);
      if (oldtz) free (oldtz);
      tzset ();
      }
    //unmy_setenv ("TZ");
    }

  DateTime *dt = DateTime_new_utime (utime);
  return dt;
  }

Exemplo n.º 2

Arquivo: expression.c Projeto: 38/basiclone

Data* parse_term( char** p )
{
	Data* ret = NULL;
	while(1)
	{
		char op;
		int sign;
		if( ret )
		{
			parse_ws(p);
			op = *((*p));
			if( op != '*' && op != '/' ) 
			{
				break; /*last chr should not be parsed*/
			}
			else
				(*p)++;
		}
		sign=parse_sign(p);
		if( sign == 0 ) sign = 1;
		Data* factor = parse_factor(p);
		if( factor->type == TYPE_ERROR )
		{
			dispose(ret);
			return factor; /*throw*/
		}
		if( sign == -1 )
		{
			if( factor->type == TYPE_STRING )
			{
				dispose(factor);
				dispose(ret);
				return Raise(SYNTAX);
			}
			else if( factor->type == TYPE_REAL )
				factor->storage.Real = -factor->storage.Real;
			else
				factor->storage.Integer = - factor->storage.Integer;
		}
		parse_ws(p);
		if( **p == '^' )
		{/*exponent*/
			(*p)++;
			Data* exponent = parse_factor(p);
			factor = temp_var(factor);
			if( exponent->type == TYPE_ERROR )
			{
				dispose(ret);
				dispose(factor);
				return exponent;
			}
			if( exponent->type == TYPE_STRING || factor->type == TYPE_STRING)
			{
				dispose(ret);
				dispose(factor);	
				dispose(exponent);
				return Data_new( TYPE_ERROR , (Storage)Error_new(TYPE_MISMATCH) , 1 );
			}
			if( factor->type == TYPE_INTEGER )
			{
				factor->storage.Real = factor->storage.Integer;
				factor->type = TYPE_REAL;
			}
			if( exponent->type == TYPE_INTEGER )
			{
				factor->storage.Real = factor->storage.Integer;
				factor->type = TYPE_REAL;
			}
			factor->storage.Real = exp( log(factor->storage.Real) * exponent->storage.Real); 
			dispose(exponent);
		}
		
		if( ret == NULL )
			ret = factor;
		else
		{
			ret = temp_var(ret);
			if( ret->type == TYPE_STRING )
			{
				dispose(ret);
				dispose(factor);
				return Raise(TYPE_MISMATCH);
			}
			else
			{
				if( op == '*' )
				{
					if( ret->type == TYPE_REAL || factor->type == TYPE_REAL )
					{
						if( ret->type == TYPE_INTEGER )
						{
							ret->type = TYPE_REAL;
							ret->storage.Real = ret->storage.Integer;
						}
						if( factor->type == TYPE_INTEGER )
						{
							factor->type = TYPE_REAL;
							factor->storage.Real = factor->storage.Integer;
						}
						ret->storage.Real *= factor->storage.Real;
											
					}
					else
						ret->storage.Integer *= factor->storage.Integer;
				}
				else
				{
					if( ret->type == TYPE_INTEGER )
					{
						ret->type = TYPE_REAL;
						ret->storage.Real = ret->storage.Integer;
					}
					if( factor->type == TYPE_INTEGER )
					{
						factor->type = TYPE_REAL;
						factor->storage.Real = factor->storage.Integer;
					}
					if( factor->storage.Real == 0 )
					{
						dispose( ret );
						dispose( factor );
						return Raise(DIV_BY_ZERO);
					}
					ret->storage.Real /= factor->storage.Real;
				}
					
			}
			dispose(factor);
		}
	}
	return ret;
}