Hi
Installed on mac os x 10.11.5
with
sudo pip install jiphy
[no errors]
Here is a run sequence that failed (no output, app hangs):
jiphy -o py -i js express2xml.js
^CTraceback (most recent call last):
File "/usr/local/bin/jiphy", line 9, in
load_entry_point('jiphy==1.2.1', 'console_scripts', 'jiphy')()
File "/Library/Python/2.7/site-packages/jiphy/main.py", line 129, in main
output_code = jiphy.to.python(input_code)
File "/Library/Python/2.7/site-packages/jiphy/to.py", line 41, in python
return ast(code).python
File "/Library/Python/2.7/site-packages/jiphy/handlers.py", line 168, in python
return self._python()
File "/Library/Python/2.7/site-packages/jiphy/handlers.py", line 164, in _python
return (self.started_on or '') + self.python_content + (self.ended_on or '')
File "/Library/Python/2.7/site-packages/jiphy/handlers.py", line 161, in python_content
return "".join((child.python for child in self.children))
File "/Library/Python/2.7/site-packages/jiphy/handlers.py", line 161, in
return "".join((child.python for child in self.children))
...
Here is the input source file:
// $Id: express2xml.js,v 1.38 2004/08/24 16:58:55 thendrix Exp $
// Author: Rob Bodington, Eurostep Limited
// Owner: Developed by Eurostep and supplied to NIST under contract.
//
// Other editors:
// T. Hendrix (aka THX and TEH)(Boeing)
// P. Huau (GOSET) for subtype_constraint and algorithms of global rules
// S. Frechette (NIST)
//
// Open issues:
// Script does not handle SELF\ construct correctly - deletes it in most cases
//
// Recent changes: 2004 summer
// Added handling for type labels in function formal params
// Added handling of constants that are aggregates.
// Fixed abstract supertype in subtype constraints.
// function xmlEnumeration:
// Still to do ????
// width CDATA #IMPLIED
// fix (YES | NO) "NO"
// precision CDATA #IMPLIED
// typelabel NMTOKEN #IMPLIED
// Purpose:
// JScript to convert an Express file to an XML file
// cscript express2xml.js
// cscript express2xml.js arm
// cscript express2xml.js mim
// cscript express2xml.js mim_lf
// cscript express2xml.js module
// cscript express2xml.js resource
// cscript express2xml.js reference
//
// e.g.,
// cscript express2xml.js part_and_version_identification arm
// cscript express2xml.js action_schema resource "ISO 10303-41"
// cscript express2xml.js pdm_schema_12 reference "pdm_if"
// file is stepmod\pdm_if\pdm_schema_12.exp
// ------------------------------------------------------------
// Global variables
// -----------------------------------------------------------
var ForReading = 1, ForWriting = 2, ForAppending = 8;
var TristateUseDefault = -2, TristateTrue = -1, TristateFalse = 0;
// The line number of the file being read.
// Only used in Warnings to user
var lNumber = 0;
// The express file being currently parsed
// Only used in Warnings to user
var currentExpFile = 0;
// The string added to the begining of the xml ouput to indent the output
var indent = "";
// Add a functioncalled trim as a method of the prototype
// object of the String constructor.
//String.prototype.trim = function() {
// // Use a regular expression to replace leading and trailing
// // spaces with the empty string
// return this.replace(/(^\s)|(\s$)/g, "");
//}
// ------------------------------------------------------------
// function debug()
// Print debug text to screen
// ------------------------------------------------------------
function debug(txt){
WScript.Echo("Dbx: "+txt);
}
// ------------------------------------------------------------
// function userMessage()
// Print to command screen
// ------------------------------------------------------------
function userMessage(msg){
WScript.Echo(msg);
}
// ------------------------------------------------------------
// function errorMessage()
// Print error message to command screen
// ------------------------------------------------------------
function ErrorMessage(msg){
var objShell = WScript.CreateObject("WScript.Shell");
objShell.Popup(msg);
}
// ------------------------------------------------------------
// function readStatement()
// Return a statement terminated by ";"
// ------------------------------------------------------------
function readStatement(line, ts) {
var pos;
if (ts.AtEndOfStream) {
return(line);
}//end if
else {
pos = line.search(";")
if (pos == -1){
var nextLine = readNextLine(ts);
var reg = /^[A-Za-z]/;
var ch = nextLine.match(reg);
if (ch) {
// add a white space at the beginning of line
line = line + " " + readStatement(nextLine, ts);
}//end if
else {
line = line + readStatement(nextLine, ts);
}//end else
}
else {
return(line);
}
return(line);
}//end else
}//end function
// ------------------------------------------------------------
// function normaliseStatement()
// Separate all , and ( ) with whitespace, remove all tabs etc
// ------------------------------------------------------------
function normaliseStatement(statement) {
//TEH added
statement = statement.replace(/(\w)=/g,"$1 =");
statement = statement.replace(/=(\w)/g,"= $1");
statement = statement.replace(/=\'/g,"= \'");
statement = statement.replace(/:(\?)/g,": $1");
statement = statement.replace(/:(\w)/g,": $1");
statement = statement.replace(/(\w):/g,"$1 :");
//end TEH added
// replace double space with single space
while (statement.search(/ /) != -1) {
statement = statement.replace(/ /g," ");
}
// debug (statement);
return(statement);
}
// ------------------------------------------------------------
// function getWord()
// Get the nth word of a string
// ------------------------------------------------------------
function getWord(n, statement) {
statement = normaliseStatement(statement);
var arr = statement.split(" ");
//get the nth word
var word = arr[n-1];
//get rid of any :
word = word.replace(/\:/,"");
return(word);
}
// ------------------------------------------------------------
// function getList()
// Return the contents of everything enclosed in ()
// ------------------------------------------------------------
function getList(statement) {
var list = normaliseStatement(statement);
var reg = /(.*)/;
list = list.match( reg );
if (list) {
list = list.toString();
// remove the ()
list = list.substr(2,list.length-4);
// remove ,
list = list.replace(/ , /g," ");
}
return (list);
}
// ------------------------------------------------------------
// function readNextLine()
// read a line, bypass any comments or blank lines
// ------------------------------------------------------------
function readNextLine(ts) {
var line = ts.ReadLine();
lNumber = ts.Line;
line = trim(line);
//debug ("1 "+line);
var blankLine = /^\s*$/;
var comment1 = /^\s*\(\*/;
var comment2 = /^--/;
while (line.match(blankLine) || line.match(comment1) || line.match(comment2)){
if (line.match(comment1)){
var com = readComment(line,ts);
}
if(!(ts.AtEndOfStream)){
line = ts.ReadLine();
lNumber = ts.Line;
line = trim(line);
}
else return(line);
}
// remove any trailing -- comments
var pos = line.search(/--/);
if (pos != -1) {
line = line.substr(0,pos);
line = trim(line);
}
//debug ("2 "+line);
return (line);
}
// ------------------------------------------------------------
// function list2array()
// Given a statement, extract the (list) into an array
// ------------------------------------------------------------
function list2array(statement) {
var arr = -1;
//var list = getList(statement);
var reg = /\(.*\)/;
var list = statement.match( reg );
if (list) {
list = list.toString();
// remove the ()
list = list.substr(2,list.length-4);
list = normaliseStatement(list);
arr = list.split(",");
}
return(arr)
}
// ------------------------------------------------------------
// deprecated function: list2arrayOld (replaced by list2array())
// Given a statement, extract the (list) into an array
// ------------------------------------------------------------
//function list2arrayOld(statement) {
// var arr;
// var list = getList(statement);
// if (list) {
// // remove all the whitespace
// //list = list.replace(/ /g,"");
// arr = list.split(" ");
// }
// return(arr)
//}
// ------------------------------------------------------------
// function splitList()
// Given a string, return and array.
// Array[0] is the nth list in the string where n is the listNo
// Array[1] is the rest of the strig after the list
// ------------------------------------------------------------
function splitList(str, listNo) {
var reg = /(.*)/;
var list = str.match( reg );
var listArr = new Array();
var parenCnt = 0;
var listCnt = 0;
var listStr = "";
if (list) {
list = str.replace(reg);
for (var i=0; i<str.length; i++) {
var chr = str.charAt(i);
switch(chr) {
case "(" :
listStr = listStr + "(";
parenCnt++;
if (parenCnt == 1) {
listCnt++;
if (listCnt == listNo) {
// found the list
listStr = "(";
}
}
break;
case ")" :
parenCnt = parenCnt-1;
listStr = listStr + ")";
if ((parenCnt == 0) && (listCnt == listNo)) {
// found the end of the list
listArr[0] = listStr;
listArr[1] = str.substr(i+1);
// terminate the loop
i = str.length;
}
break;
default :
if (parenCnt > 0) listStr = listStr+chr;
}
}
}
else {
listArr[0] = "";
listArr[1] = str;
}
return listArr;
}
// ------------------------------------------------------------
// function isOptional()
// Return true if an attribute statment is OPTIONAL
// It will be the first word after the colon.
// ------------------------------------------------------------
function isOptional(statement) {
statement = getAfterColon(statement);
var word = getWord(1,statement);
var result = false;
if (word=="OPTIONAL") result = true;
return (result);
}
// ------------------------------------------------------------
// function isRedeclared()
// Return true if statement contains "SELF"
// ------------------------------------------------------------
function isRedeclared(statement) {
var result = false;
var reg = /\bSELF\b/i;
var token = statement.match(reg);
if (token) result = true;
return (result);
}
// ------------------------------------------------------------
// function getAfterColon()
// Return everything after the : removing the ;
// ------------------------------------------------------------
function getAfterColon(statement) {
var expr = "";
var reg = /:/;
var pos = statement.search(reg);
if (pos) {
expr = statement.substr(pos+1);
expr = expr.replace(/^\s/g,"");
expr = expr.replace(/\;/,"");
}
return(expr);
}
// ------------------------------------------------------------
// function getAfterEquals()
// Return everything after the := removing the ;
// ------------------------------------------------------------
function getAfterEquals(statement) {
var expr = "";
var pos = -1;
var reg = /\=/;
var pos = statement.search(reg);
if (pos != -1) {
expr = statement.substr(pos+1);
expr = expr.replace(/^\s/g,"");
expr = expr.replace(/\;/,"");
}
return(expr);
}
// ------------------------------------------------------------
// function readComment()
// Return a statement terminated by ;
// calls recursive function readCommentRecurse() to get the comment
// ------------------------------------------------------------
function readComment(line, ts) {
var reg = /^\s(\/;
var pos = line.search(reg);
var comment = -1;
// ------------------------------------------------------------
// function readCommentRecurse()
// Recursive function called by readComment()
// ------------------------------------------------------------
function readCommentRecurse(line, ts) {
var comment = "";
if (ts.AtEndOfStream) {
return(line);
}
else {
var reg = /*)/;
var pos = line.search(reg);
if (pos == -1) {
comment = line + "\n" + readCommentRecurse(ts.ReadLine(), ts);
}
else {
//comment = line.substr(0,pos);
comment = line;
}
return(comment);
}
}
// ------------------------------------------------------------
// function readToken()
// Return the first word in the line or (*
// ------------------------------------------------------------
function readToken(line) {
// get the first word
var reg = /^\s\b\w\b/i;
var token = line.match(reg);
if (!token) {
// Not a word, so check for comment
reg = /^\s*\(\*/;
token = line.match(reg);
}
if (!token) {
// Not a word, so check for comment
reg = /^\s*[--]/;
token = line.match(reg);
}
if (!token) {
// Not a word, so check for {} statement
reg = /^\{/;
token = line.match(reg);
}
if (token) {
token = token[0].replace(/\s/g,"");
token = token.toString();
switch (token) {
case "USE" :
var reg = /^\s*USE FROM\b/i;
token = line.match(reg);
if (token) {
token = token[0].replace(/\s/g,"");
token = token.toString();
}
else {
token = -1;
}
break;
case "REFERENCE" :
var reg = /^\s*REFERENCE FROM\b/i;
token = line.match(reg);
if (token) {
token = token[0].replace(/\s/g,"");
token = token.toString();
}
else {
token = -1;
}
break;
//thx added 20040813
case "ABSTRACT" :
var reg = /^\sABSTRACT SUPERTYPE\b/i;
token = line.match(reg);
if (token) {
token = token[0].replace(/\s/g,"");
token = token.toString();
}
break;
// ------------------------------------------------------------
// function xmlFileHeader()
// Write the xml file header
// ------------------------------------------------------------
function xmlFileHeader(outTs) {
outTs.Writeline("<?xml version='1.0' encoding='UTF-8'?>");
outTs.Writeline("");
outTs.Writeline("<?xml-stylesheet type=\"text\/xsl\" href=\"..\/..\/..\/xsl\/express.xsl\"?>");
outTs.Writeline("<!DOCTYPE express SYSTEM \"../../../dtd/express.dtd\">");
}
// ------------------------------------------------------------
// function getApplicationRevision()
// Return the revision of this application
// ------------------------------------------------------------
function getApplicationRevision() {
// get CVS to set the revision in the variable, then extract the
// revision from the string.
// SPF: not interacting with CVS
var appCVSRevision = "$Revision: 1.38 $";
var appRevision = appCVSRevision.replace(/Revision:/,"");
appRevision = appRevision.replace(/\$/g,"");
appRevision = trim(appRevision);
//appRevision.trim(); // SPF: trim is now a function not a method
return(appRevision);
}
// ------------------------------------------------------------
// function trim()
// Trim white space from both ends of a string
// ------------------------------------------------------------
function trim(s) {
return s.replace(/(^\s+)|(\s+$)/g, "")
}
// ------------------------------------------------------------
// function xmlApplication()
// ------------------------------------------------------------
function xmlApplication(outTs) {
var appRevision = getApplicationRevision();
xmlOpenElement("<application",outTs);
xmlAttr("name","express2xml2.js",outTs);
xmlAttr("owner","Eurostep Limited",outTs);
xmlAttr("url","http://www.eurostep.com",outTs);
xmlAttr("version",appRevision,outTs);
xmlAttr("source",currentExpFile,outTs);
xmlCloseAttr(outTs);
outTs.WriteLine();
}
// ------------------------------------------------------------
// function xmlOpenSchema()
// Open the schema XML element
// ------------------------------------------------------------
function xmlOpenSchema(statement, outTs) {
var schema = getWord(2,statement);
xmlOpenElement("<schema name=\""+schema,outTs);
outTs.WriteLine("\">");
outTs.WriteLine("");
}
// ------------------------------------------------------------
// function xmlCloseSchema()
// Close the schema XML element
// ------------------------------------------------------------
function xmlCloseSchema(outTs) {
xmlCloseElement("",outTs);
}
// ------------------------------------------------------------
// function xmlConstant()
// ------------------------------------------------------------
function xmlConstant(statement,expTs,outTs) {
var name;
var expr;
var type;
var arr;
var line;
var reg;
var reg2;
var reg3;
var token;
// First time function called line will start with CONSTANT, so remove
line = trim(statement);
// remove CONSTANT word
reg = /^CONSTANT/i;
token = line.match(reg);
if (token) {
line = line.replace(reg,"");
}
// split the statement into name, type, expression
arr = line.split(":");
reg2 = /\;|\=/g;
// get name
name = arr[0];
name = trim(name.replace(reg2,""));
// get type
type = arr[1];
type = trim(type.replace(reg2,""));
//get expression
expr = arr[2];
expr = trim(expr.replace(reg2,""));
expr = tidyExpression(expr);
xmlOpenElement("<constant name=\""+name+"\"", outTs);
xmlAttr("expression", expr, outTs);
outTs.WriteLine(">");
xmlInstanciableType(type,outTs);
xmlCloseElement("</constant>",outTs);
//get the next line
line = readNextLine(expTs);
var token = readToken(line);
statement = readStatement(line,expTs);
switch( token ) {
case "END_CONSTANT" :
break;
default :
// multiple constants may be defined in one CONSTANT statement
xmlConstant(statement,expTs,outTs); // recursive call
break;
}
}
function xmlInstanciableType(type,outTs) {
var typeType = getType(type);
//debug("St:"+statement);
//debug("tn:"+typeName);
//debug("tt:"+typeType);
switch( typeType) {
case "BINARY" :
xmlBuiltInType(typeType,type,outTs);
break;
case "BOOLEAN" :
xmlBuiltInType(typeType,type,outTs);
break;
case "INTEGER" :
xmlBuiltInType(typeType,type,outTs);
break;
case "LOGICAL" :
xmlBuiltInType(typeType,type,outTs);
break;
case "NUMBER" :
xmlBuiltInType(typeType,type,outTs);
break;
case "REAL" :
xmlBuiltInType(typeType,type,outTs);
break;
case "STRING" :
xmlBuiltInType(typeType,type,outTs);
break;
case "LIST" :
xmlUnderlyingType(type,outTs);
break;
case "SET" :
xmlUnderlyingType(type,outTs);
break;
case "BAG" :
xmlUnderlyingType(type,outTs);
break;
case "ARRAY" :
xmlUnderlyingType(type,outTs);
break;
default :
xmlOpenElement("<typename",outTs);
xmlAttr("name",type,outTs);
// ------------------------------------------------------------
// function getAbstractSuper()
// ------------------------------------------------------------
function getAbstractSuper(statement) {
statement = normaliseStatement(statement);
var reg = /.*ABSTRACT SUPERTYPE\b/i;
var token = statement.match(reg);
return(token);
}
// ------------------------------------------------------------
// function xmlAbstract()
// ------------------------------------------------------------
function xmlAbstract(outTs) {
xmlAttr("abstract.supertype", "YES", outTs);
}
// ------------------------------------------------------------
// function xmlSuperExpression()
// Return the supertype expression.
// Format may be:
// SUPERTYPE OF (ONEOF(next_assembly_usage_occurrence, specified_higher_usage_occurrence,promissory_usage_occurrence))
// SUBTYPE OF (product_definition_usage);
// ------------------------------------------------------------
function xmlSuperExpression(statement, outTs) {
var reg = /.*SUPERTYPE OF/i;
var token = statement.match(reg);
var superExpr = "";
if (token) {
// remove the SUPERTYPE OF words
superExpr = statement.replace(reg,"");
// get the list after the SUPERTYPE OF words
var listArr = splitList(superExpr,1);
superExpr = listArr[0];
reg = /;/;
superExpr = superExpr.replace(reg,"");
xmlAttr("super.expression", superExpr, outTs);
}
}
// ------------------------------------------------------------
// function xmlSupertypes()
// ------------------------------------------------------------
function xmlSupertypes(statement, outTs) {
var reg = /.*SUBTYPE OF\b/i;
var token = statement.match(reg);
var token = statement.match(reg);
var supertypes = "";
if (token) {
supertypes = statement.replace(reg,"");
reg = /;/;
supertypes = supertypes.replace(reg,"");
supertypes = getList(supertypes);
xmlAttr("supertypes", supertypes, outTs);
}
}
// ------------------------------------------------------------
// function xmlOpenEntity()
// Open the entity XML element
// ------------------------------------------------------------
function xmlOpenEntity(statement,outTs,expTs) {
xmlOpenElement("<entity",outTs);
var entity = getWord(2,statement);
// entity = entity.toLowerCase();
xmlAttr("name",entity,outTs);
if (getAbstractSuper(statement)) xmlAbstract(outTs);
xmlSuperExpression(statement,outTs);
xmlSupertypes(statement,outTs);
outTs.WriteLine(">");
xmlEntityStructure(outTs, expTs, "explicit");
}
// ------------------------------------------------------------
// function xmlCloseEntity
// Close the entity XML entity
// ------------------------------------------------------------
function xmlCloseEntity(outTs) {
xmlCloseElement("",outTs);
}
// ------------------------------------------------------------
// function xmlEntityStructure()
// ------------------------------------------------------------
function xmlEntityStructure(outTs,expTs,mode) {
var l = readNextLine(expTs);
//if(mode == "unique") debug("unique: "+l);
var token = readToken(l)+"";
switch( token ) {
case "-1" :
// must have read an empty line
xmlEntityStructure(outTs,expTs,mode);
break;
case "DERIVE" :
xmlEntityStructure(outTs,expTs,"derive");
break;
case "INVERSE" :
xmlEntityStructure(outTs,expTs,"inverse");
break;
case "WHERE" :
xmlEntityStructure(outTs,expTs,"where");
break;
case "UNIQUE" :
xmlEntityStructure(outTs,expTs,"unique");
break;
case "END_ENTITY" :
xmlCloseEntity(outTs);
break;
default :
// output the attribute, rule etc
var statement = readStatement(l,expTs);
var name = getWord(1,statement);
var rest = getAfterColon(statement);
var reg = /^\s*/;
rest = rest.replace(reg,"");
switch( mode ) {
case "explicit" :
if (isRedeclared(statement)) {
name = getRedeclaredAttribute(statement, outTs);
}
xmlOpenElement("<explicit",outTs);
xmlAttr("name",name,outTs);
if (isOptional(statement)) {
reg = /\bOPTIONAL\b/i;
rest = rest.replace(reg,"");
reg = /^\s*/;
rest = rest.replace(reg,"");
xmlAttr("optional","YES",outTs);
}
outTs.WriteLine(">");
xmlUnderlyingType(rest,outTs);
if (isRedeclared(statement)) {
xmlRedeclaredAttribute(statement, outTs);
}
xmlCloseElement("</explicit>",outTs);
// process the next attribute
xmlEntityStructure(outTs,expTs,mode);
break;
case "derive" :
xmlOpenElement("<derived",outTs);
var expression = getAfterEquals(rest);
var reg = /^\s*/;
expression = expression.replace(reg,"");
expression = tidyExpression(expression);
var typedef = rest.replace(/:=.*/,"");
xmlAttr("name",name.replace(/^.*\./,""),outTs);
xmlAttr("expression",expression,outTs);
outTs.WriteLine(">");
xmlUnderlyingType(typedef,outTs);
//TEH added
if (isRedeclared(name)) {
xmlRedeclaredAttribute(name.replace(/^.*\/,"").replace(/.$/,""), outTs);
}
//end TEH added
xmlCloseElement("",outTs);
// process the next attribute
xmlEntityStructure(outTs,expTs,mode);
break;
case "inverse" :
var entity = getInverseEntity(statement);
var attribute = getInverseAttr(statement);
xmlOpenElement("<inverse",outTs);
xmlAttr("name",name,outTs);
xmlAttr("entity",entity,outTs);
xmlAttr("attribute",attribute,outTs);
outTs.WriteLine(">");
xmlAggregate(statement, outTs);
// redeclaration
xmlCloseElement("</inverse>",outTs);
// process the next attribute
xmlEntityStructure(outTs,expTs,mode);
break;
case "where" :
//var expr = getAfterColon(rest);
var expr = rest;
var reg = /^\s*/;
expr = expr.replace(reg,"");
expr = tidyExpression(expr);
xmlOpenElement("<where",outTs);
xmlAttr("label",name,outTs);
xmlAttr("expression",expr,outTs);
outTs.WriteLine(">");
xmlCloseElement("</where>",outTs);
// process the next attribute
xmlEntityStructure(outTs,expTs,mode);
break;
case "unique" :
xmlUnique(statement, outTs);
// process the next attribute
xmlEntityStructure(outTs,expTs,mode);
break;
}
}
}
// ------------------------------------------------------------
// function: getRedeclaredAttribute()
// SELF\Representation.context_of_items : Geometric_coordinatespace;
// Return the name of a redeclared attribute
// ------------------------------------------------------------
function getRedeclaredAttribute(statement, outTs) {
statement = trim(statement);
statement = statement.replace(/^../g,"");
var attr = statement.replace(/:._/g,"");
attr = trim(attr);
return(attr);
}
// ------------------------------------------------------------
// function: xmlRedeclaredAttribute()
// SELF\Representation.context_of_items : Geometric_coordinate_space;
// Output a redeclared attribute by matching on SELF\
// ------------------------------------------------------------
function xmlRedeclaredAttribute(statement, outTs) {
statement = statement.replace(/^\s_SELF\/,"");
var entityref = statement.replace(/../g,"");
xmlOpenElement("<redeclaration",outTs);
xmlAttr("entity-ref",entity_ref,outTs);
outTs.WriteLine("/>");
}
// ------------------------------------------------------------
// function xmlUnique()
// ------------------------------------------------------------
function xmlUnique(statement, outTs) {
var name = getWord(1,statement);
xmlOpenElement("<unique",outTs);
xmlAttr("label",name,outTs);
outTs.WriteLine(">");
var uniqueAttrs = getAfterColon(statement);
var reg = /^\s*|;|/;
uniqueAttrs = uniqueAttrs.replace(reg,"");
// remove all the whitespace
uniqueAttrs = uniqueAttrs.replace(/ /g,"");
var arr = uniqueAttrs.split(",");
for (var i=0; i<arr.length; i++) {
//is this the correct way to handle SELF\? SPF
//TEH modified - need to add entity-ref attr if SELF
if (isRedeclared(arr[i])){
var tmp = arr[i].replace(/^.*\./,"");
var entity_ref = arr[i].replace(/\..*/g,"").replace(/^SELF\\/,"");
}
//end TEH modified
tmp = arr[i].replace(/^SELF\/,"");
xmlOpenElement("<unique.attribute",outTs);
if (isRedeclared(arr[i])){
xmlAttr("entity-ref",entity_ref,outTs);
}
xmlAttr("attribute",arr[i].replace(/^.*\./,""),outTs);
xmlCloseAttr(outTs);
}
xmlCloseElement("</unique>",outTs);
}
// ------------------------------------------------------------
// function getInverseEntity()
// ------------------------------------------------------------
function getInverseEntity(statement) {
statement=normaliseStatement(statement);
var entity;
var pos = statement.search(/\bOF\b/i);
if (pos > 0) {
entity = statement.substr(pos+3);
entity = getWord(1,entity);
} else {
pos = statement.search(/:/);
entity = statement.substr(pos+1);
entity = getWord(1,entity);
}
return(entity);
}
// ------------------------------------------------------------
// function getInverseAttr()
// ------------------------------------------------------------
function getInverseAttr(statement) {
statement=normaliseStatement(statement);
var pos = statement.search(/\bFOR\b/i);
var attr = statement.substr(pos+4);
attr = getWord(1,attr);
return(attr);
}
// ------------------------------------------------------------
// function xmlAggregate()
// Output elements for aggregate
// ------------------------------------------------------------
function xmlAggregate(statement, outTs) {
var reg = /\bSET\b|\bBAG\b|\bLIST\b|\bARRAY\b/i;
var agg = statement.match(reg);
if (agg) {
agg = agg.toString();
agg = agg.toUpperCase();
var opos = statement.search(/[/);
var cpos = statement.search(/]/);
var bounds = statement.substr(opos+1, cpos-opos-1);
bounds = bounds.replace(/\s/g,"");
var lower = bounds.match(/.*:/);
// "if" added by TEH to enable else, which deals with implied bounds.
// After experimenting with GE, I decide to coerce explicit bounds in all cases
// rather than fix the display in the case where no bounds are in the express
if (bounds.length > 0) {
lower = lower[0].replace(/:/,"");
var upper = bounds.match(/:.*/);
upper = upper[0].replace(/:/,"");
xmlOpenElement("<inverse.aggregate",outTs);
xmlAttr("type",agg,outTs);
xmlAttr("lower",lower,outTs);
xmlAttr("upper",upper,outTs);
xmlCloseAttr(outTs);
}
else{
xmlOpenElement("<inverse.aggregate",outTs);
xmlAttr("type",agg,outTs);
xmlAttr("lower",'0',outTs);
xmlAttr("upper",'?',outTs);
xmlCloseAttr(outTs);
}
}
}
// ------------------------------------------------------------
// function xmlSuperExpression_cst()
// ------------------------------------------------------------
function xmlSuperExpression_cst(statement, outTs) {
var superExpr = statement;
var reg = /\;/;
superExpr = superExpr.replace(reg,"");
xmlAttr("super.expression", superExpr, outTs);
}
// ------------------------------------------------------------
// function xmlSubtypeConstraint()
// ------------------------------------------------------------
function xmlSubtypeConstraint(statement,outTs,expTs) {
var constName = getWord(2,statement);
var entity_ref = getWord(4,statement);
xmlOpenElement("<subtype.constraint name=\""+constName+"\"",outTs);
xmlAttr("entity",entity_ref,outTs);
xmlConstraintStructure(outTs, expTs, "supertype_expression");
}
// ------------------------------------------------------------
// function xmlConstraintStructure()
// ------------------------------------------------------------
function xmlConstraintStructure(outTs,expTs,mode) {
var l = readNextLine(expTs);
//debug(l);
var token = readToken(l)+"";
//debug(token);
switch(token) {
case "-1" :
// must have read an empty line
// process next statement
xmlConstraintStructure(outTs,expTs,mode);
break;
case "ABSTRACTSUPERTYPE" :
xmlAbstract(outTs);
// process next statement
xmlConstraintStructure(outTs,expTs,mode);
break;
case "TOTAL_OVER":
var statement = readStatement(l,expTs);
var to_list=getList(statement);
xmlAttr("totalover",to_list,outTs);
// process next statement
xmlConstraintStructure(outTs,expTs,mode);
break;
case "END_SUBTYPE_CONSTRAINT" :
outTs.WriteLine(">");
xmlCloseElement("</subtype.constraint>",outTs);
break;
default:
var statement = readStatement(l,expTs);
xmlSuperExpression_cst(statement,outTs);
// process next statement
xmlConstraintStructure(outTs,expTs,mode);
break;
}
}
// ------------------------------------------------------------
// function xmlInterface()
// ------------------------------------------------------------
function xmlInterface(statement, outTs) {
statement = normaliseStatement(statement);
xmlOpenElement("<interface",outTs);
var kind = getWord(1,statement).toLowerCase();
xmlAttr("kind",kind,outTs);
var schema = getWord(3,statement);
xmlAttr("schema",schema,outTs);
outTs.WriteLine(">");
var lArr = list2array(statement);
if (lArr != -1) {
for (var i=0; i<lArr.length; i++) {
xmlOpenElement("<interfaced.item",outTs);
var line = trim(lArr[i]);
var reg = /\bAS\b/i;
var as = line.match(reg);
var entity, alias;
if (as) {
var ifLine = line.split(" ");
entity = ifLine[0];
alias = ifLine[2];
//debug('{'+entity+' = '+alias+'}');
xmlAttr("name",entity,outTs);
xmlAttr("alias",alias,outTs);
}
else {
entity = line;
xmlAttr("name",entity,outTs);
}
xmlCloseAttr(outTs);
}
}
xmlCloseElement("",outTs);
}
// ------------------------------------------------------------
// function xmlUnderlyingType()
// tage the underlying type
// ------------------------------------------------------------
function xmlUnderlyingType(statement,outTs) {
statement = normaliseStatement(statement);
// PH: Add aggregate for function parameters
var reg = /\bSET\b|\bBAG\b|\bLIST\b|\bARRAY\b|\bAGGREGATE\b/i;
var agg = statement.match(reg);
if (agg) {
agg = agg.toString();
agg = agg.toUpperCase();
var opos = statement.search(/\[/);
var cpos = statement.search(/\]/);
var bounds = null;
var lower = "";
var upper = "";
if (opos != -1) {
bounds = statement.substr(opos+1, cpos-opos-1);
bounds = bounds.replace(/\s/g,"");
lower = bounds.match(/.*\:/);
lower = lower[0].replace(/\:/,"");
upper = bounds.match(/\:.*/);
upper = upper[0].replace(/\:/,"");
}
var pos = statement.search(/\bOF\b/i);
var rest = statement.substr(pos+3);
var unique = null;
var optional = null;
reg = /\bOPTIONAL\b/i;
if (rest.match(reg)) {
optional="YES";
rest = rest.replace(reg,"");
}
reg = /\bUNIQUE\b/i;
if (rest.match(reg)) {
unique="YES";
rest = rest.replace(reg,"");
}
var typename = getWord(1,rest);
//thx added
reg = /:/i;
if(rest.match(reg)){
var typelabel = getAfterColon(rest);
}
xmlOpenElement("<aggregate",outTs);
xmlAttr("type",agg,outTs);
if (bounds) {
xmlAttr("lower",lower,outTs);
xmlAttr("upper",upper,outTs);
}
if (optional) xmlAttr("optional",optional,outTs);
if (unique) xmlAttr("unique",unique,outTs);
xmlCloseAttr(outTs);
// PH: GENERIC_ENTITY
reg = /\bBINARY\b|\bBOOLEAN\b|\bGENERIC_ENTITY\b|\bGENERIC\b|\bINTEGER\b|\bLOGICAL\b|\bNUMBER\b|\bREAL\b|\bSTRING\b/i;
var aggtype = statement.match(reg);
if (aggtype) {
aggtype = aggtype.toString();
aggtype = aggtype.toUpperCase();
xmlOpenElement("<builtintype",outTs);
xmlAttr("type",aggtype,outTs);
if (typelabel){
xmlAttr("typelabel",typelabel,outTs);
}
xmlCloseAttr(outTs);
}
else {
xmlOpenElement("<typename",outTs);
xmlAttr("name",typename,outTs);
xmlCloseAttr(outTs);
}
return;
}
reg = /\bBINARY\b|\bBOOLEAN\b|\bGENERIC_ENTITY\b|GENERIC\b|\bINTEGER\b|\bLOGICAL\b|\bNUMBER\b|\bREAL\b|\bSTRING\b/i;
var type = statement.match(reg);
if (type) {
type = type.toString();
type = type.toUpperCase();
xmlOpenElement("<builtintype",outTs);
xmlAttr("type",type,outTs);
if (typelabel){
xmlAttr("typelabel",typelabel,outTs);
}
xmlCloseAttr(outTs);
return;
}
xmlOpenElement("<typename",outTs);
statement = trim(statement);
xmlAttr("name",statement,outTs);
xmlCloseAttr(outTs);
}
// ----------------------------------------------------------
// function tidyExpression()
// Replace all <> in the expression
// ------------------------------------------------------------
function tidyExpression(expr) {
expr = trim(expr);
expr = expr.replace(/>/g,">");
expr = expr.replace(/</g,"<");
expr = expr.replace(/\"/g,""");
// SPF: hack - not correct way to handle SELF\
// expr = expr.replace(/^SELF\/,"");
// replace double space with single space
while (expr.search(/ /) != -1) {
expr = expr.replace(/ /g," ");
}
// remove spaces around parens
expr = expr.replace(/\( /g,"(");
expr = expr.replace(/ \)/g,")");
return(expr);
}
// ------------------------------------------------------------
// function getExtensibleBasedOn()
// Return the BASED_ON type
// ------------------------------------------------------------
function getExtensibleBasedOn(extensibleStatement) {
extensibleStatement = normaliseStatement(extensibleStatement);
var type = -1;
var reg = /\bBASED_ON\b/i;
var pos = extensibleStatement.search(reg);
if (pos != -1) {
// get the word after BASED_ON
extensibleStatement = extensibleStatement.substr(pos+9);
pos = extensibleStatement.search(" ");
type = extensibleStatement.substr(0,pos);
}
return(type);
}
// ------------------------------------------------------------
// function xmlSelect()
// genericentity (YES | NO) "NO"
// ------------------------------------------------------------
function xmlSelect(statement,outTs) {
xmlOpenElement("<select",outTs);
var reg = /\bEXTENSIBLE\b/i;
if (statement.match(reg)) {
xmlAttr("extensible","YES",outTs);
}
var reg = /\bGENERIC_ENTITY\b/i;
if (statement.match(reg)) {
xmlAttr("genericentity","YES",outTs);
}
var based_on = getExtensibleBasedOn(statement);
if (based_on != -1) {
xmlAttr("basedon",based_on,outTs);
}
var selectItems = getList(statement);
if (selectItems) {
// ------------------------------------------------------------
// function xmlBuiltInType()
// tag builtin type
// ------------------------------------------------------------
function xmlBuiltInType(typeType,statement,outTs) {
xmlOpenElement("<builtintype",outTs);
xmlAttr("type",typeType,outTs);
outTs.WriteLine(">");
xmlCloseElement("",outTs);
}
// ------------------------------------------------------------
// function getType()
// Get the type and return
// ------------------------------------------------------------
function getType(statement) {
var reg = /\bSET\b|\bBAG\b|\bLIST\b|\bARRAY\b|\bAGGREGATE\b|\bSELECT\b|\bENUMERATION\b|\bBINARY\b|\bBOOLEAN\b|\bINTEGER\b|\bLOGICAL\b|\bNUMBER\b|\bREAL\b|\bSTRING\b/i;
var type = statement.match(reg);
//debug("getType1:"+type);
if (type) {
type = type.toString();
type = type.toUpperCase();
//debug("getType2:"+type);
}
else {
//debug("no Type found");
type = getAfterEquals(statement);
var reg = /^\s*/;
type = type.replace(reg,"");
reg = /\;/;
type = type.replace(reg,"");
//debug("getType3:"+type);
}
return(type);
}
// ------------------------------------------------------------
// function xmlType()
// identify the express type and process
// ------------------------------------------------------------
function xmlType(statement,outTs,expTs) {
var typeName = getWord(2,statement);
// typeName = typeName.toLowerCase();
xmlOpenElement("<type name=\""+typeName,outTs);
outTs.WriteLine("\">");
var typeType = getType(statement);
//debug("St:"+statement);
//debug("tn:"+typeName);
//debug("tt:"+typeType);
switch( typeType) {
case "SELECT" :
xmlSelect(statement,outTs);
break;
case "ENUMERATION" :
xmlEnumeration(statement,outTs);
break;
case "BINARY" :
xmlBuiltInType(typeType,statement,outTs);
break;
case "BOOLEAN" :
xmlBuiltInType(typeType,statement,outTs);
break;
case "INTEGER" :
xmlBuiltInType(typeType,statement,outTs);
break;
case "LOGICAL" :
xmlBuiltInType(typeType,statement,outTs);
break;
case "NUMBER" :
xmlBuiltInType(typeType,statement,outTs);
break;
case "REAL" :
xmlBuiltInType(typeType,statement,outTs);
break;
case "STRING" :
xmlBuiltInType(typeType,statement,outTs);
break;
case "LIST" :
xmlUnderlyingType(statement,outTs);
break;
case "SET" :
xmlUnderlyingType(statement,outTs);
break;
case "BAG" :
xmlUnderlyingType(statement,outTs);
break;
case "ARRAY" :
xmlUnderlyingType(statement,outTs);
break;
default :
xmlOpenElement("<typename",outTs);
xmlAttr("name",typeType,outTs);
xmlCloseAttr(outTs);
break;
}
//outTs.WriteLine("");
xmlTypeStructure(outTs,expTs);
}
// ------------------------------------------------------------
// dep function
// ------------------------------------------------------------
//function xmlTypeStructureOld(xmlTs,expTs) {
// var l = expTs.ReadLine();
// //debug("L:"+l);
// lNumber = expTs.Line;
// var token = readToken(l);
// switch( token ) {
// case "END_TYPE" :
// xmlCloseElement("",xmlTs);
// break;
// case "WHERE" :
// // assumes WHERE is on new line
// xmlTypeStructure(xmlTs,expTs);
// break;
//
// default :
// // only called when in a where definition
// var statement = readStatement(l,expTs);
//
// //debug("ss:"+statement);
// var name = getWord(1,statement);
//
// var expr = getAfterColon(statement);
// var reg = /^\s*/;
// expr = expr.replace(reg,"");
// expr = tidyExpression(expr);
// xmlOpenElement("<where",xmlTs);
// xmlAttr("label",name,xmlTs);
// xmlAttr("expression",expr,xmlTs);
// xmlTs.WriteLine(">");
// xmlCloseElement("",xmlTs);
// xmlTypeStructure(xmlTs,expTs);
// break;
//
// }
//}
// ------------------------------------------------------------
// function xmlTypeStructure()
// ------------------------------------------------------------
function xmlTypeStructure(xmlTs,expTs) {
var l = readNextLine(expTs);
//debug("L:"+l);
var token = readToken(l);
switch( token ) {
case "END_TYPE" :
xmlCloseElement("</type>",xmlTs);
break;
//case "WHERE" :
// assumes WHERE is on new line
//xmlTypeStructure(xmlTs,expTs);
//break;
default :
// only called when in a where definition
var statement = readStatement(l,expTs);
//debug("ss:"+statement);
var name = getWord(2,statement);
//debug("wr:"+name);
var expr = getAfterColon(statement);
var reg = /^\s*/;
expr = expr.replace(reg,"");
expr = tidyExpression(expr);
xmlOpenElement("<where",xmlTs);
xmlAttr("label",name,xmlTs);
xmlAttr("expression",expr,xmlTs);
xmlTs.WriteLine(">");
xmlCloseElement("</where>",xmlTs);
xmlTypeStructure(xmlTs,expTs);
break;
}
if (closeParen != -1) {
// found the end of the parameter list
var retStr = paramList.replace(/.*\)/,"");
this.loadRtnStr(retStr,expTs,outTs);
paramList = paramList.replace(/\).*/,"");
paramList = paramList.replace(/.*\(/,"");
this.paramStr = paramList;
this.loadAlgorithm("",expTs,outTs);
}
else {
var line = readNextLine(expTs);
paramList = paramList+line;
this.loadParamList(paramList,expTs,outTs);
}
}
// ------------------------------------------------------------
// FunctionObj method xmlParamList()
// get the parameter list
// ------------------------------------------------------------
FunctionObj.prototype.xmlParamList = function (outTs) {
this.paramStr = trim(this.paramStr);
var paramArr1 = this.paramStr.split(";");
for (var i=0; i<paramArr1.length; i++) {
// there may be more than one parameter with the same type definition
// e.g., FUNCTION first_proj_axis(z_axis,arg : direction) : direction;
// SPF: fine, but this only works for one more parameter
// get the params
var params = paramArr1[i].replace(/:.*/,"");
var rest = getAfterColon(paramArr1[i]);
var paramArr2 = params.split(",");
var typedef = paramArr1[i].substring(params.length);
typedef = trim(rest);
for (var j=0; j<paramArr2.length; j++) {
var param = trim(paramArr2[j]);
xmlOpenElement("<parameter",outTs);
xmlAttr("name",param,outTs);
outTs.WriteLine(">");
xmlUnderlyingType(typedef,outTs);
xmlCloseElement("</parameter>",outTs);
}
}
// ------------------------------------------------------------
// FunctionObj method xmlRtnStr()
// xml return string
// ------------------------------------------------------------
FunctionObj.prototype.xmlRtnStr = function (outTs) {
xmlUnderlyingType(this.rtnStr,outTs);
}
// ------------------------------------------------------------
// FunctionObj method loadAlgorithm()
// read in the algorithm and write in to the xml file
// ------------------------------------------------------------
FunctionObj.prototype.loadAlgorithm = function(algoStr,expTs,outTs) {
var line = readNextLine(expTs);
// end of algorithm?
//TEH modified for case when these are on same line as last part of alogorithm
// var reg = /\bEND_FUNCTION|END_PROCEDURE|WHERE/i;
// if (line.match(reg)) {
//
var pos = line.search(/\bEND_FUNCTION|END_PROCEDURE|WHERE/i);
if (pos != -1) {
line=line.substr(0,pos)
this.algorithm = algoStr+"\n" +line;
}
//
else {
line = trim(line);
algoStr = algoStr+"\n"+line;
this.loadAlgorithm(algoStr,expTs,outTs);
}
// return -1 if there is no algorithm
if (algoStr == "") {
return -1;
}
}
// ------------------------------------------------------------
// function xmlFunction
// ------------------------------------------------------------
function xmlFunction(line,expTs,outTs) {
var name = getWord(2,line);
var fnObj = new FunctionObj(name);
// TEH - algorithm is loaded in xmlParamList
fnObj.xmlAlgorithm(outTs);
xmlCloseElement("",outTs);
}
// ------------------------------------------------------------
// function xmlProcedure()
// ------------------------------------------------------------
function xmlProcedure(line,expTs,outTs) {
var name = getWord(2,line);
var fnObj = new FunctionObj(name);
//TEH algorithm is loaded in xmlParamList
fnObj.xmlAlgorithm(outTs);
xmlCloseElement("",outTs);
}
// ------------------------------------------------------------
// function loadDomainRule()
// found a WHERE
// ------------------------------------------------------------
function loadDomainRule(expTs,outTs) {
var line = readNextLine(expTs);
var reg1 = /\bEND_RULE/i;
if (!line.match(reg1)) {
var statement = readStatement(line,expTs);
var name = getWord(1,statement);
var expr = getAfterColon(statement);
var reg = /^\s*/;
expr = expr.replace(reg,"");
expr = tidyExpression(expr);
xmlOpenElement("<where",outTs);
xmlAttr("label",name,outTs);
xmlAttr("expression",expr,outTs);
outTs.WriteLine(">");
xmlCloseElement("</where>",outTs);
loadDomainRule(expTs,outTs);
}
}
// ------------------------------------------------------------
// function xmlRule()
// ------------------------------------------------------------
function xmlRule(line,expTs,outTs) {
var statement = readStatement(line,expTs);
var name = getWord(2,line);
var appliesTo = getList(statement);
var fnObj = new FunctionObj(name);
// ------------------------------------------------------------
// function xmlOpenElement()
// ------------------------------------------------------------
function xmlOpenElement(xmlElement, outTs) {
var txt = indent+xmlElement;
outTs.Write(txt);
indent = indent+" ";
}
// ------------------------------------------------------------
// function xmlCloseElement()
// close xml element tag
// ------------------------------------------------------------
function xmlCloseElement(xmlElement, outTs) {
if (indent.length >= 2) {
indent = indent.substr(2);
}
else {
indent = indent+"-------";
}
// ------------------------------------------------------------
// function xmlAttr()
// Output an indented attribute
// ------------------------------------------------------------
function xmlAttr(name, value, outTs) {
// SPF: delete "SELF\" ISSUE: this is not the correct way to process SELF\
// xml will not validate with "SELF\"
// value = value.replace(/SELF\/,"");
var txt = indent+name+'=\"'+value+'\"';
outTs.WriteLine();
outTs.Write(txt);
}
// ------------------------------------------------------------
// function xmlCloseAttr()
// close attribute tag
// ------------------------------------------------------------
function xmlCloseAttr(outTs) {
outTs.WriteLine("/>");
// ------------------------------------------------------------
// function Output2xml()
// this is the main routine
// read express file line, process, write to xml file
// ------------------------------------------------------------
function Output2xml(expFile, xmlFile, partnumber) {
userMessage("Reading EXPRESS from file: " + expFile);
userMessage("");
userMessage(" Writing XML to file: " + xmlFile);
var fso = new ActiveXObject("Scripting.FileSystemObject");
var expF = fso.GetFile(expFile);
var expTs = expF.OpenAsTextStream(ForReading, TristateUseDefault);
var xmlF = fso.CreateTextFile(xmlFile,true);
xmlF.Close();
xmlF = fso.GetFile(xmlFile);
var xmlTs = xmlF.OpenAsTextStream(ForWriting, TristateUseDefault);
xmlFileHeader(xmlTs);
xmlOpenElement("<express",xmlTs);
xmlAttr("language_version","2",xmlTs);
if (expFile.match(/_schema.exp$/) ) {
// An integrated resource
if (partnumber) {
xmlAttr("reference",partnumber,xmlTs);
}
}
// hacked by TEH: did not know how to indicate start of string in a regular expression
// SPF: start of word is \b
else if (expFile.match(/\baic_/i)) {
// an aic
// debug("found aic :" + partnumber);
if (partnumber) {
// debug("found partno: " + partnumber);
xmlAttr("reference",partnumber,xmlTs);
}
}
// End hack by TEH - plus or minus a curly bracket.
// SPF: Curly brackets OK
else if (expFile.match(/arm.exp$/)) {
xmlAttr("description.file","arm_descriptions.xml",xmlTs);
}
else if (expFile.match(/mim.exp$/)) {
xmlAttr("description.file","mim_descriptions.xml",xmlTs);
}
var rcsdate = "$"+"Date: $";
xmlAttr("rcs.date",rcsdate,xmlTs);
var rcsrevision = "$"+"Revision: $";
xmlAttr("rcs.revision",rcsrevision,xmlTs);
xmlTs.WriteLine(">");
xmlTs.WriteLine("");
xmlApplication(xmlTs);
while (!expTs.AtEndOfStream) {
var l = readNextLine(expTs);
var token = readToken(l);
switch( token ) {
case "{" :
// found: { iso standard 10303 part (11) version (4) }
// ignore as this is express edition 2 construct
break;
case "SCHEMA" :
var statement = readStatement(l,expTs);
xmlOpenSchema(statement,xmlTs);
break;
case "END_SCHEMA" :
var statement = readStatement(l,expTs);
xmlCloseSchema(xmlTs);
break;
case "CONSTANT" :
var statement = readStatement(l,expTs);
xmlConstant(statement,expTs,xmlTs);
break;
case "ENTITY" :
var statement = readStatement(l,expTs);
xmlOpenEntity(statement,xmlTs,expTs);
break;
case "USEFROM" :
var statement = readStatement(l,expTs);
xmlInterface(statement,xmlTs);
break;
case "REFERENCEFROM" :
var statement = readStatement(l,expTs);
xmlInterface(statement,xmlTs);
break;
case "TYPE" :
var statement = readStatement(l,expTs);
xmlType(statement,xmlTs,expTs);
break;
case "FUNCTION" :
var statement = readStatement(l,expTs);
xmlFunction(statement,expTs,xmlTs);
break;
case "PROCEDURE" :
var statement = readStatement(l,expTs);
xmlProcedure(statement,expTs,xmlTs);
break;
case "RULE" :
var statement = readStatement(l,expTs);
xmlRule(statement,expTs,xmlTs);
break;
// PH
case "SUBTYPE_CONSTRAINT":
var statement = readStatement(l,expTs);
xmlSubtypeConstraint(statement,xmlTs,expTs);
break;
//case "(*" :
//var comment = readComment(l, expTs);
//userMessage(comment);
//break;
//case "--" :
//var comment = readDashComment(l, expTs);
//userMessage(comment);
//break;
default :
//debug("default: "+token+"]");
//debug(l);
break;
}//end switch
}//end while
xmlCloseElement("</express>",xmlTs);
//close the files
expTs.Close();
xmlTs.Close();
}//end function
// --------------------------------------------------------------------
// Main program for generating the XML for the ARM express of module
// --------------------------------------------------------------------
function MainArm() {
var cArgs = System.Environment.GetCommandLineArgs();
if (cArgs.length != 1) {
ErrorMessage("Incorrect arguments\ncscript express2xml.js <module>" );
return(false);
}
var module = cArgs(0);
currentExpFile = '../data/modules/'+module+'/arm.exp';
var xmlFile = '../data/modules/'+module+'/arm.xml';
var partNo = "";
Output2xml(currentExpFile, xmlFile, partNo);
}
// ------------------------------------------------------------
// Main program for generating the XML for the MIM express of module
// -----------------------------------------------------------
function MainMim() {
var cArgs = System.Environment.GetCommandLineArgs();
if (cArgs.length != 1) {
ErrorMessage("Incorrect arguments\ncscript express2xml.js <module>" );
return(false);
}
var module = cArgs(0);
currentExpFile = '../data/modules/'+module+'/mim.exp';
var xmlFile = '../data/modules/'+module+'/mim.xml';
var partNo = "";
Output2xml(currentExpFile, xmlFile, partNo);
}
// ------------------------------------------------------------
// Main program
// -----------------------------------------------------------
function Main() {
//get the command line arguments
var cArgs = WScript.Arguments;
// debug(cArgs.length);
// for (var i=0; i<cArgs.length; i++){
// WScript.Echo (cArgs(i));
//}
if ( !((cArgs.length == 1) || (cArgs.length == 2) || (cArgs.length == 3)) ) {
var msg="Incorrect arguments\n"+
" express2xml.js <express>\nOr\n"+
" express2xml.js <module> arm\nOr\n"+
" express2xml.js <module> arm_lf\nOr\n"+
" express2xml.js <module> mim\nOr\n"+
" express2xml.js <module> mim_lf\nOr\n"+
" express2xml.js <module> module\nOr\n"+
" express2xml.js <resource> resource <part number>\n"+
" express2xml.js <reference> reference <directory>\n";
ErrorMessage(msg);
return(false);
}
userMessage("Warning: \n This script does not do any EXPRESS parsing, so if there are\n errors in the EXPRESS, then unexpected output may be produced.\n Furthermore, as the program is a string parser, assumptions have\n been made about the layout of the EXPRESS.\n It is advisable to display the resulting XML and compare with\n the orginal EXPRESS.\n\n");
var module, expFile, type;
if (cArgs.length > 1) {
switch(cArgs(1)) {
case "arm" :
var module = cArgs(0);
expFile = '../data/modules/'+module+'/arm.exp';
currentExpFile=expFile;
var xmlFile = expFile.replace("\.exp","\.xml");
var partNo = "";
Output2xml(expFile, xmlFile, partNo);
break;
case "mim" :
var module = cArgs(0);
expFile = '../data/modules/'+module+'/mim.exp';
currentExpFile=expFile;
var xmlFile = expFile.replace("\.exp","\.xml");
var partNo = "";
Output2xml(expFile, xmlFile, partNo);
break;
case "mim_lf" :
var module = cArgs(0);
expFile = '../data/modules/'+module+'/mim_lf.exp';
currentExpFile=expFile;
var xmlFile = expFile.replace("\.exp","\.xml");
var partNo = "";
Output2xml(expFile, xmlFile, partNo);
break;
case "arm_lf" :
var module = cArgs(0);
expFile = '../data/modules/'+module+'/arm_lf.exp';
currentExpFile=expFile;
var xmlFile = expFile.replace("\.exp","\.xml");
var partNo = "";
Output2xml(expFile, xmlFile, partNo);
break;
case "resource" :
var resource = cArgs(0);
expFile = '../data/resources/'+resource+'/'+resource+'.exp';
currentExpFile=expFile;
var xmlFile = expFile.replace("\.exp","\.xml");
if (cArgs.length>2) {
var partNo = cArgs(2);
Output2xml(expFile, xmlFile, partNo);
}
else {
var partNo = "";
Output2xml(expFile, xmlFile, partNo);
}
break;
case "reference" :
var reference = cArgs(0);
if (cArgs.length>2) {
var origin = cArgs(2);
}
else {
var origin = "";
}
expFile = '../data/reference/'+origin+'/'+reference+'.exp';
currentExpFile=expFile;
var xmlFile = expFile.replace("\.exp","\.xml");
Output2xml(expFile, xmlFile, origin);
break;
case "module" :
var module = cArgs(0);
var xmlFile;
// arm
expFile = '../data/modules/'+module+'/arm.exp';
currentExpFile=expFile;
xmlFile = expFile.replace("\.exp","\.xml");
var partNo = "";
Output2xml(expFile, xmlFile, partNo);
// mim
expFile = '../data/modules/'+module+'/mim.exp';
currentExpFile=expFile;
xmlFile = expFile.replace("\.exp","\.xml");
var partNo = "";
Output2xml(expFile, xmlFile, partNo);
// mim long form
expFile = '../data/modules/'+module+'/mim_lf.exp';
currentExpFile=expFile;
xmlFile = expFile.replace("\.exp","\.xml");
var partNo = "";
Output2xml(expFile, xmlFile, partNo);
break;
}//end switch
}
else {
expFile = cArgs(0)+".exp";
currentExpFile=expFile;
var xmlFile = expFile.replace("\.exp","\.xml");
var partNo = "";
Output2xml(expFile, xmlFile, partNo);
}
}//end function
// ---------------------------------------------------------------
// Call Main program
// ---------------------------------------------------------------
Main();
Hi Installed on mac os x 10.11.5 with sudo pip install jiphy [no errors]
Here is a run sequence that failed (no output, app hangs): jiphy -o py -i js express2xml.js
^CTraceback (most recent call last): File "/usr/local/bin/jiphy", line 9, in
load_entry_point('jiphy==1.2.1', 'console_scripts', 'jiphy')()
File "/Library/Python/2.7/site-packages/jiphy/main.py", line 129, in main
output_code = jiphy.to.python(input_code)
File "/Library/Python/2.7/site-packages/jiphy/to.py", line 41, in python
return ast(code).python
File "/Library/Python/2.7/site-packages/jiphy/handlers.py", line 168, in python
return self._python()
File "/Library/Python/2.7/site-packages/jiphy/handlers.py", line 164, in _python
return (self.started_on or '') + self.python_content + (self.ended_on or '')
File "/Library/Python/2.7/site-packages/jiphy/handlers.py", line 161, in python_content
return "".join((child.python for child in self.children))
File "/Library/Python/2.7/site-packages/jiphy/handlers.py", line 161, in
return "".join((child.python for child in self.children))
...
Here is the input source file:
// $Id: express2xml.js,v 1.38 2004/08/24 16:58:55 thendrix Exp $ // Author: Rob Bodington, Eurostep Limited // Owner: Developed by Eurostep and supplied to NIST under contract. // // Other editors: // T. Hendrix (aka THX and TEH)(Boeing) // P. Huau (GOSET) for subtype_constraint and algorithms of global rules // S. Frechette (NIST) // // Open issues: // Script does not handle SELF\ construct correctly - deletes it in most cases // // Recent changes: 2004 summer // Added handling for type labels in function formal params // Added handling of constants that are aggregates. // Fixed abstract supertype in subtype constraints. // function xmlEnumeration: // Still to do ???? // width CDATA #IMPLIED // fix (YES | NO) "NO" // precision CDATA #IMPLIED // typelabel NMTOKEN #IMPLIED
// Purpose: // JScript to convert an Express file to an XML file // cscript express2xml.js
// cscript express2xml.js arm
// cscript express2xml.js mim
// cscript express2xml.js mim_lf
// cscript express2xml.js module
// cscript express2xml.js resource
// cscript express2xml.js reference
//
// e.g.,
// cscript express2xml.js part_and_version_identification arm
// cscript express2xml.js action_schema resource "ISO 10303-41"
// cscript express2xml.js pdm_schema_12 reference "pdm_if"
// file is stepmod\pdm_if\pdm_schema_12.exp
// ------------------------------------------------------------ // Global variables // ----------------------------------------------------------- var ForReading = 1, ForWriting = 2, ForAppending = 8;
var TristateUseDefault = -2, TristateTrue = -1, TristateFalse = 0;
// The line number of the file being read. // Only used in Warnings to user var lNumber = 0;
// The express file being currently parsed // Only used in Warnings to user var currentExpFile = 0;
// The string added to the begining of the xml ouput to indent the output var indent = "";
// Add a functioncalled trim as a method of the prototype // object of the String constructor. //String.prototype.trim = function() { // // Use a regular expression to replace leading and trailing // // spaces with the empty string // return this.replace(/(^\s)|(\s$)/g, ""); //}
// ------------------------------------------------------------ // function debug() // Print debug text to screen // ------------------------------------------------------------ function debug(txt){ WScript.Echo("Dbx: "+txt); }
// ------------------------------------------------------------ // function userMessage() // Print to command screen // ------------------------------------------------------------ function userMessage(msg){ WScript.Echo(msg); }
// ------------------------------------------------------------ // function errorMessage() // Print error message to command screen // ------------------------------------------------------------ function ErrorMessage(msg){ var objShell = WScript.CreateObject("WScript.Shell"); objShell.Popup(msg); }
// ------------------------------------------------------------ // function readStatement() // Return a statement terminated by ";" // ------------------------------------------------------------ function readStatement(line, ts) { var pos;
}//end function
// ------------------------------------------------------------ // function normaliseStatement() // Separate all , and ( ) with whitespace, remove all tabs etc // ------------------------------------------------------------ function normaliseStatement(statement) {
//TEH added
statement = statement.replace(/(\w)=/g,"$1 ="); statement = statement.replace(/=(\w)/g,"= $1"); statement = statement.replace(/=\'/g,"= \'"); statement = statement.replace(/:(\?)/g,": $1"); statement = statement.replace(/:(\w)/g,": $1"); statement = statement.replace(/(\w):/g,"$1 :"); //end TEH added // replace double space with single space while (statement.search(/ /) != -1) { statement = statement.replace(/ /g," "); }
}
// ------------------------------------------------------------ // function getWord() // Get the nth word of a string // ------------------------------------------------------------ function getWord(n, statement) { statement = normaliseStatement(statement); var arr = statement.split(" ");
}
// ------------------------------------------------------------ // function getList() // Return the contents of everything enclosed in () // ------------------------------------------------------------ function getList(statement) { var list = normaliseStatement(statement); var reg = /(.*)/;
list = list.match( reg );
}
// ------------------------------------------------------------ // function readNextLine() // read a line, bypass any comments or blank lines // ------------------------------------------------------------ function readNextLine(ts) { var line = ts.ReadLine(); lNumber = ts.Line; line = trim(line); //debug ("1 "+line);
}
// ------------------------------------------------------------ // function list2array() // Given a statement, extract the (list) into an array // ------------------------------------------------------------ function list2array(statement) { var arr = -1;
}
// ------------------------------------------------------------ // deprecated function: list2arrayOld (replaced by list2array()) // Given a statement, extract the (list) into an array // ------------------------------------------------------------ //function list2arrayOld(statement) { // var arr; // var list = getList(statement); // if (list) {
// // remove all the whitespace // //list = list.replace(/ /g,""); // arr = list.split(" "); // } // return(arr) //}
// ------------------------------------------------------------ // function splitList() // Given a string, return and array. // Array[0] is the nth list in the string where n is the listNo // Array[1] is the rest of the strig after the list // ------------------------------------------------------------ function splitList(str, listNo) { var reg = /(.*)/;
var list = str.match( reg ); var listArr = new Array(); var parenCnt = 0; var listCnt = 0; var listStr = "";
}
// ------------------------------------------------------------ // function isOptional() // Return true if an attribute statment is OPTIONAL // It will be the first word after the colon. // ------------------------------------------------------------ function isOptional(statement) { statement = getAfterColon(statement); var word = getWord(1,statement); var result = false; if (word=="OPTIONAL") result = true; return (result); }
// ------------------------------------------------------------ // function isRedeclared() // Return true if statement contains "SELF" // ------------------------------------------------------------ function isRedeclared(statement) { var result = false; var reg = /\bSELF\b/i; var token = statement.match(reg); if (token) result = true; return (result); }
// ------------------------------------------------------------ // function getAfterColon() // Return everything after the : removing the ; // ------------------------------------------------------------ function getAfterColon(statement) { var expr = ""; var reg = /:/; var pos = statement.search(reg); if (pos) { expr = statement.substr(pos+1); expr = expr.replace(/^\s/g,""); expr = expr.replace(/\;/,""); } return(expr); }
// ------------------------------------------------------------ // function getAfterEquals() // Return everything after the := removing the ; // ------------------------------------------------------------ function getAfterEquals(statement) { var expr = ""; var pos = -1; var reg = /\=/; var pos = statement.search(reg); if (pos != -1) { expr = statement.substr(pos+1); expr = expr.replace(/^\s/g,""); expr = expr.replace(/\;/,""); } return(expr); }
// ------------------------------------------------------------ // function readComment() // Return a statement terminated by ; // calls recursive function readCommentRecurse() to get the comment // ------------------------------------------------------------ function readComment(line, ts) { var reg = /^\s(\/; var pos = line.search(reg); var comment = -1;
}
// ------------------------------------------------------------ // function readCommentRecurse() // Recursive function called by readComment() // ------------------------------------------------------------ function readCommentRecurse(line, ts) { var comment = ""; if (ts.AtEndOfStream) { return(line); }
else { var reg = /*)/; var pos = line.search(reg); if (pos == -1) { comment = line + "\n" + readCommentRecurse(ts.ReadLine(), ts); } else { //comment = line.substr(0,pos); comment = line; } return(comment); } }
// ------------------------------------------------------------ // function readToken() // Return the first word in the line or (* // ------------------------------------------------------------ function readToken(line) { // get the first word var reg = /^\s\b\w\b/i; var token = line.match(reg);
//thx added 20040813
case "ABSTRACT" : var reg = /^\sABSTRACT SUPERTYPE\b/i; token = line.match(reg); if (token) { token = token[0].replace(/\s/g,""); token = token.toString(); } break;
}
// ------------------------------------------------------------ // function xmlFileHeader() // Write the xml file header // ------------------------------------------------------------ function xmlFileHeader(outTs) { outTs.Writeline("<?xml version='1.0' encoding='UTF-8'?>"); outTs.Writeline(""); outTs.Writeline("<?xml-stylesheet type=\"text\/xsl\" href=\"..\/..\/..\/xsl\/express.xsl\"?>"); outTs.Writeline("<!DOCTYPE express SYSTEM \"../../../dtd/express.dtd\">");
}
// ------------------------------------------------------------ // function getApplicationRevision() // Return the revision of this application // ------------------------------------------------------------ function getApplicationRevision() { // get CVS to set the revision in the variable, then extract the // revision from the string. // SPF: not interacting with CVS var appCVSRevision = "$Revision: 1.38 $"; var appRevision = appCVSRevision.replace(/Revision:/,""); appRevision = appRevision.replace(/\$/g,""); appRevision = trim(appRevision); //appRevision.trim(); // SPF: trim is now a function not a method return(appRevision); }
// ------------------------------------------------------------ // function trim() // Trim white space from both ends of a string // ------------------------------------------------------------ function trim(s) { return s.replace(/(^\s+)|(\s+$)/g, "") }
// ------------------------------------------------------------ // function xmlApplication() // ------------------------------------------------------------ function xmlApplication(outTs) { var appRevision = getApplicationRevision(); xmlOpenElement("<application",outTs); xmlAttr("name","express2xml2.js",outTs); xmlAttr("owner","Eurostep Limited",outTs); xmlAttr("url","http://www.eurostep.com",outTs); xmlAttr("version",appRevision,outTs); xmlAttr("source",currentExpFile,outTs); xmlCloseAttr(outTs); outTs.WriteLine(); }
// ------------------------------------------------------------ // function xmlOpenSchema() // Open the schema XML element // ------------------------------------------------------------ function xmlOpenSchema(statement, outTs) { var schema = getWord(2,statement); xmlOpenElement("<schema name=\""+schema,outTs); outTs.WriteLine("\">"); outTs.WriteLine(""); }
// ------------------------------------------------------------ // function xmlCloseSchema() // Close the schema XML element // ------------------------------------------------------------ function xmlCloseSchema(outTs) { xmlCloseElement("",outTs); }
// ------------------------------------------------------------ // function xmlConstant() // ------------------------------------------------------------ function xmlConstant(statement,expTs,outTs) { var name; var expr; var type; var arr; var line; var reg; var reg2; var reg3; var token;
}
function xmlInstanciableType(type,outTs) { var typeType = getType(type); //debug("St:"+statement); //debug("tn:"+typeName); //debug("tt:"+typeType);
// xmlAttr("name",typeType,outTs); xmlCloseAttr(outTs); break; }
//outTs.WriteLine(""); // xmlInstanciableType(type,outTs); }
// ------------------------------------------------------------ // function getAbstractSuper() // ------------------------------------------------------------ function getAbstractSuper(statement) { statement = normaliseStatement(statement); var reg = /.*ABSTRACT SUPERTYPE\b/i; var token = statement.match(reg); return(token);
}
// ------------------------------------------------------------ // function xmlAbstract() // ------------------------------------------------------------ function xmlAbstract(outTs) { xmlAttr("abstract.supertype", "YES", outTs); }
// ------------------------------------------------------------ // function xmlSuperExpression() // Return the supertype expression. // Format may be: // SUPERTYPE OF (ONEOF(next_assembly_usage_occurrence, specified_higher_usage_occurrence,promissory_usage_occurrence)) // SUBTYPE OF (product_definition_usage); // ------------------------------------------------------------ function xmlSuperExpression(statement, outTs) { var reg = /.*SUPERTYPE OF/i; var token = statement.match(reg); var superExpr = ""; if (token) { // remove the SUPERTYPE OF words superExpr = statement.replace(reg,""); // get the list after the SUPERTYPE OF words var listArr = splitList(superExpr,1); superExpr = listArr[0]; reg = /;/; superExpr = superExpr.replace(reg,""); xmlAttr("super.expression", superExpr, outTs); } }
// ------------------------------------------------------------ // function xmlSupertypes() // ------------------------------------------------------------ function xmlSupertypes(statement, outTs) { var reg = /.*SUBTYPE OF\b/i; var token = statement.match(reg); var token = statement.match(reg); var supertypes = ""; if (token) { supertypes = statement.replace(reg,""); reg = /;/; supertypes = supertypes.replace(reg,""); supertypes = getList(supertypes); xmlAttr("supertypes", supertypes, outTs); } }
// ------------------------------------------------------------ // function xmlOpenEntity() // Open the entity XML element // ------------------------------------------------------------ function xmlOpenEntity(statement,outTs,expTs) { xmlOpenElement("<entity",outTs); var entity = getWord(2,statement); // entity = entity.toLowerCase(); xmlAttr("name",entity,outTs); if (getAbstractSuper(statement)) xmlAbstract(outTs); xmlSuperExpression(statement,outTs); xmlSupertypes(statement,outTs); outTs.WriteLine(">"); xmlEntityStructure(outTs, expTs, "explicit"); }
// ------------------------------------------------------------ // function xmlCloseEntity // Close the entity XML entity // ------------------------------------------------------------ function xmlCloseEntity(outTs) { xmlCloseElement("",outTs); }
// ------------------------------------------------------------ // function xmlEntityStructure() // ------------------------------------------------------------ function xmlEntityStructure(outTs,expTs,mode) { var l = readNextLine(expTs);
//TEH added if (isRedeclared(name)) { xmlRedeclaredAttribute(name.replace(/^.*\/,"").replace(/.$/,""), outTs); } //end TEH added xmlCloseElement("",outTs);
}
// ------------------------------------------------------------ // function: getRedeclaredAttribute() // SELF\Representation.context_of_items : Geometric_coordinatespace; // Return the name of a redeclared attribute // ------------------------------------------------------------ function getRedeclaredAttribute(statement, outTs) { statement = trim(statement); statement = statement.replace(/^../g,""); var attr = statement.replace(/:._/g,""); attr = trim(attr); return(attr); }
// ------------------------------------------------------------ // function: xmlRedeclaredAttribute() // SELF\Representation.context_of_items : Geometric_coordinate_space; // Output a redeclared attribute by matching on SELF\ // ------------------------------------------------------------ function xmlRedeclaredAttribute(statement, outTs) { statement = statement.replace(/^\s_SELF\/,""); var entityref = statement.replace(/../g,""); xmlOpenElement("<redeclaration",outTs); xmlAttr("entity-ref",entity_ref,outTs); outTs.WriteLine("/>");
}
// ------------------------------------------------------------ // function xmlUnique() // ------------------------------------------------------------ function xmlUnique(statement, outTs) { var name = getWord(1,statement); xmlOpenElement("<unique",outTs);
xmlAttr("label",name,outTs); outTs.WriteLine(">");
//TEH modified - need to add entity-ref attr if SELF if (isRedeclared(arr[i])){
//end TEH modified tmp = arr[i].replace(/^SELF\/,"");
}
// ------------------------------------------------------------ // function getInverseEntity() // ------------------------------------------------------------ function getInverseEntity(statement) { statement=normaliseStatement(statement); var entity; var pos = statement.search(/\bOF\b/i); if (pos > 0) { entity = statement.substr(pos+3); entity = getWord(1,entity); } else { pos = statement.search(/:/); entity = statement.substr(pos+1); entity = getWord(1,entity); } return(entity); }
// ------------------------------------------------------------ // function getInverseAttr() // ------------------------------------------------------------ function getInverseAttr(statement) { statement=normaliseStatement(statement); var pos = statement.search(/\bFOR\b/i); var attr = statement.substr(pos+4); attr = getWord(1,attr); return(attr); }
// ------------------------------------------------------------ // function xmlAggregate() // Output elements for aggregate // ------------------------------------------------------------ function xmlAggregate(statement, outTs) { var reg = /\bSET\b|\bBAG\b|\bLIST\b|\bARRAY\b/i; var agg = statement.match(reg); if (agg) { agg = agg.toString(); agg = agg.toUpperCase(); var opos = statement.search(/[/); var cpos = statement.search(/]/); var bounds = statement.substr(opos+1, cpos-opos-1); bounds = bounds.replace(/\s/g,""); var lower = bounds.match(/.*:/);
//debug TEH // debug("opos " + opos); // debug("cpos " + cpos); // debug("bounds " + bounds); // debug("bounds.length " + bounds.length); // debug("lower " + lower);
// "if" added by TEH to enable else, which deals with implied bounds. // After experimenting with GE, I decide to coerce explicit bounds in all cases // rather than fix the display in the case where no bounds are in the express if (bounds.length > 0) { lower = lower[0].replace(/:/,""); var upper = bounds.match(/:.*/); upper = upper[0].replace(/:/,""); xmlOpenElement("<inverse.aggregate",outTs); xmlAttr("type",agg,outTs); xmlAttr("lower",lower,outTs); xmlAttr("upper",upper,outTs); xmlCloseAttr(outTs); } else{ xmlOpenElement("<inverse.aggregate",outTs); xmlAttr("type",agg,outTs); xmlAttr("lower",'0',outTs); xmlAttr("upper",'?',outTs); xmlCloseAttr(outTs); } } }
// ------------------------------------------------------------ // function xmlSuperExpression_cst() // ------------------------------------------------------------ function xmlSuperExpression_cst(statement, outTs) { var superExpr = statement; var reg = /\;/; superExpr = superExpr.replace(reg,""); xmlAttr("super.expression", superExpr, outTs); }
// ------------------------------------------------------------ // function xmlSubtypeConstraint() // ------------------------------------------------------------ function xmlSubtypeConstraint(statement,outTs,expTs) { var constName = getWord(2,statement); var entity_ref = getWord(4,statement); xmlOpenElement("<subtype.constraint name=\""+constName+"\"",outTs); xmlAttr("entity",entity_ref,outTs); xmlConstraintStructure(outTs, expTs, "supertype_expression"); }
// ------------------------------------------------------------ // function xmlConstraintStructure() // ------------------------------------------------------------ function xmlConstraintStructure(outTs,expTs,mode) { var l = readNextLine(expTs);
}
// ------------------------------------------------------------ // function xmlInterface() // ------------------------------------------------------------ function xmlInterface(statement, outTs) { statement = normaliseStatement(statement); xmlOpenElement("<interface",outTs); var kind = getWord(1,statement).toLowerCase(); xmlAttr("kind",kind,outTs); var schema = getWord(3,statement); xmlAttr("schema",schema,outTs); outTs.WriteLine(">"); var lArr = list2array(statement); if (lArr != -1) { for (var i=0; i<lArr.length; i++) { xmlOpenElement("<interfaced.item",outTs); var line = trim(lArr[i]); var reg = /\bAS\b/i; var as = line.match(reg); var entity, alias; if (as) { var ifLine = line.split(" "); entity = ifLine[0]; alias = ifLine[2]; //debug('{'+entity+' = '+alias+'}');
xmlAttr("name",entity,outTs);
xmlAttr("alias",alias,outTs); } else { entity = line; xmlAttr("name",entity,outTs);
} xmlCloseAttr(outTs); } } xmlCloseElement("",outTs); }
// ------------------------------------------------------------ // function xmlUnderlyingType() // tage the underlying type // ------------------------------------------------------------ function xmlUnderlyingType(statement,outTs) { statement = normaliseStatement(statement);
// PH: Add aggregate for function parameters var reg = /\bSET\b|\bBAG\b|\bLIST\b|\bARRAY\b|\bAGGREGATE\b/i; var agg = statement.match(reg);
//thx added reg = /:/i;
}
// ---------------------------------------------------------- // function tidyExpression() // Replace all <> in the expression // ------------------------------------------------------------ function tidyExpression(expr) { expr = trim(expr); expr = expr.replace(/>/g,">"); expr = expr.replace(/</g,"<"); expr = expr.replace(/\"/g,""");
// expr = expr.replace(/^SELF\/,"");
}
// ------------------------------------------------------------ // function getExtensibleBasedOn() // Return the BASED_ON type // ------------------------------------------------------------ function getExtensibleBasedOn(extensibleStatement) { extensibleStatement = normaliseStatement(extensibleStatement); var type = -1; var reg = /\bBASED_ON\b/i; var pos = extensibleStatement.search(reg); if (pos != -1) { // get the word after BASED_ON extensibleStatement = extensibleStatement.substr(pos+9); pos = extensibleStatement.search(" "); type = extensibleStatement.substr(0,pos); } return(type); }
// ------------------------------------------------------------ // function xmlSelect() // genericentity (YES | NO) "NO" // ------------------------------------------------------------ function xmlSelect(statement,outTs) {
xmlOpenElement("<select",outTs); var reg = /\bEXTENSIBLE\b/i;
// selectItems = selectItems.toLowerCase(); xmlAttr("selectitems",selectItems,outTs); }
}
// ------------------------------------------------------------ // function xmlSelect() // genericentity (YES | NO) "YES" // ------------------------------------------------------------ function xmlEnumeration(statement,outTs) { xmlOpenElement("<enumeration",outTs); var reg = /\bEXTENSIBLE\b/i;
// TEH: Still to do? // width CDATA #IMPLIED // fix (YES | NO) "NO" // precision CDATA #IMPLIED // typelabel NMTOKEN #IMPLIED
// ------------------------------------------------------------ // function xmlBuiltInType() // tag builtin type // ------------------------------------------------------------ function xmlBuiltInType(typeType,statement,outTs) { xmlOpenElement("<builtintype",outTs); xmlAttr("type",typeType,outTs); outTs.WriteLine(">"); xmlCloseElement("",outTs); }
// ------------------------------------------------------------ // function getType() // Get the type and return // ------------------------------------------------------------ function getType(statement) { var reg = /\bSET\b|\bBAG\b|\bLIST\b|\bARRAY\b|\bAGGREGATE\b|\bSELECT\b|\bENUMERATION\b|\bBINARY\b|\bBOOLEAN\b|\bINTEGER\b|\bLOGICAL\b|\bNUMBER\b|\bREAL\b|\bSTRING\b/i; var type = statement.match(reg); //debug("getType1:"+type);
}
// ------------------------------------------------------------ // function xmlType() // identify the express type and process // ------------------------------------------------------------ function xmlType(statement,outTs,expTs) { var typeName = getWord(2,statement); // typeName = typeName.toLowerCase(); xmlOpenElement("<type name=\""+typeName,outTs); outTs.WriteLine("\">"); var typeType = getType(statement); //debug("St:"+statement); //debug("tn:"+typeName); //debug("tt:"+typeType);
}
// ------------------------------------------------------------ // dep function // ------------------------------------------------------------ //function xmlTypeStructureOld(xmlTs,expTs) { // var l = expTs.ReadLine(); // //debug("L:"+l); // lNumber = expTs.Line; // var token = readToken(l); // switch( token ) { // case "END_TYPE" : // xmlCloseElement("",xmlTs); // break; // case "WHERE" : // // assumes WHERE is on new line // xmlTypeStructure(xmlTs,expTs); // break; // // default : // // only called when in a where definition // var statement = readStatement(l,expTs); // // //debug("ss:"+statement); // var name = getWord(1,statement); //
// var expr = getAfterColon(statement); // var reg = /^\s*/; // expr = expr.replace(reg,""); // expr = tidyExpression(expr); // xmlOpenElement("<where",xmlTs); // xmlAttr("label",name,xmlTs); // xmlAttr("expression",expr,xmlTs); // xmlTs.WriteLine(">"); // xmlCloseElement("",xmlTs); // xmlTypeStructure(xmlTs,expTs); // break; // // } //}
// ------------------------------------------------------------ // function xmlTypeStructure()
// ------------------------------------------------------------ function xmlTypeStructure(xmlTs,expTs) { var l = readNextLine(expTs); //debug("L:"+l);
}
// ------------------------------------------------------------ // Object declaration FunctionObj() // ------------------------------------------------------------ function FunctionObj(name) { this.name = name; this.paramStr =""; this.retStr = ""; this.algorithm = ""; }
// ------------------------------------------------------------ // FunctionObj method loadParamList() // ------------------------------------------------------------ FunctionObj.prototype.loadParamList = function(paramList,expTs,outTs) { var closeParen = paramList.search(/)/);
}
// ------------------------------------------------------------ // FunctionObj method xmlParamList() // get the parameter list // ------------------------------------------------------------ FunctionObj.prototype.xmlParamList = function (outTs) { this.paramStr = trim(this.paramStr); var paramArr1 = this.paramStr.split(";");
// there may be more than one parameter with the same type definition // e.g., FUNCTION first_proj_axis(z_axis,arg : direction) : direction; // SPF: fine, but this only works for one more parameter
// get the params var params = paramArr1[i].replace(/:.*/,""); var rest = getAfterColon(paramArr1[i]); var paramArr2 = params.split(",");
var typedef = paramArr1[i].substring(params.length); typedef = trim(rest);
}
// ------------------------------------------------------------ // FunctionObj method loadRtnStr() // return string // ------------------------------------------------------------ FunctionObj.prototype.loadRtnStr = function (retStr,expTs,outTs) { this.rtnStr = readStatement(retStr,expTs); this.rtnStr = normaliseStatement(this.rtnStr); this.rtnStr = trim(this.rtnStr); this.rtnStr = this.rtnStr.replace(/;/g,""); this.rtnStr = this.rtnStr.replace(/^:/g,""); this.rtnStr = trim(this.rtnStr); }
// ------------------------------------------------------------ // FunctionObj method xmlRtnStr() // xml return string // ------------------------------------------------------------ FunctionObj.prototype.xmlRtnStr = function (outTs) { xmlUnderlyingType(this.rtnStr,outTs);
}
// ------------------------------------------------------------ // FunctionObj method loadAlgorithm() // read in the algorithm and write in to the xml file // ------------------------------------------------------------ FunctionObj.prototype.loadAlgorithm = function(algoStr,expTs,outTs) { var line = readNextLine(expTs);
//TEH modified for case when these are on same line as last part of alogorithm // var reg = /\bEND_FUNCTION|END_PROCEDURE|WHERE/i; // if (line.match(reg)) { // var pos = line.search(/\bEND_FUNCTION|END_PROCEDURE|WHERE/i); if (pos != -1) { line=line.substr(0,pos) this.algorithm = algoStr+"\n" +line; } //
else { line = trim(line); algoStr = algoStr+"\n"+line; this.loadAlgorithm(algoStr,expTs,outTs); } // return -1 if there is no algorithm if (algoStr == "") { return -1; }
}
// ------------------------------------------------------------ // FunctionObj method xmlAlgorithm() // ------------------------------------------------------------ FunctionObj.prototype.xmlAlgorithm = function(outTs){ xmlOpenElement("<algorithm",outTs); outTs.WriteLine(">"); outTs.WriteLine(tidyExpression(this.algorithm)); xmlCloseElement("",outTs); }
// ------------------------------------------------------------ // function xmlFunction // ------------------------------------------------------------ function xmlFunction(line,expTs,outTs) { var name = getWord(2,line); var fnObj = new FunctionObj(name);
// TEH - algorithm is loaded in xmlParamList fnObj.xmlAlgorithm(outTs); xmlCloseElement("",outTs); }
// ------------------------------------------------------------ // function xmlProcedure() // ------------------------------------------------------------ function xmlProcedure(line,expTs,outTs) { var name = getWord(2,line); var fnObj = new FunctionObj(name);
//TEH algorithm is loaded in xmlParamList fnObj.xmlAlgorithm(outTs); xmlCloseElement("",outTs); }
// ------------------------------------------------------------ // function loadDomainRule() // found a WHERE // ------------------------------------------------------------ function loadDomainRule(expTs,outTs) { var line = readNextLine(expTs);
}
// ------------------------------------------------------------ // function xmlRule() // ------------------------------------------------------------ function xmlRule(line,expTs,outTs) { var statement = readStatement(line,expTs); var name = getWord(2,line); var appliesTo = getList(statement); var fnObj = new FunctionObj(name);
// ------------------------------------------------------------ // function xmlOpenElement() // ------------------------------------------------------------ function xmlOpenElement(xmlElement, outTs) { var txt = indent+xmlElement; outTs.Write(txt); indent = indent+" "; }
// ------------------------------------------------------------ // function xmlCloseElement() // close xml element tag // ------------------------------------------------------------ function xmlCloseElement(xmlElement, outTs) { if (indent.length >= 2) { indent = indent.substr(2); } else { indent = indent+"-------"; }
}
// ------------------------------------------------------------ // function xmlAttr() // Output an indented attribute // ------------------------------------------------------------ function xmlAttr(name, value, outTs) { // SPF: delete "SELF\" ISSUE: this is not the correct way to process SELF\ // xml will not validate with "SELF\" // value = value.replace(/SELF\/,"");
}
// ------------------------------------------------------------ // function xmlCloseAttr() // close attribute tag // ------------------------------------------------------------ function xmlCloseAttr(outTs) { outTs.WriteLine("/>");
}
// ------------------------------------------------------------ // function Output2xml() // this is the main routine // read express file line, process, write to xml file // ------------------------------------------------------------ function Output2xml(expFile, xmlFile, partnumber) { userMessage("Reading EXPRESS from file: " + expFile); userMessage(""); userMessage(" Writing XML to file: " + xmlFile);
}//end function
// -------------------------------------------------------------------- // Main program for generating the XML for the ARM express of module // -------------------------------------------------------------------- function MainArm() {
var cArgs = System.Environment.GetCommandLineArgs();
}
// ------------------------------------------------------------ // Main program for generating the XML for the MIM express of module // ----------------------------------------------------------- function MainMim() { var cArgs = System.Environment.GetCommandLineArgs();
}
// ------------------------------------------------------------ // Main program // ----------------------------------------------------------- function Main() { //get the command line arguments var cArgs = WScript.Arguments;
}//end function
// --------------------------------------------------------------- // Call Main program // --------------------------------------------------------------- Main();