Titan Core Initial Contribution

[deliverable/titan.core.git] / xsdconvert / TTCN3Module.cc

///////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2000-2014 Ericsson Telecom AB
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// which accompanies this distribution, and is available at
// http://www.eclipse.org/legal/epl-v10.html
///////////////////////////////////////////////////////////////////////////////
#include "TTCN3Module.hh"

#include "RootType.hh"
#include "SimpleType.hh"
#include "ComplexType.hh"
#include "ImportStatement.hh"
#include "Annotation.hh"

#include "../common/version_internal.h"

#include <ctime>

#if defined(WIN32) && !defined(MINGW)
#include <cygwin/version.h>
#include <sys/cygwin.h>
#include <limits.h>
#endif

extern bool e_flag_used;
extern bool t_flag_used;
extern bool z_flag_used;

TTCN3Module::TTCN3Module(const char * a_filename, XMLParser * a_parser)
: parser(a_parser)
, schemaname()
, modulename()
, definedTypes()
, actualXsdConstruct(c_unknown)
, xsdVersion()
, xsdEncoding()
, xsdStandalone()
, targetNamespace()
, targetNamespace_connectedPrefix()
, declaredNamespaces()
, elementFormDefault(notset)
, attributeFormDefault(notset)
//, importedModules()
, variant()
, moduleNotIntoFile(false)
, moduleNotIntoNameConversion(false)
{
#if defined(WIN32) && !defined(MINGW)
  // Transform a Windows style path: "C:\cygwin\tmp\a.xsd"
  // into a POSIX style path: "/home/a/xsd", so getValueWithoutPrefix('/')
  // can chop off the directory path.
#if CYGWIN_VERSION_DLL_MAJOR >= 1007
  char *posix = NULL;
  ssize_t needed = cygwin_conv_path (CCP_WIN_A_TO_POSIX | CCP_RELATIVE, a_filename, NULL, 0);
  if (needed >= 0) {
    posix = (char*)Malloc(needed);
    if (cygwin_conv_path (CCP_WIN_A_TO_POSIX | CCP_RELATIVE, a_filename, posix, needed)) {
      posix = NULL; // conversion failed
    }
  }
  Mstring filename(posix ? posix : a_filename);
  Free(posix); // even if NULL
#else // Cygwin 1.5
  char posix[PATH_MAX];
  int fail = cygwin_conv_to_posix_path(a_filename, posix);
  Mstring filename(fail ? a_filename : posix);
#endif

#else
  Mstring filename(a_filename);
#endif
  schemaname = filename.getValueWithoutPrefix('/'); // excludes the path of the input file
}

TTCN3Module::~TTCN3Module()
{
  for (List<RootType*>::iterator type = definedTypes.begin(); type; type = type->Next) {
    delete(type->Data);
  }
}

void TTCN3Module::loadValuesFromXMLDeclaration(const char *a_version,
  const char *a_encoding, int a_standalone)
{
  xsdVersion = a_version;
  xsdEncoding = a_encoding;
  xsdStandalone = a_standalone;
}

void TTCN3Module::loadValuesFromSchemaTag(const Mstring& a_targetNamespace,
  List<NamespaceType> a_declaredNamespaces,
  FormValue a_elementFormDefault, FormValue a_attributeFormDefault)
{
  if (a_targetNamespace.empty()) {
    targetNamespace = "NoTargetNamespace";
  }
  else {
    if (a_targetNamespace == "http://www.w3.org/2001/XMLSchema") {
      notIntoFile();
    }
    targetNamespace = a_targetNamespace;
  }

  elementFormDefault = a_elementFormDefault;
  attributeFormDefault = a_attributeFormDefault;

  declaredNamespaces = a_declaredNamespaces;

  for (List<NamespaceType>::iterator ns = declaredNamespaces.begin(); ns; ns = ns->Next)
  {
    if (ns->Data.uri == targetNamespace) {
      targetNamespace_connectedPrefix = ns->Data.prefix;
      break;
    }
  }
}

