示例#1
0
文件: overloadn.C 项目: Nodplus/gcc
int main()
{
  l0001(l); // { dg-error "lvalue" }
  l0010(l); // { dg-error "lvalue" }
  l0011(l); // { dg-error "lvalue" }
  l0100(l);
  l0101(l);
  l0110(l);
  l0111(l);
  l1000(l);
  l1001(l);
  l1010(l);
  l1011(l);
  l1100(l);
  l1101(l);
  l1110(l);
  l1111(l);
  cl0001(cl); // { dg-error "lvalue" }
  cl0011(cl); // { dg-error "lvalue" }
  cl0100(cl);
  cl0101(cl);
  cl0110(cl);
  cl0111(cl);
  cl1001(cl); // { dg-error "lvalue" }
  cl1011(cl); // { dg-error "lvalue" }
  cl1100(cl);
  cl1101(cl);
  cl1110(cl);
  cl1111(cl);
  r0001(r());
  r0010(r());
  r0011(r());
  r0100(r());
  r0101(r());
  r0110(r());
  r0111(r());
  r1001(r());
  r1010(r());
  r1011(r());
  r1100(r());
  r1101(r());
  r1110(r());
  r1111(r());
  cr0001(cr());
  cr0011(cr());
  cr0100(cr());
  cr0101(cr());
  cr0110(cr());
  cr0111(cr());
  cr1001(cr());
  cr1011(cr());
  cr1100(cr());
  cr1101(cr());
  cr1110(cr());
  cr1111(cr());
  nl0001(nl); // { dg-error "lvalue" }
  nl0010(nl); // { dg-error "lvalue" }
  nl0011(nl); // { dg-error "lvalue" }
  nl0100(nl);
  nl0101(nl);
  nl0110(nl);
  nl0111(nl);
  nl1000(nl);
  nl1001(nl);
  nl1010(nl);
  nl1011(nl);
  nl1100(nl);
  nl1101(nl);
  nl1110(nl);
  nl1111(nl);
  ncl0001(ncl); // { dg-error "lvalue" }
  ncl0011(ncl); // { dg-error "lvalue" }
  ncl0100(ncl);
  ncl0101(ncl);
  ncl0110(ncl);
  ncl0111(ncl);
  ncl1001(ncl); // { dg-error "lvalue" }
  ncl1011(ncl); // { dg-error "lvalue" }
  ncl1100(ncl);
  ncl1101(ncl);
  ncl1110(ncl);
  ncl1111(ncl);
  nr0001(nr); // { dg-error "lvalue" }
  nr0010(nr); // { dg-error "lvalue" }
  nr0011(nr); // { dg-error "lvalue" }
  nr0100(nr);
  nr0101(nr);
  nr0110(nr);
  nr0111(nr);
  nr1000(nr);
  nr1001(nr);
  nr1010(nr);
  nr1011(nr);
  nr1100(nr);
  nr1101(nr);
  nr1110(nr);
  nr1111(nr);
  ncr0001(ncr); // { dg-error "lvalue" }
  ncr0011(ncr); // { dg-error "lvalue" }
  ncr0100(ncr);
  ncr0101(ncr);
  ncr0110(ncr);
  ncr0111(ncr);
  ncr1001(ncr); // { dg-error "lvalue" }
  ncr1011(ncr); // { dg-error "lvalue" }
  ncr1100(ncr);
  ncr1101(ncr);
  ncr1110(ncr);
  ncr1111(ncr);
  ul0001(ul()); // { dg-error "lvalue" }
  ul0010(ul()); // { dg-error "lvalue" }
  ul0011(ul()); // { dg-error "lvalue" }
  ul0100(ul());
  ul0101(ul());
  ul0110(ul());
  ul0111(ul());
  ul1000(ul());
  ul1001(ul());
  ul1010(ul());
  ul1011(ul());
  ul1100(ul());
  ul1101(ul());
  ul1110(ul());
  ul1111(ul());
  ucl0001(ucl()); // { dg-error "lvalue" }
  ucl0011(ucl()); // { dg-error "lvalue" }
  ucl0100(ucl());
  ucl0101(ucl());
  ucl0110(ucl());
  ucl0111(ucl());
  ucl1001(ucl()); // { dg-error "lvalue" }
  ucl1011(ucl()); // { dg-error "lvalue" }
  ucl1100(ucl());
  ucl1101(ucl());
  ucl1110(ucl());
  ucl1111(ucl());
  ur0001(ur());
  ur0010(ur());
  ur0011(ur());
  ur0100(ur());
  ur0101(ur());
  ur0110(ur());
  ur0111(ur());
  ur1001(ur());
  ur1010(ur());
  ur1011(ur());
  ur1100(ur());
  ur1101(ur());
  ur1110(ur());
  ur1111(ur());
  ucr0001(ucr());
  ucr0011(ucr());
  ucr0100(ucr());
  ucr0101(ucr());
  ucr0110(ucr());
  ucr0111(ucr());
  ucr1001(ucr());
  ucr1011(ucr());
  ucr1100(ucr());
  ucr1101(ucr());
  ucr1110(ucr());
  ucr1111(ucr());

  return 0;
}
示例#2
0
/* ****************************************************************************
*
* restErrorReplyGet - 
*
* This function renders an error reply depending on the 'request' type.
* Many responses have different syntax and especially the tag in the reply
* differs (registerContextResponse, discoverContextAvailabilityResponse etc).
*
* Also, the function is called from more than one place, especially from 
* restErrorReply, but also from where the payload type is matched against the request URL.
* Where the payload type is matched against the request URL, the incoming 'request' is a
* request and not a response.
*/
std::string restErrorReplyGet(ConnectionInfo* ciP, Format format, std::string indent, std::string request, HttpStatusCode code, std::string details)
{
   std::string   tag = tagGet(request);
   StatusCode    errorCode(code, details, "errorCode");
   std::string   reply;

   ciP->httpStatusCode = SccOk;

   if (tag == "registerContextResponse")
   {
      RegisterContextResponse rcr("000000000000000000000000", errorCode);
      reply =  rcr.render(RegisterContext, format, indent);
   }
   else if (tag == "discoverContextAvailabilityResponse")
   {
      DiscoverContextAvailabilityResponse dcar(errorCode);
      reply =  dcar.render(DiscoverContextAvailability, format, indent);
   }
   else if (tag == "subscribeContextAvailabilityResponse")
   {
      SubscribeContextAvailabilityResponse scar("000000000000000000000000", errorCode);
      reply =  scar.render(SubscribeContextAvailability, format, indent);
   }
   else if (tag == "updateContextAvailabilitySubscriptionResponse")
   {
      UpdateContextAvailabilitySubscriptionResponse ucas(errorCode);
      reply =  ucas.render(UpdateContextAvailabilitySubscription, format, indent, 0);
   }
   else if (tag == "unsubscribeContextAvailabilityResponse")
   {
      UnsubscribeContextAvailabilityResponse ucar(errorCode);
      reply =  ucar.render(UnsubscribeContextAvailability, format, indent);
   }
   else if (tag == "notifyContextAvailabilityResponse")
   {
      NotifyContextAvailabilityResponse ncar(errorCode);
      reply =  ncar.render(NotifyContextAvailability, format, indent);
   }

   else if (tag == "queryContextResponse")
   {
      QueryContextResponse qcr(errorCode);
      reply =  qcr.render(QueryContext, format, indent);
   }
   else if (tag == "subscribeContextResponse")
   {
      SubscribeContextResponse scr(errorCode);
      reply =  scr.render(SubscribeContext, format, indent);
   }
   else if (tag == "updateContextSubscriptionResponse")
   {
      UpdateContextSubscriptionResponse ucsr(errorCode);
      reply =  ucsr.render(UpdateContextSubscription, format, indent);
   }
   else if (tag == "unsubscribeContextResponse")
   {
      UnsubscribeContextResponse uncr(errorCode);
      reply =  uncr.render(UnsubscribeContext, format, indent);
   }
   else if (tag == "updateContextResponse")
   {
      UpdateContextResponse ucr(errorCode);
      reply = ucr.render(UpdateContext, format, indent);
   }
   else if (tag == "notifyContextResponse")
   {
      NotifyContextResponse ncr(errorCode);
      reply =  ncr.render(NotifyContext, format, indent);
   }
   else if (tag == "StatusCode")
   {
     StatusCode sc(code, details);
     reply = sc.render(format, indent);
   }
   else
   {
      OrionError orionError(errorCode);

      LM_E(("Unknown tag: '%s', request == '%s'", tag.c_str(), request.c_str()));
      
      reply = orionError.render(format, indent);
   }

   return reply;
}
示例#3
0
文件: overload.C 项目: 0day-ci/gcc
int main()
{
  //l0001(l);
  //l0010(l);
  //l0011(l);
  l0100(l);
  l0101(l);
  l0110(l);
  l0111(l);
  l1000(l);
  l1001(l);
  l1010(l);
  l1011(l);
  l1100(l);
  l1101(l);
  l1110(l);
  l1111(l);
  //cl0001(cl);
  //cl0011(cl);
  cl0100(cl);
  cl0101(cl);
  cl0110(cl);
  cl0111(cl);
  //cl1001(cl);
  //cl1011(cl);
  cl1100(cl);
  cl1101(cl);
  cl1110(cl);
  cl1111(cl);
  r0001(r());
  r0010(r());
  r0011(r());
  r0100(r());
  r0101(r());
  r0110(r());
  r0111(r());
  r1001(r());
  r1010(r());
  r1011(r());
  r1100(r());
  r1101(r());
  r1110(r());
  r1111(r());
  cr0001(cr());
  cr0011(cr());
  cr0100(cr());
  cr0101(cr());
  cr0110(cr());
  cr0111(cr());
  cr1001(cr());
  cr1011(cr());
  cr1100(cr());
  cr1101(cr());
  cr1110(cr());
  cr1111(cr());
  //nl0001(nl);
  //nl0010(nl);
  //nl0011(nl);
  nl0100(nl);
  nl0101(nl);
  nl0110(nl);
  nl0111(nl);
  nl1000(nl);
  nl1001(nl);
  nl1010(nl);
  nl1011(nl);
  nl1100(nl);
  nl1101(nl);
  nl1110(nl);
  nl1111(nl);
  //ncl0001(ncl);
  //ncl0011(ncl);
  ncl0100(ncl);
  ncl0101(ncl);
  ncl0110(ncl);
  ncl0111(ncl);
  //ncl1001(ncl);
  //ncl1011(ncl);
  ncl1100(ncl);
  ncl1101(ncl);
  ncl1110(ncl);
  ncl1111(ncl);
  //nr0001(nr);
  //nr0010(nr);
  //nr0011(nr);
  nr0100(nr);
  nr0101(nr);
  nr0110(nr);
  nr0111(nr);
  nr1000(nr);
  nr1001(nr);
  nr1010(nr);
  nr1011(nr);
  nr1100(nr);
  nr1101(nr);
  nr1110(nr);
  nr1111(nr);
  //ncr0001(ncr);
  //ncr0011(ncr);
  ncr0100(ncr);
  ncr0101(ncr);
  ncr0110(ncr);
  ncr0111(ncr);
  //ncr1001(ncr);
  //ncr1011(ncr);
  ncr1100(ncr);
  ncr1101(ncr);
  ncr1110(ncr);
  ncr1111(ncr);
  //ul0001(ul());
  //ul0010(ul());
  //ul0011(ul());
  ul0100(ul());
  ul0101(ul());
  ul0110(ul());
  ul0111(ul());
  ul1000(ul());
  ul1001(ul());
  ul1010(ul());
  ul1011(ul());
  ul1100(ul());
  ul1101(ul());
  ul1110(ul());
  ul1111(ul());
  //ucl0001(ucl());
  //ucl0011(ucl());
  ucl0100(ucl());
  ucl0101(ucl());
  ucl0110(ucl());
  ucl0111(ucl());
  //ucl1001(ucl());
  //ucl1011(ucl());
  ucl1100(ucl());
  ucl1101(ucl());
  ucl1110(ucl());
  ucl1111(ucl());
  ur0001(ur());
  ur0010(ur());
  ur0011(ur());
  ur0100(ur());
  ur0101(ur());
  ur0110(ur());
  ur0111(ur());
  ur1001(ur());
  ur1010(ur());
  ur1011(ur());
  ur1100(ur());
  ur1101(ur());
  ur1110(ur());
  ur1111(ur());
  ucr0001(ucr());
  ucr0011(ucr());
  ucr0100(ucr());
  ucr0101(ucr());
  ucr0110(ucr());
  ucr0111(ucr());
  ucr1001(ucr());
  ucr1011(ucr());
  ucr1100(ucr());
  ucr1101(ucr());
  ucr1110(ucr());
  ucr1111(ucr());

  return 0;
}