Beispiel #1
0
/* ----------------------------------------------------------------------------
   function:            myfloor_()         author:              Andrew Cave
   creation date:       08-Oct-1987        last modification:   ##-###-####
   arguments:           none .
   description:

   See PostScript reference manual page 157.

---------------------------------------------------------------------------- */
Bool myfloor_(ps_context_t *pscontext)
{
  int32 ssize ;
  OBJECT *theo ;

  UNUSED_PARAM(ps_context_t *, pscontext) ;

  ssize = theStackSize( operandstack ) ;
  if ( EmptyStack( ssize ))
    return error_handler( STACKUNDERFLOW ) ;

  theo = TopStack( operandstack , ssize ) ;

  if ( oType(*theo) == OREAL ) {
    int32 iarg ;
    SYSTEMVALUE arg ;

    arg = ( SYSTEMVALUE )oReal(*theo) ;
    if ( !intrange(arg) )
      return TRUE ;

    iarg = ( int32 )arg ;
    if ( iarg <= 0 && arg < 0.0 && ( SYSTEMVALUE )iarg - arg != 0.0 )
      --iarg ;
    oReal(*theo) = ( USERVALUE )iarg ;
    theLen(*theo) = 0 ;
    return TRUE ;
  }
  else if ( oType(*theo) == OINTEGER ||
            oType(*theo) == OINFINITY )
    return TRUE ;
  else
    return error_handler( TYPECHECK ) ;
}
Beispiel #2
0
double Executor::run(const grammar::Program& program, 
                     runtime::Dispatcher& dispatcher,
                     const expression::Context& context) {
  std::stack<double> stack;
  for (grammar::Program::const_iterator i = program.begin(); 
                                        i != program.end(); ++i) {
    const std::string g = *i;
    assert(!g.empty());
    if (g[0] == '@') {
      const std::string func = g.substr(1);
      int nb_args = dispatcher.nb_args(func);
      function::Arguments args(nb_args);
      for (function::Arguments::reverse_iterator j = args.rbegin(); 
                                                 j != args.rend(); ++j) {
        if (stack.empty())
          throw EmptyStack(func);
        *j = stack.top();
        stack.pop();
      }
      stack.push(dispatcher.call(func, args));
    } else if (g[0] == '#') {
      const std::string name = g.substr(1);
      expression::Context::const_iterator j = context.find(name);
      double value = j != context.end() ? j->second : 0.0;
      stack.push(value);
    } else {
      stack.push(fromString<double>(g));
    }
  }
  assert(stack.size() == 1);
  double result = stack.top();
  stack.pop();
  return result;
}
Beispiel #3
0
ItemType StackType::Top()
// Returns a copy of the top item in the stack.
// Pre:  Stack has been initialized.
// Post: If stack is empty, EmptyStack exception is thrown;
//       else a copy of the top element is returned.
{
  if (IsEmpty())
    throw EmptyStack();
  else
    return topPtr->info;  
}
Beispiel #4
0
void StackType::Pop()
// Removes top item from Stack and returns it in item.
// Pre:  Stack has been initialized.
// Post: If stack is empty, EmptyStack exception is thrown;
//       else top element has been removed.
{
  if (IsEmpty())
    throw EmptyStack();
  else
  {  
    NodeType* tempPtr;
    tempPtr = topPtr;
    topPtr = topPtr->next;
    delete tempPtr;
  }
}
void InOrder_Non_Recursion(BiTree *bt)
{
	Stack *S;
	BiTree *p;
	S = Initstack();
	p = bt;
	while (p || !EmptyStack(S))
	{
		while (p)
		{
			push(S, p);
			p = p->lchild;
		}
		pop(S, &p);
		printf("%c", p->data);
		p = p->rchild;
	}
}
Beispiel #6
0
Bool string_(ps_context_t *pscontext)
{
  register int32 ssize ;
  register OBJECT *theo ;

  UNUSED_PARAM(ps_context_t *, pscontext) ;

  ssize = theStackSize( operandstack ) ;
  if ( EmptyStack( ssize ))
    return error_handler( STACKUNDERFLOW ) ;

  theo = TopStack( operandstack , ssize ) ;
  if ( oType(*theo) != OINTEGER )
    return error_handler( TYPECHECK ) ;
  ssize = oInteger(*theo) ;

/* Setup string and initialise strings elements to zero. */
  return ps_string(theo, NULL, ssize) ;
}
Beispiel #7
0
/*----------------------------------------------------------------------------------------------
	${IActionHandler#Commit}
----------------------------------------------------------------------------------------------*/
STDMETHODIMP ActionHandler::Commit()
{
	BEGIN_COM_METHOD;

	HRESULT hr = E_FAIL;
	HRESULT hrFinal = S_OK;
	if (m_vquact.Size())
	{
		// JohnT 10/22/01: this can happen, typically if the only thing in the sequence is a
		// position mark. We could try to check for that but it doesn't seem worth it. Nothing
		// actually depends on having at least one sequence start here.
		//Assert(m_viSeqStart.Size() > 0);

		// Commit all actions.
		for (int i = 0; i <= m_iuactCurr; i++)
		{
			// If for some reason, we cannot commit an action that is part of a sequence, it's
			// just too bad.  We can't undo a commited action so we might as well just amble on
			// and hope for the best.
			IgnoreHr(hr = m_vquact[i]->Commit());
			if (FAILED(hr))
			{
				hrFinal = hr;
			}
		}

		EmptyStack();
	}

#ifdef DEBUG_ACTION_HANDLER
	StrAnsi sta;
	sta.Format("Commit:");
	sta.FormatAppend(" m_iCurrSeq=%d, m_viSeqStart=%d, m_iuactCurr=%d, m_vquact=%d, m_viMarks=%d, m_nDepth=%d\n",
		m_iCurrSeq, m_viSeqStart.Size(), m_iuactCurr, m_vquact.Size(), m_viMarks.Size(), m_nDepth);
	::OutputDebugStringA(sta.Chars());
#endif//DEBUG_ACTION_HANDLER

	return hrFinal;

	END_COM_METHOD(g_factActh, IID_IActionHandler);
}
Beispiel #8
0
main()
{
	int i;
	int temp;
	int arr[8] = {49,38,65,97,76,13,27,49};
	int pivotloc;
	
	SqStack sta;//初始化栈
	InitStack(&sta);
	Data data={0,7};
	Data get;
	Push(&sta,(Elem)data);//0,7进栈
	
	
	while(EMPTY!=EmptyStack(&sta))
	{
		GetTop(&sta,(pElem)(&get));
		Pop(&sta);
		pivotloc = Partition(arr,get.low,get.high);
		
		temp = get.high;
		get.high = pivotloc-1;
		if(get.low<get.high)
		{
			Push(&sta,(Elem)get);
		}
		
		get.low = pivotloc+1;
		get.high = temp;
		if(get.low<get.high)
		{
			Push(&sta,(Elem)get);
		}
	}
	for(i=0;i<8;i++)
	{
		printf("%d ",arr[i]);
	}
	printf("\n");
	
}
Beispiel #9
0
/* ----------------------------------------------------------------------------
   function:            mysqrt_()          author:              Andrew Cave
   creation date:       08-Oct-1987        last modification:   ##-###-####
   arguments:           none .
   description:

   See PostScript reference manual page 224.

---------------------------------------------------------------------------- */
Bool mysqrt_(ps_context_t *pscontext)
{
  register int32 ssize ;
  register OBJECT *theo ;
  register SYSTEMVALUE arg ;

  UNUSED_PARAM(ps_context_t *, pscontext) ;

  ssize = theStackSize( operandstack ) ;
  if ( EmptyStack( ssize ))
    return error_handler( STACKUNDERFLOW ) ;

  theo = TopStack( operandstack , ssize ) ;

  /* Do NOT use object_get_numeric, because of different behaviour with
     OINFINITY. */
  switch ( oType(*theo)) {
  case OREAL :
    arg = ( SYSTEMVALUE )oReal(*theo) ;
    break ;
  case OINTEGER :
    arg = ( SYSTEMVALUE )oInteger(*theo) ;
    break ;
  case OINFINITY :
    return TRUE ;
  default:
    return error_handler( TYPECHECK ) ;
  }
/*  Check for validity of argument. */
  if ( arg < 0.0 )
    return error_handler( RANGECHECK ) ;

  theTags(*theo) = OREAL | LITERAL ;
  oReal(*theo) = ( USERVALUE )sqrt(( double )arg ) ;
  theLen(*theo) = 0 ;
  return TRUE ;
}
Beispiel #10
0
symbol StackType::Top() const
{
	if(IsEmpty())
		throw EmptyStack();
	return items[top];
}
Beispiel #11
0
void StackType::Pop()
{
	if(IsEmpty())
		throw EmptyStack();
	top--;
}
Beispiel #12
0
ItemType StackType::Top()
{
  if (IsEmpty())
    throw EmptyStack();
  return items[top];
}    
Beispiel #13
0
/*----------------------------------------------------------------------------------------------
	${IActionHandler#Redo}
----------------------------------------------------------------------------------------------*/
STDMETHODIMP ActionHandler::Redo(UndoResult * pures)
{
	BEGIN_COM_METHOD;
	ChkComArgPtr(pures);

	*pures = kuresSuccess;
	// Do not allow actions to be redone if they have not been undone.
	Assert(m_viSeqStart.Size() > 0);
	Assert(m_iCurrSeq <= m_viSeqStart.Size() - 1);

	m_fCanContinueTask = false; // Can't 'continue' the previous task from before the Undo.
	m_fUndoOrRedoInProgress = true;
	HRESULT hrFinal = S_OK;
	int iSeqToRedo = m_iCurrSeq + 1;

	try // to ensure in progress gets cleared.
	{
		int handle;
		// Start a 'transaction' if possible to group together all the stuff we're going to Undo.
		if (m_qundg)
		{
			m_qundg->BeginGroup(&handle);
		}

		// Determine the last action to be redone; The last action to redo is the action
		// before the next redo sequence. Or the last existing action if there is not a
		// redo sequence after the sequence we are about to redo.
		int iLastRedoAct = m_vquact.Size() - 1;
		if (iSeqToRedo <= m_viSeqStart.Size() - 2)
			iLastRedoAct = m_viSeqStart[iSeqToRedo + 1] - 1;

		// Loop through all of the actions that are about to be redone and see if any of them
		// require a refresh.
		for (int i = m_viSeqStart[iSeqToRedo]; i <= iLastRedoAct; i++)
		{
			CheckHr(m_vquact[i]->put_SuppressNotification(true));
		}

		// Redo all the actions in the next action sequence that change data.
		hrFinal = CallRedo(pures, true, iSeqToRedo, iLastRedoAct);

		// Now do all the PropChangeds
		for (int i = m_viSeqStart[iSeqToRedo]; i <= iLastRedoAct; i++)
		{
			CheckHr(m_vquact[i]->put_SuppressNotification(false));
		}

		// REVIEW (TimS/EberhardB): What do we do if the call to CallRedo above failed somewhere?
		// Should we do this at all? Or just until the failed action? Or everything?
		UndoResult uresTmp = kuresSuccess;
		// Redo all the actions in the next action sequence that don't change data.
		HRESULT hr;
		IgnoreHr(hr = CallRedo(&uresTmp, false, iSeqToRedo, iLastRedoAct));
		if (FAILED(hr))
		{
			hrFinal = hr;
			*pures = uresTmp;
		}
		else if (uresTmp == kuresFailed)
		{
			*pures = uresTmp;
		}

		// dlh testing
		if (*pures == kuresError || * pures == kuresFailed)
		{
			if (m_qundg)
				m_qundg->CancelGroup(handle);
			EmptyStack();
		}
		else // normal success case
		{
			// Set the current sequence and action.
			m_iCurrSeq++;
			m_iuactCurr = m_vquact.Size() - 1;
			if (m_iCurrSeq < m_viSeqStart.Size() - 1)
			{
				m_iuactCurr = m_viSeqStart[m_iCurrSeq + 1] - 1;
			}
			if (m_qundg)
				m_qundg->EndGroup(handle);
		}


#ifdef DEBUG_ACTION_HANDLER
		StrAnsi sta;
		sta.Format("Redo:");
		sta.FormatAppend(" m_iCurrSeq=%d, m_viSeqStart=%d, m_iuactCurr=%d, m_vquact=%d, m_viMarks=%d, m_nDepth=%d\n",
			m_iCurrSeq, m_viSeqStart.Size(), m_iuactCurr, m_vquact.Size(), m_viMarks.Size(), m_nDepth);
		::OutputDebugStringA(sta.Chars());
#endif //DEBUG_ACTION_HANDLER
	}
	catch(...)
	{
		m_fUndoOrRedoInProgress = false;
		throw;
	}
	m_fUndoOrRedoInProgress = false;

	return hrFinal;

	END_COM_METHOD(g_factActh, IID_IActionHandler);
}
Beispiel #14
0
/*----------------------------------------------------------------------------------------------
	${IActionHandler#Undo}
----------------------------------------------------------------------------------------------*/
STDMETHODIMP ActionHandler::Undo(UndoResult * pures)
{
	BEGIN_COM_METHOD;
	ChkComArgPtr(pures);

	*pures = kuresSuccess;

	Assert(m_iCurrSeq >= 0);
	Assert(m_vquact.Size() > 0);

	HRESULT hr = E_FAIL;
	HRESULT hrFinal = S_OK;

	m_fCanContinueTask = false; // Can't 'continue' the previous task from before the Undo.
	m_fUndoOrRedoInProgress = true;

	try // to ensure in progress gets cleared.
	{
		int handle;
		// Start a 'transaction' if possible to group together all the stuff we're going to Undo.
		if (m_qundg)
		{
			m_qundg->BeginGroup(&handle);
		}

		// Loop through all of the actions that are about to be undone and see if any of them
		// require a refresh.
		Vector<long> vhvoCreatedObjects;
		for (int i = m_iuactCurr; (m_iCurrSeq >= 0) && (i >= m_viSeqStart[m_iCurrSeq]); i--)
		{
			CheckHr(m_vquact[i]->put_SuppressNotification(true));
		}

		// Undo all actions from the current action back to the first action of the current action
		// sequence.
		bool fRedoable = true;
		IgnoreHr(hrFinal = CallUndo(pures, fRedoable, true));

		// Now do all the PropChangeds
		for (int i = m_iuactCurr; (m_iCurrSeq >= 0) && (i >= m_viSeqStart[m_iCurrSeq]); i--)
		{
			CheckHr(m_vquact[i]->put_SuppressNotification(false));
		}

		// REVIEW (TimS/EberhardB): What do we do if the call to CallUndo above failed somewhere?
		// Should we do this at all? Or just until the failed action? Or everything?
		UndoResult uresTmp;
		IgnoreHr(hr = CallUndo(&uresTmp, fRedoable, false));
		if (FAILED(hr))
		{
			hrFinal = hr;
			*pures = uresTmp;
		}
		else if (uresTmp == kuresFailed)
		{
			*pures = uresTmp;
		}

		// dlh testing
		if (*pures == kuresError || * pures == kuresFailed)
		{
			if (m_qundg)
				m_qundg->CancelGroup(handle);
			EmptyStack();
		}
		else // normal success case
		{
			// Set the current action and start of the current action sequence.
			if (m_iCurrSeq >= 0)
			{
				m_iuactCurr = m_viSeqStart[m_iCurrSeq] - 1;
				m_iCurrSeq = m_iCurrSeq - 1;
			}
			if (m_qundg)
				m_qundg->EndGroup(handle);
		}

		// Delete any marks that now point after current undo action
		CleanUpMarks();

		if (!fRedoable)
			CleanUpRedoActions(true);

#ifdef DEBUG_ACTION_HANDLER
		StrAnsi sta;
		sta.Format("Undo:");
		sta.FormatAppend(" m_iCurrSeq=%d, m_viSeqStart=%d, m_iuactCurr=%d, m_vquact=%d, m_viMarks=%d, m_nDepth=%d\n",
			m_iCurrSeq, m_viSeqStart.Size(), m_iuactCurr, m_vquact.Size(), m_viMarks.Size(), m_nDepth);
		::OutputDebugStringA(sta.Chars());
#endif//DEBUG_ACTION_HANDLER
	}
	catch(...)
	{
		CleanUpMarks();
		m_fUndoOrRedoInProgress = false;
		throw;
	}
	m_fUndoOrRedoInProgress = false;

	return hrFinal;

	END_COM_METHOD(g_factActh, IID_IActionHandler);
}
Beispiel #15
0
//输入表达式并计算结果
double CalculateExp(void)
{
	double result, tempNum1, tempNum2;
	double data = 0, expn;
	char ch, topSign, point = 'n', num = 'n';
	OPTR *sign;
	OPRD *number;

	InitStack(OPTR, &sign);
	InitStack(OPRD, &number);
	PushStack(sign, '#');
	printf("请输入表达式:");
	ch = getchar();
	GetStackTop(sign, &topSign);

	while(ch != '#' || topSign != '#'){
		if ('0' <= ch && ch <= '9' || ch == '.'){
			if (ch == '.' && point == 'y'){
				printf("表达式输入有误!\n");
				exit(-1);
			}
			else if (ch == '.' && point == 'n'){
				point = 'y';
				expn = 0.1;
			}
			else{
				if (point == 'y'){
					data = data + expn * (ch - '0');
					expn *= 0.1;
				}
				else{
					data = data * 10 + (ch - '0');
				}
				num = 'y';
			}
			ch = getchar();
		}
		else if (ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '(' || ch == ')' || ch == '#'){
			if (num == 'y'){
				PushStack(number, data);
				num = 'n';	point = 'n';
				data = 0;
			}
			GetStackTop(sign, &topSign);
			switch(compare(ch, topSign)){
				case '<':		//扫描运算符优先级小于栈顶元素
					PopStack(sign, &topSign);
					PopStack(number, &tempNum1);
					PopStack(number, &tempNum2);
					switch(topSign){
						case '+':	result = tempNum1 + tempNum2;	break;
						case '-':	result = tempNum1 - tempNum2;	break;
						case '*':	result = tempNum1 * tempNum2;	break;
						case '/':	result = tempNum2 / tempNum1;	break;
					}
					PushStack(number, result);
					break;
				case '>':		//扫描运算符优先级大于栈顶元素
					PushStack(sign, ch);
					ch = getchar();
					break;
				case '=':		//扫描运算符为右括号,匹配到了左括号
					PopStack(sign, &topSign);
					ch = getchar();
					break;
			}
		}
		else if (ch == '\n'){
			ch = '#';
		}
		else{
			printf("输入的表达式有误!\n");
			exit(-1);
		}
		GetStackTop(sign, &topSign);
	}
	PopStack(number, &result);	//将结果从栈中取出来
	if (!EmptyStack(number)){   //如果取出后栈不为空则表示输入的表达式不正确
		printf("表达式有误!\n");
		exit(-1);
	}
	
	return result;
}
void ResetNeighbourUpdates(NeighbourUpdate* neighbourUpdate)
{
  EmptyStack(neighbourUpdate->m_Pointers);
  EmptyStack(neighbourUpdate->m_Old);
}