tesla::Parser Class Reference

Detailed Description

A parser for TESLA automata descriptions.

Definition at line 68 of file Parser.h.

#include "Parser.h"

Public Types
typedef std::vector< const clang::ValueDecl * >	RefVector
	Variables referenced by an automaton. More...

Public Member Functions
bool	Parse (llvm::OwningPtr< AutomatonDescription > &Descrip, llvm::OwningPtr< Usage > &Usage)
	Parse the automaton and its usage. More...

Static Public Member Functions
static Parser *	AssertionParser (clang::CallExpr *, clang::ASTContext &)
	Create a Parser for an inline assertion. More...
static Parser *	AutomatonParser (clang::FunctionDecl *, clang::ASTContext &)
	Create a Parser for an automaton description. More...
static Parser *	MappingParser (clang::FunctionDecl *, clang::ASTContext &)
	Create a Parser for a struct-automaton mapping. More...

Member Typedef Documentation

typedef std::vector<const clang::ValueDecl*> tesla::Parser::RefVector

Variables referenced by an automaton.

Definition at line 71 of file Parser.h.

Member Function Documentation

Parser * Parser::AssertionParser ( clang::CallExpr *  , clang::ASTContext &    )

static

Create a Parser for an inline assertion.

Definition at line 51 of file Parser.cpp.

References tesla::INLINE_ASSERTION, and tesla::TeslaContext().

Referenced by tesla::TeslaVisitor::VisitCallExpr().

                                                               {
  assert(Call->getDirectCallee()->getName().compare(INLINE_ASSERTION) == 0);

  OwningPtr<Parser> Bootstrap(new Parser(Ctx));

  if (Call->getNumArgs() != 7) {
    Bootstrap->ReportError(
      "expected seven arguments: "
      "filename, line, counter, context, start, end, expression",
      Call);
    return NULL;
  }

  Expr *Filename    = Call->getArg(0);
  Expr *Line        = Call->getArg(1);
  Expr *Counter     = Call->getArg(2);
  Expr *Context     = Call->getArg(3);
  Expr *Beginning   = Call->getArg(4);
  Expr *End         = Call->getArg(5);
  Expr *Expression  = Call->getArg(6);

  Identifier ID;
  if (!Bootstrap->Parse(ID.mutable_location(), Filename, Line, Counter))
    return NULL;

  AutomatonDescription::Context TeslaContext;
  if (!Bootstrap->Parse(&TeslaContext, Context))
    return NULL;

  Flags RootFlags;
  RootFlags.FnInstrContext = FunctionEvent::Callee;
  RootFlags.OrOperator = BooleanExpr::BE_Or;
  RootFlags.StrictMode = false;

  return new Parser(Ctx, ID, TeslaContext, Beginning, End, Expression, RootFlags);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Parser * Parser::AutomatonParser ( clang::FunctionDecl *  , clang::ASTContext &    )

static

Create a Parser for an automaton description.

Definition at line 89 of file Parser.cpp.

Referenced by tesla::TeslaVisitor::VisitFunctionDecl().

                                                                {
  assert(F != NULL);
  assert(F->doesThisDeclarationHaveABody());

  Identifier ID;
  ID.set_name(F->getName());

  OwningPtr<Parser> Bootstrap(new Parser(Ctx));

  // We should reference one variable: the struct pointer.
  if (F->getNumParams() != 1) {
    Bootstrap->ReportError("expected one parameter: the struct", F);
    return NULL;
  }

  // TODO: programmer-specified context
  AutomatonDescription::Context Context = AutomatonDescription::Global;

  ValueDecl *StructRef = F->getParamDecl(0);

  const PointerType *StructPtrTy = dyn_cast<PointerType>(StructRef->getType());
  if (!StructPtrTy || !StructPtrTy->getPointeeType()->getAsStructureType()) {
    Bootstrap->ReportError("expected pointer to struct", StructRef);
    return NULL;
  }

  Flags RootFlags;
  RootFlags.FnInstrContext = FunctionEvent::Callee;
  RootFlags.OrOperator = BooleanExpr::BE_Xor;
  RootFlags.StrictMode = true;

  return new Parser(Ctx, ID, Context, NULL, NULL, F->getBody(), RootFlags);
}

Here is the caller graph for this function:

Parser * Parser::MappingParser ( clang::FunctionDecl *  , clang::ASTContext &    )

static

Create a Parser for a struct-automaton mapping.

Definition at line 124 of file Parser.cpp.

References tesla::AUTOMATON_USES.

Referenced by tesla::TeslaVisitor::VisitFunctionDecl().

                                                              {
  assert(F != NULL);
  assert(F->doesThisDeclarationHaveABody());

  OwningPtr<Parser> Bootstrap(new Parser(Ctx));

  auto Body = dyn_cast<CompoundStmt>(F->getBody());
  if (!Body) {
    Bootstrap->ReportError("expected a function body (compound statement)", F);
    return NULL;
  }

  if (Body->size() != 1) {
    Bootstrap->ReportError("expected a single statement", F->getBody());
    return NULL;
  }

  auto Ret = dyn_cast<ReturnStmt>(Body->body_back());
  if (!Ret) {
    Bootstrap->ReportError("expected a return statement", Body->body_back());
    return NULL;
  }

  auto Call = dyn_cast<CallExpr>(Ret->getRetValue());
  if (!Call || !Call->getDirectCallee()
      || (Call->getDirectCallee()->getName() != AUTOMATON_USES)) {
    Bootstrap->ReportError("expected call to " + AUTOMATON_USES, Ret);
    return NULL;
  }

  Expr* Args[4];
  const size_t ArgCount = sizeof(Args) / sizeof(Args[0]);

  if (Call->getNumArgs() != ArgCount) {
    Bootstrap->ReportError("expected automaton, locality, start, end", Call);
    return NULL;
  }

  for (size_t i = 0; i < ArgCount; i++)
    Args[i] = Call->getArg(i)->IgnoreImplicit();

  auto Automaton = Bootstrap->ParseStringLiteral(Call->getArg(0));
  if (Automaton.empty()) {
    Bootstrap->ReportError("expected automaton name", Call->getArg(0));
    return NULL;
  }

  auto Locality = dyn_cast<DeclRefExpr>(Call->getArg(1)->IgnoreImplicit());
  if (!Locality) {
    Bootstrap->ReportError("expected TESLA locality", Call->getArg(1));
    return NULL;
  }

  auto Beginning = Call->getArg(2);
  auto End = Call->getArg(3);

  Identifier ID;
  ID.set_name(Automaton);

  AutomatonDescription::Context Context;
  if (!Bootstrap->Parse(&Context, Locality))
    return NULL;

  Flags RootFlags;
  RootFlags.FnInstrContext = FunctionEvent::Callee;

  return new Parser(Ctx, ID, Context, Beginning, End, NULL, RootFlags);
}

Here is the caller graph for this function:

bool tesla::Parser::Parse	(	llvm::OwningPtr< AutomatonDescription > &	Descrip,
		llvm::OwningPtr< Usage > &	Usage
	)

Parse the automaton and its usage.

Parameters

[out]	Descrip	the automaton description will be stored here
[out]	Usage	the usage of the automaton will be stored here

Returns

true on success, false on failure

---

The documentation for this class was generated from the following files:

• tesla/analyser/Parser.h
• tesla/analyser/Parser.cpp