void TTCN3Module::addMainType(ConstructType typeOfMainType)
{
  switch (typeOfMainType)
  {
  case c_simpleType: {
    SimpleType * new_ST = new SimpleType(parser, this, c_simpleType);
    definedTypes.push_back(new_ST);
    new_ST->loadWithValues();
    break; }
  case c_element: {
    SimpleType * new_ST = new SimpleType(parser, this, c_element);
    definedTypes.push_back(new_ST);
    new_ST->loadWithValues();
    break; }
  case c_attribute: {
    SimpleType * new_ST = new SimpleType(parser, this, c_attribute);
    definedTypes.push_back(new_ST);
    new_ST->loadWithValues();
    break; }
  case c_complexType: {
    ComplexType * new_CT = new ComplexType(parser, this, c_complexType);
    definedTypes.push_back(new_CT);
    new_CT->loadWithValues();
    break; }
  case c_group: {
    ComplexType * new_CT = new ComplexType(parser, this, c_group);
    definedTypes.push_back(new_CT);
    new_CT->loadWithValues();
    break; }
  case c_attributeGroup: {
    ComplexType * new_CT = new ComplexType(parser, this, c_attributeGroup);
    definedTypes.push_back(new_CT);
    new_CT->loadWithValues();
    break; }
  case c_include: {
    ImportStatement * new_INCL = new ImportStatement(parser, this, c_include);
    definedTypes.push_back(new_INCL);
    new_INCL->loadWithValues();
    break; }
  case c_import: {
    ImportStatement * new_IMP = new ImportStatement(parser, this, c_import);
    definedTypes.push_back(new_IMP);
    new_IMP->loadWithValues();
    break; }
  case c_annotation: {
    Annotation * new_ANN = new Annotation(parser, this, c_annotation);
    definedTypes.push_back(new_ANN);
    new_ANN->loadWithValues();
    break; }
  case c_unknown:
  case c_schema:
    break;
  }

  actualXsdConstruct = typeOfMainType;
}

void TTCN3Module::replaceLastMainType(RootType * t)
{
  delete(definedTypes.back());
  definedTypes.pop_back();
  definedTypes.push_back(t);
  actualXsdConstruct = t->getConstruct();
}

void TTCN3Module::generate_TTCN3_header(FILE * file)
{
  time_t time_current = time(NULL);
  fprintf(file,
    "/*******************************************************************************\n"
  );
  if (t_flag_used) {
    fprintf(file,
      "* Copyright Ericsson Telecom AB\n"
      "*\n"
      "* XSD to TTCN-3 Translator\n"
      "*\n"
    );
  }
  else {
    fprintf(file,
      "* Copyright Ericsson Telecom AB %-4d\n"
      "*\n"
      "* XSD to TTCN-3 Translator version: %-40s\n"
      "*\n",
      1900 + (localtime(&time_current))->tm_year,
      PRODUCT_NUMBER
    );
  }
  fprintf(file,
    "* All rights reserved. This program and the accompanying materials\n"
    "* are made available under the terms of the Eclipse Public License v1.0\n"
    "* which accompanies this distribution, and is available at\n"
    "* http://www.eclipse.org/legal/epl-v10.html\n"
    "*******************************************************************************/\n"
    "//\n"
    "//  File:          %s.ttcn\n"
    "//  Description:\n"
    "//  References:\n"
    "//  Rev:\n"
    "//  Prodnr:\n",
    modulename.c_str()
  );
  if (t_flag_used) {
    fprintf(file,
      "//  Updated:\n"
    );
  }
  else {
    fprintf(file,
      "//  Updated:       %s",
      ctime(&time_current)
    );
  }
  fprintf(file,
    "//  Contact:       http://ttcn.ericsson.se\n"
    "//\n"
    "////////////////////////////////////////////////////////////////////////////////\n"
  );
}

void TTCN3Module::generate_TTCN3_fileinfo(FILE * file)
{
  fprintf(file,
    "//\t- %s\n"
    "//\t\t\t/* xml ",
    schemaname.c_str()
  );

  if (!xsdVersion.empty()) {
    fprintf(file, "version = \"%s\" ", xsdVersion.c_str());
  }
  if (!xsdEncoding.empty()) {
    fprintf(file, "encoding = \"%s\" ", xsdEncoding.c_str());
  }

  switch (xsdStandalone)
  {
  case 0:
    fprintf(file, "standalone = \"no\" ");
    break;
  case 1:
    fprintf(file, "standalone = \"yes\" ");
    break;
  default:
    break;
  }

  fprintf(file,
    "*/\n"
    "//\t\t\t/* targetnamespace = \"%s\" */\n",
    targetNamespace.c_str()
  );
}

void TTCN3Module::generate_TTCN3_modulestart(FILE * file)
{
  fprintf(file,
    "module %s {\n"
    "\n"
    "\n"
    "import from XSD all;\n"
    "\n"
    "\n",
    modulename.c_str()
  );
}

void TTCN3Module::generate_TTCN3_import_statements(FILE * file)
{
  for (List<RootType*>::iterator type = definedTypes.begin(); type; type = type->Next)
  {
    if (type->Data->getConstruct() == c_import)
    {
      type->Data->printToFile(file);
    }
  }
}

void TTCN3Module::generate_TTCN3_included_types(FILE * file)
{
  for (List<RootType*>::iterator type = definedTypes.begin(); type; type = type->Next)
  {
    if (type->Data->getConstruct() == c_include)
    {
      type->Data->printToFile(file);
    }
  }
}

void TTCN3Module::generate_TTCN3_types(FILE * file)
{
  for (List<RootType*>::iterator type = definedTypes.begin(); type; type = type->Next)
  {
    if (type->Data->getConstruct() != c_include && type->Data->getConstruct() != c_import)
    {
      type->Data->printToFile(file);
    }
  }
}

void TTCN3Module::generate_with_statement(FILE * file, List<NamespaceType> used_namespaces)
{
  if (e_flag_used) return;

  fprintf(file,
    "with {\n"
    "encode \"XML\";\n"
  );

  bool xsi = false;

  for (List<NamespaceType>::iterator usedNS = used_namespaces.begin(); usedNS; usedNS = usedNS->Next)
  {
    if (usedNS->Data.uri == "http://www.w3.org/2001/XMLSchema") {
      xsi = true;
      continue;
    }
    if (usedNS->Data.uri == "NoTargetNamespace") {
      continue;
    }
// XXX this inner loop is either redundant now, or it should be elsewhere.
// It is quite dodgy to modify(!) namespaces when we are already generating code.
    for (List<NamespaceType>::iterator usedNS2 = usedNS->Next; usedNS2; usedNS2 = usedNS2->Next)
    {
      if (usedNS->Data.uri == usedNS2->Data.uri) {
        if (usedNS2->Data.prefix.empty())
          usedNS2->Data.prefix = usedNS->Data.prefix;
        break;
      }
    }
  }

  if (targetNamespace != "NoTargetNamespace") {
    fprintf(file, "variant \"namespace as \'%s\'", targetNamespace.c_str());
    if (!targetNamespace_connectedPrefix.empty())
      fprintf(file, " prefix \'%s\'", targetNamespace_connectedPrefix.c_str());
    fprintf(file, "\";\n");
  }


  if (xsi) {
    fprintf(file,
      "variant \"controlNamespace \'http://www.w3.org/2001/XMLSchema-instance\' prefix \'xsi\'\";\n");
  }
  if (attributeFormDefault == qualified) {
    fprintf(file,
      "variant \"attributeFormQualified\";\n");
  }
  if (elementFormDefault == qualified) {
    fprintf(file,
      "variant \"elementFormQualified\";\n");
  }
  fprintf(file,
    "}\n");
}

void TTCN3Module::TargetNamespace2ModuleName()
{
  Mstring res(targetNamespace);

  if (z_flag_used) {
    if (res.isFound("http://"))
      for (int i = 0; i != 7; ++i)
        res.eraseChar(0);
    if (res.isFound("urn:"))
      for (int i = 0; i != 4; ++i)
        res.eraseChar(0);
  }

  // the characters ' '(SPACE), '.'(FULL STOP) and '-'(HYPEN-MINUS)
  // and '/', '#', ':' shall all be replaced by a "_" (LOW LINE)
  for (size_t i = 0; i != res.size(); ++i) {
    if ((res[i] == ' ') ||
      (res[i] == '.') ||
      (res[i] == '-') ||
      (res[i] == '/') ||
      (res[i] == '#') ||
      (res[i] == ':'))
    {
      res[i] = '_';
    }
  }
  // any character except "A" to "Z", "a" to "z" or "0" to "9" and "_" shall be removed
  for (size_t i = 0; i != res.size(); ++i) {
    if (!isalpha((const unsigned char)res[i]) && !isdigit((const unsigned char)res[i]) && (res[i] != '_')) {
      res.eraseChar(i);
    }
  }
  // a sequence of two of more "_" (LOW LINE) shall be replaced with a single "_" (LOW LINE)
  for (size_t i = 1; i < res.size(); ++i) {
    while (res[i] == '_' && res[i-1] == '_') {
      res.eraseChar(i--);
    }
  }
  // "_" (LOW LINE) characters occurring at the beginning of the name shall be removed
  if (res[0] == '_') res.eraseChar(0);
  // "_" (LOW LINE) characters occurring at the end of the name shall be removed
  if (res[res.size()-1] == '_') res.eraseChar(res.size()-1);

  if (res.empty()) {
    res = "x";
  }
  else if (isdigit((const unsigned char)res[0])) {
    res.insertChar(0, 'x');
  }

  modulename = res;
}

void TTCN3Module::dump() const
{
  fprintf(stderr, "Module '%s' at %p (from %s)\n",
    modulename.c_str(), (const void*)this, schemaname.c_str());

  for (List<RootType*>::iterator type = definedTypes.begin(); type; type = type->Next)
  {
    type->Data->dump(1);
  }
}