id
stringlengths 36
36
| text
stringlengths 1
1.25M
|
|---|---|
eea14503-2c13-47a1-ac74-f3b363f040af
|
public crmondemand.xml.customobject6.query.QueryType getCustomBoolean11() {
return this.customBoolean11;
}
|
3c90716e-d2bd-4b45-a95a-bfe4ecb45889
|
public java.lang.Boolean getCustomBoolean3() {
return this.customBoolean3;
}
|
9c0f8bde-ca14-48a5-814b-6f89ba9f8cc2
|
private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.oracle.xmlns.oxp.service.publicreportservice.CreateReport param, boolean optimizeContent)
throws org.apache.axis2.AxisFault{
try{
org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
emptyEnvelope.getBody().addChild(param.getOMElement(com.oracle.xmlns.oxp.service.publicreportservice.CreateReport.MY_QNAME,factory));
return emptyEnvelope;
} catch(org.apache.axis2.databinding.ADBException e){
throw org.apache.axis2.AxisFault.makeFault(e);
}
}
|
bf5fb39a-3aeb-4401-9a24-49c3c90cd2d3
|
public void setCustomPickList51(crmondemand.xml.customobject6.query.QueryType customPickList51) {
this.customPickList51 = customPickList51;
}
|
12cae8d6-3630-4e39-8078-1b013f7eaa40
|
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton1ActionPerformed(evt);
}
|
776438ee-7acb-49d4-92f2-f19b95da19b2
|
public crmondemand.xml.customobject6.query.QueryType getPolicyCurrencyCode() {
return this.policyCurrencyCode;
}
|
e09fb595-79b8-4a2c-a2d9-c9187b9c19fa
|
public java.math.BigDecimal getCustomCurrency0() {
return this.customCurrency0;
}
|
a145829c-0646-48ad-9a8e-61fd54dd57b8
|
public java.math.BigDecimal getCustomNumber9() {
return this.customNumber9;
}
|
e5ed2f03-8bc2-4983-9bfe-9f429f86807e
|
public void setCustomPickList65(crmondemand.xml.customobject3.query.QueryType customPickList65) {
this.customPickList65 = customPickList65;
}
|
9e5762a7-b557-4ff2-a059-03e57c29114e
|
public java.lang.String getCustomText42() {
return this.customText42;
}
|
a37ee9df-3269-4e01-b434-679bf7445ba4
|
public crmondemand.xml.customobject6.query.QueryType getCustomObject14ExternalSystemId() {
return this.customObject14ExternalSystemId;
}
|
01463ea0-63e1-4db1-8dc9-14ae91d7cd91
|
public void setCustomPhone7(crmondemand.xml.customobject6.query.QueryType customPhone7) {
this.customPhone7 = customPhone7;
}
|
da6f4d7e-5e8c-45cd-b771-6efb1cc7111c
|
public crmondemand.xml.customobject3.query.QueryType getObjectiveExternalSystemId() {
return this.objectiveExternalSystemId;
}
|
cc7443f9-e2b6-4c5c-aad1-a3e1fd51e1fe
|
public java.lang.String getIntegrationId() {
return this.integrationId;
}
|
a9732ef9-4115-4362-87a8-a6ee202db85a
|
public void createChoices()
{
createChoices(CMClass.races());
choices().add("","");
for(int x=0;x<choices().size();x++)
choices().get(x).first = choices().get(x).first.toUpperCase();
}
|
8d93d1dc-0786-4dce-955e-4f1010e84434
|
public void setCustomPickList44(crmondemand.xml.customobject3.query.QueryType customPickList44) {
this.customPickList44 = customPickList44;
}
|
07d4e914-493e-45a3-90fd-116376fcd371
|
public void setCustomPhone13(java.lang.String customPhone13) {
this.customPhone13 = customPhone13;
}
|
7d2d2bbb-922f-47a7-ba1c-ebcb9770fad7
|
public void setCustomPickList80(crmondemand.xml.customobject6.query.QueryType customPickList80) {
this.customPickList80 = customPickList80;
}
|
e317969d-64d3-44ab-8453-4496b1d5b026
|
@Override
public boolean existeFabrica(String nombre) throws Exception {
AccesoBD accesoBD = new AccesoBD();
Collection movCol = null;
try {
accesoBD.iniciarTransaccion();
String filtro = "nombre.equals(\""+nombre+"\")";
movCol = accesoBD.buscarPorFiltro(Fabrica.class, filtro);
accesoBD.concretarTransaccion();
} catch (Exception e) {
accesoBD.rollbackTransaccion();
}
return (movCol != null && movCol.size()>=1);
}
|
ea049ce8-5eb6-42a1-bdcd-850b81e7d7fe
|
public void setExternalSystemId(java.lang.String externalSystemId)
{
this.externalSystemId = externalSystemId;
}
|
d87b480d-95d0-4406-9185-4c37ba8b021c
|
public void checkType()
{
AstType type = getType();
if (type.getType() != AstType.TYPE_BOOL)
{
reportTypeError("Predicates must evaluate to a boolean value",
m_token,
specObject,
property
);
}
}
}
public class AstPredicateExpression extends AstPredicate
{
AstExpression m_expression;
public AstPredicateExpression(SpecObject specObject, String property)
{
super(specObject, property);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = new AstSymbolTable(stable);
stable.addKid(m_stable);
m_expression.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_expression.populateSymbolTable();
}
public AstType getType()
{
return m_expression.getType();
}
}
public class AstForAllP extends AstPredicate
{
AstSchemaText m_schemaText;
AstPredicate m_predicate;
public AstForAllP(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
print(l, "ForAll - Predicate");
m_schemaText.print(l + 1);
m_predicate.print(l + 1);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = new AstSymbolTable(stable);
stable.addKid(m_stable);
m_schemaText.populateTypeTable(m_stable);
m_predicate.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_schemaText.populateSymbolTable();
m_predicate.populateSymbolTable();
}
public void checkType()
{
m_schemaText.checkType();
m_predicate.getType();
}
public AstType getType()
{
checkType();
return new AstType(AstType.TYPE_BOOL);
}
}
public class AstThereExistsP extends AstPredicate
{
AstSchemaText m_schemaText;
AstPredicate m_predicate;
public AstThereExistsP(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
print(l, "ThereExists - Predicate");
m_schemaText.print(l + 1);
m_predicate.print(l + 1);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = new AstSymbolTable(stable);
stable.addKid(m_stable);
m_schemaText.populateTypeTable(m_stable);
m_predicate.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_schemaText.populateSymbolTable();
m_predicate.populateSymbolTable();
}
public void checkType()
{
m_schemaText.checkType();
m_predicate.getType();
}
public AstType getType()
{
checkType();
return new AstType(AstType.TYPE_BOOL);
}
}
public class AstThereExists1P extends AstPredicate
{
AstSchemaText m_schemaText;
AstPredicate m_predicate;
public AstThereExists1P(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
print(l, "ThereExists1 - Predicate");
m_schemaText.print(l + 1);
m_predicate.print(l + 1);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = new AstSymbolTable(stable);
stable.addKid(m_stable);
m_schemaText.populateTypeTable(m_stable);
m_predicate.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_schemaText.populateSymbolTable();
m_predicate.populateSymbolTable();
}
public void checkType()
{
m_schemaText.checkType();
m_predicate.getType();
}
public AstType getType()
{
checkType();
return new AstType(AstType.TYPE_BOOL);
}
}
public class AstLetP extends AstPredicate
{
List m_lets = new ArrayList();
AstPredicate m_predicate;
public AstLetP(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
print(l, "let - Predicate");
m_predicate.print(l + 1);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_predicate.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_predicate.populateSymbolTable();
}
public void checkType()
{
m_predicate.getType();
}
public AstType getType()
{
checkType();
return new AstType(AstType.TYPE_BOOL);
}
}
public class AstAndP extends AstPredicate
{
AstPredicate m_predicateL;
AstPredicate m_predicateR;
public AstAndP(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
print(l, "AND - Predicate");
m_predicateL.print(l + 1);
m_predicateR.print(l + 1);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_predicateL.populateTypeTable(m_stable);
m_predicateR.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_predicateL.populateSymbolTable();
m_predicateR.populateSymbolTable();
}
public AstType getType()
{
m_predicateL.checkType();
m_predicateR.checkType();
return new AstType(AstType.TYPE_BOOL);
}
}
public class AstOrP extends AstPredicate
{
AstPredicate m_predicateL;
AstPredicate m_predicateR;
public AstOrP(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
print(l, "OR - Predicate");
m_predicateL.print(l + 1);
m_predicateR.print(l + 1);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_predicateL.populateTypeTable(m_stable);
m_predicateR.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_predicateL.populateSymbolTable();
m_predicateR.populateSymbolTable();
}
public AstType getType()
{
m_predicateL.checkType();
m_predicateR.checkType();
return new AstType(AstType.TYPE_BOOL);
}
}
public class AstImpliesP extends AstPredicate
{
AstPredicate m_predicateL;
AstPredicate m_predicateR;
public AstImpliesP(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
print(l, "IMPLIES - Predicate");
m_predicateL.print(l + 1);
m_predicateR.print(l + 1);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_predicateL.populateTypeTable(m_stable);
m_predicateR.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_predicateL.populateSymbolTable();
m_predicateR.populateSymbolTable();
}
public AstType getType()
{
m_predicateL.checkType();
m_predicateR.checkType();
return new AstType(AstType.TYPE_BOOL);
}
}
public class AstBiimpliesP extends AstPredicate
{
AstPredicate m_predicateL;
AstPredicate m_predicateR;
public AstBiimpliesP(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
print(l, "BIIMPLIES - Predicate");
m_predicateL.print(l + 1);
m_predicateR.print(l + 1);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_predicateL.populateTypeTable(m_stable);
m_predicateR.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_predicateL.populateSymbolTable();
m_predicateR.populateSymbolTable();
}
public AstType getType()
{
m_predicateL.checkType();
m_predicateR.checkType();
return new AstType(AstType.TYPE_BOOL);
}
}
public class AstRelationsP extends AstPredicate
{
List m_relations = new ArrayList();
AstExpression m_expressionL;
AstExpression m_expressionR;
public AstRelationsP(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
print(l, getName());
m_expressionL.print(l + 1);
m_expressionR.print(l + 1);
}
public String getName()
{
int i;
AstRelation rnode;
String name = "";
for (i = 0; i < m_relations.size(); i++)
{
rnode = (AstRelation) m_relations.get(0);
name += rnode.m_infixRelationName.m_token.m_value + " ";
}
return name;
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_expressionL.populateTypeTable(m_stable);
m_expressionR.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_expressionL.populateSymbolTable();
m_expressionR.populateSymbolTable();
}
public AstType getType()
{
AstRelation r = (AstRelation) m_relations.get(0);
AstType ret;
AstType t1 = m_expressionL.getType();
AstType t2 = m_expressionR.getType();
if ((t1.isUndefined())
|| (t2.isUndefined()))
{
return new AstType(AstType.TYPE_BOOL);
}
switch (r.m_infixRelationName.m_token.m_id)
{
case TozeTokenizer.TOKEN_MEM:
case TozeTokenizer.TOKEN_NEM:
if (!t2.isSet())
{
reportTypeError("Right side of " + getName() + " must be a set",
r.m_infixRelationName.m_token,
specObject,
property
);
}
if (!t1.isEqual(t2.m_setType))
{
reportTypeError("Element is not the same type as the set for " + getName(),
r.m_infixRelationName.m_token,
specObject,
property
);
}
break;
case TozeTokenizer.TOKEN_PSUBS:
case TozeTokenizer.TOKEN_SUBS:
if (!t1.isEqual(t2))
{
reportTypeError("Both sides of " + getName() + " must be sets of the same type",
r.m_infixRelationName.m_token,
specObject,
property
);
}
break;
case TozeTokenizer.TOKEN_EQUAL:
case TozeTokenizer.TOKEN_NEQ:
if (!t1.isCompatible(t2))
{
reportTypeError("Both sides of " + getName() + " must be the same type",
r.m_infixRelationName.m_token,
specObject,
property
);
}
break;
case TozeTokenizer.TOKEN_LESSTHAN:
case TozeTokenizer.TOKEN_LEQ:
case TozeTokenizer.TOKEN_GEQ:
case TozeTokenizer.TOKEN_GREATERTHAN:
if ((!t1.isANumber() || !t2.isANumber()))
{
reportTypeError("Both sides of " + getName() + " must be numbers",
r.m_infixRelationName.m_token,
specObject,
property
);
}
break;
case TozeTokenizer.TOKEN_PREFIX:
case TozeTokenizer.TOKEN_SUFFIX:
case TozeTokenizer.TOKEN_INSEQ:
if (!t2.isSequence())
{
reportTypeError("Right side of " + getName() + " must be a sequence",
r.m_infixRelationName.m_token,
specObject,
property
);
}
if (!t1.isSequence())
{
reportTypeError("Left side of " + getName() + " must be a sequence",
r.m_infixRelationName.m_token,
specObject,
property
);
}
if (!t1.isEqual(t2))
{
reportTypeError("Both sequences of " + getName() + " must be of the same type",
r.m_infixRelationName.m_token,
specObject,
property
);
}
return new AstType(AstType.TYPE_BOOL);
case TozeTokenizer.TOKEN_BAGMEMBERSHIP:
case TozeTokenizer.TOKEN_SQUAREIMAGEOREQUAL:
case TozeTokenizer.TOKEN_PARTITIONS:
return new AstType();
default:
return new AstType();
}
return new AstType(AstType.TYPE_BOOL);
}
}
public class AstRelation extends AstBase
{
AstIdentifier m_identifier;
AstInfixRelationName m_infixRelationName;
public void print(int l)
{
if (m_infixRelationName != null)
{
m_infixRelationName.print(l);
}
if (m_identifier != null)
{
m_identifier.print(l);
}
}
}
public class AstPrefixRelationNameP extends AstPredicate
{
AstPrefixRelationName m_prefixRelationName;
AstExpression m_expression;
public AstPrefixRelationNameP(SpecObject specObject, String property)
{
super(specObject, property);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_expression.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_expression.populateSymbolTable();
}
public void checkType()
{
AstType type = m_expression.getType();
if (!type.isSet())
{
reportTypeError("Expression for " + m_prefixRelationName.getName() + " must evaluate to a set",
m_expression.m_token,
specObject,
property
);
}
}
public AstType getType()
{
checkType();
return new AstType(AstType.TYPE_BOOL);
}
}
public class AstSchemaReferenceP extends AstPredicate
{
AstSchemaReference m_schemaReference;
public AstSchemaReferenceP(SpecObject specObject, String property)
{
super(specObject, property);
}
}
public class AstPreP extends AstPredicate
{
AstSchemaReference m_schemaReference;
public AstPreP(SpecObject specObject, String property)
{
super(specObject, property);
}
}
public class AstInitP extends AstPredicate
{
AstExpression m_expression;
public AstInitP(SpecObject specObject, String property)
{
super(specObject, property);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_expression.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_expression.populateSymbolTable();
}
public AstType getType()
{
m_expression.getType();
return new AstType(AstType.TYPE_BOOL);
}
}
public class AstTrueFalseP extends AstPredicate
{
public AstTrueFalseP(SpecObject specObject, String property)
{
super(specObject, property);
}
public AstType getType()
{
return new AstType(AstType.TYPE_BOOL);
}
public void print(int l)
{
print(l, m_token.m_value);
}
}
public class AstNotP extends AstPredicate
{
AstPredicate m_predicate;
public AstNotP(SpecObject specObject, String property)
{
super(specObject, property);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_predicate.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_predicate.populateSymbolTable();
}
public AstType getType()
{
m_predicate.getType();
return new AstType(AstType.TYPE_BOOL);
}
}
public class AstParenP extends AstPredicate
{
AstPredicate m_predicate;
public AstParenP(SpecObject specObject, String property)
{
super(specObject, property);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_predicate.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_predicate.populateSymbolTable();
}
public AstType getType()
{
m_predicate.getType();
return new AstType(AstType.TYPE_BOOL);
}
}
/*
* Schema Expressions
*/
public class AstSchemaExpression extends AstBase
{
}
public class AstForAllS extends AstSchemaExpression
{
AstSchemaText m_schemaText;
AstSchemaExpression m_schemaExpression;
public void print(int l)
{
print(l, "ForAll SchemaExpression");
m_schemaText.print(l + 1);
m_schemaExpression.print(l + 1);
}
}
public class AstThereExistsS extends AstSchemaExpression
{
AstSchemaText m_schemaText;
AstSchemaExpression m_schemaExpression;
public void print(int l)
{
print(l, "ThereExists SchemaExpression");
m_schemaText.print(l + 1);
m_schemaExpression.print(l + 1);
}
}
public class AstThereExists1S extends AstSchemaExpression
{
AstSchemaText m_schemaText;
AstSchemaExpression m_schemaExpression;
public void print(int l)
{
print(l, "ThereExists1 SchemaExpression");
m_schemaText.print(l + 1);
m_schemaExpression.print(l + 1);
}
}
public class AstSchemaTextS extends AstSchemaExpression
{
AstSchemaText m_schemaText;
public void print(int l)
{
print(l, "SchemaText SchemaExpression");
m_schemaText.print(l + 1);
}
}
public class AstSchemaReferenceS extends AstSchemaExpression
{
AstSchemaReference m_schemaReference;
public void print(int l)
{
print(l, "SchemaReference SchemaExpression");
m_schemaReference.print(l + 1);
}
}
public class AstNotS extends AstSchemaExpression
{
AstSchemaExpression m_schemaExpression;
public void print(int l)
{
print(l, "Not SchemaExpression");
m_schemaExpression.print(l + 1);
}
}
public class AstPreS extends AstSchemaExpression
{
AstSchemaExpression m_schemaExpression;
public void print(int l)
{
print(l, "pre SchemaExpression");
m_schemaExpression.print(l + 1);
}
}
public class AstAndS extends AstSchemaExpression
{
AstSchemaExpression m_schemaExpressionL;
AstSchemaExpression m_schemaExpressionR;
public void print(int l)
{
print(l, "AND SchemaExpression");
m_schemaExpressionL.print(l + 1);
m_schemaExpressionR.print(l + 1);
}
}
public class AstOrS extends AstSchemaExpression
{
AstSchemaExpression m_schemaExpressionL;
AstSchemaExpression m_schemaExpressionR;
public void print(int l)
{
print(l, "OR SchemaExpression");
m_schemaExpressionL.print(l + 1);
m_schemaExpressionR.print(l + 1);
}
}
public class AstImpliesS extends AstSchemaExpression
{
AstSchemaExpression m_schemaExpressionL;
AstSchemaExpression m_schemaExpressionR;
public void print(int l)
{
print(l, "IMPLIES SchemaExpression");
m_schemaExpressionL.print(l + 1);
m_schemaExpressionR.print(l + 1);
}
}
public class AstBiimpliesS extends AstSchemaExpression
{
AstSchemaExpression m_schemaExpressionL;
AstSchemaExpression m_schemaExpressionR;
public void print(int l)
{
print(l, "BIIMPLIES SchemaExpression");
m_schemaExpressionL.print(l + 1);
m_schemaExpressionR.print(l + 1);
}
}
public class AstProjS extends AstSchemaExpression
{
AstSchemaExpression m_schemaExpressionL;
AstSchemaExpression m_schemaExpressionR;
public void print(int l)
{
print(l, "PROJ SchemaExpression");
m_schemaExpressionL.print(l + 1);
m_schemaExpressionR.print(l + 1);
}
}
public class AstBslashS extends AstSchemaExpression
{
AstSchemaExpression m_schemaExpression;
AstDeclarationNameList m_declarationNameList;
public void print(int l)
{
print(l, "BSLASH SchemaExpression");
m_schemaExpression.print(l + 1);
m_declarationNameList.print(l + 1);
}
}
public class AstCompS extends AstSchemaExpression
{
AstSchemaExpression m_schemaExpressionL;
AstSchemaExpression m_schemaExpressionR;
public void print(int l)
{
print(l, "COMP SchemaExpression");
m_schemaExpressionL.print(l + 1);
m_schemaExpressionR.print(l + 1);
}
}
public class AstMgtS extends AstSchemaExpression
{
AstSchemaExpression m_schemaExpressionL;
AstSchemaExpression m_schemaExpressionR;
public void print(int l)
{
print(l, ">> SchemaExpression");
m_schemaExpressionL.print(l + 1);
m_schemaExpressionR.print(l + 1);
}
}
public class AstParenS extends AstSchemaExpression
{
AstSchemaExpression m_schemaExpression;
public void print(int l)
{
print(l, "() SchemaExpression");
m_schemaExpression.print(l + 1);
}
}
/*
* Expression
*/
public class AstExpression extends AstBase
{
SpecObject specObject;
String property;
public AstExpression(SpecObject specObject, String property)
{
this.specObject = specObject;
this.property = property;
}
public void checkType()
{
getType();
}
}
public class AstBinaryOpX extends AstExpression
{
AstExpression m_expressionL;
AstExpression m_expressionR;
public AstBinaryOpX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
m_expressionL.print(l);
m_expressionR.print(l);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_expressionL.populateTypeTable(m_stable);
m_expressionR.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_expressionL.populateSymbolTable();
m_expressionR.populateSymbolTable();
}
public AstType getType()
{
AstType typeL = m_expressionL.getType();
AstType typeR = m_expressionR.getType();
if ((typeL.isUndefined())
|| (typeR.isUndefined()))
{
return new AstType();
}
if (!typeL.isCompatible(typeR))
{
reportTypeError("Type mismatch",
m_token,
specObject,
property
);
}
return typeL.resultantType(typeR);
}
}
public class AstIfThenElseX extends AstExpression
{
AstPredicate m_predicate;
AstExpression m_then;
AstExpression m_else;
public AstIfThenElseX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
print(l, "IfThenElse");
m_predicate.print(l + 1);
m_then.print(l + 1);
m_else.print(l + 1);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_predicate.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_predicate.populateSymbolTable();
m_then.populateSymbolTable();
m_else.populateSymbolTable();
}
public AstType getType()
{
AstType t1 = m_then.getType();
AstType t2 = m_else.getType();
if ((t1.isUndefined())
|| (t2.isUndefined()))
{
return new AstType();
}
if (!t1.isCompatible(t2))
{
reportTypeError(
"The expression used for the then clause is a different type than the one used for the else clause",
m_then.m_token,
specObject,
property
);
}
return t1.resultantType(t2);
}
}
public class AstCrossProductX extends AstBinaryOpX
{
public AstCrossProductX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
print(l, "CrossProduct");
super.print(l + 1);
}
public AstType getType()
{
AstType typeL = m_expressionL.getType();
AstType typeR = m_expressionR.getType();
if ((typeL.isUndefined())
|| (typeR.isUndefined()))
{
return new AstType();
}
typeL = typeL.getSetType();
typeR = typeR.getSetType();
if ((typeL == null) || (typeR == null))
{
reportTypeError("Both expressions of a cross-product must evaluate to a set",
m_token,
specObject,
property
);
return new AstType();
}
AstType result = new AstType(AstType.TYPE_SET);
result.m_setType = new AstType(AstType.TYPE_TUPLE);
result.m_setType.newTuple(typeL, typeR);
return result;
}
}
public class AstInfixGenericNameX extends AstBinaryOpX
{
AstInfixGenericName m_infixGenericName = new AstInfixGenericName();
public AstInfixGenericNameX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
m_infixGenericName.print(l);
super.print(l + 1);
}
public String getName()
{
return m_infixGenericName.getName();
}
public AstType getType()
{
AstType typeL = m_expressionL.getType();
AstType typeR = m_expressionR.getType();
if ((typeL.isUndefined())
|| (typeR.isUndefined()))
{
return new AstType();
}
if ((!typeL.isSet() || !typeR.isSet()))
{
reportTypeError("Both sides of an infix generic operator must be sets",
m_infixGenericName.m_token,
specObject,
property
);
return new AstType();
}
AstType type = new AstType(AstType.TYPE_SET);
type.m_setType = new AstType(AstType.TYPE_SET);
type.m_setType.m_setType = new AstType(AstType.TYPE_TUPLE);
type.m_setType.m_setType.newTuple(typeL.getSetType(), typeR.getSetType());
return type;
}
}
public class AstInfixFunctionNameX extends AstBinaryOpX
{
AstInfixFunctionName m_infixFunctionName = new AstInfixFunctionName();
public AstInfixFunctionNameX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
m_infixFunctionName.print(l);
super.print(l + 1);
}
public AstType getType()
{
boolean bad = false;
int tid = m_infixFunctionName.m_token.m_id;
String tname = m_infixFunctionName.m_token.m_value;
AstType typeL = m_expressionL.getType();
AstType typeR = m_expressionR.getType();
if ((typeL.isUndefined())
|| (typeR.isUndefined()))
{
return new AstType();
}
if (tid == TozeTokenizer.TOKEN_MAP)
{
AstType type = new AstType(AstType.TYPE_TUPLE);
type.m_tupleTypes.add(typeL);
type.m_tupleTypes.add(typeR);
return type;
}
if ((tid == TozeTokenizer.TOKEN_PLUS)
|| (tid == TozeTokenizer.TOKEN_MINUS)
|| (tid == TozeTokenizer.TOKEN_DIV)
|| (tid == TozeTokenizer.TOKEN_MOD)
|| (tid == TozeTokenizer.TOKEN_FSLASH)
|| (tid == TozeTokenizer.TOKEN_TIMES))
{
AstType rtype = typeL.resultantType(typeR);
if (!rtype.isANumber())
{
reportTypeError("The expressions for the " + tname + " operator must be numbers",
m_infixFunctionName.m_token,
specObject,
property
);
return new AstType();
}
return rtype;
}
if ((tid == TozeTokenizer.TOKEN_UNI)
|| (tid == TozeTokenizer.TOKEN_SETMINUS)
|| (tid == TozeTokenizer.TOKEN_INT)
|| (tid == TozeTokenizer.TOKEN_BSLASH))
{
if (!typeL.isSet() || !typeR.isSet())
{
reportTypeError("Expressions for the " + tname + " operator must be sets",
m_infixFunctionName.m_token,
specObject,
property
);
return new AstType();
}
if (!typeL.isEqual(typeR))
{
reportTypeError("Sets must be the same type for the operator " + tname,
m_infixFunctionName.m_token,
specObject,
property
);
return new AstType();
}
return typeL;
}
if ((tid == TozeTokenizer.TOKEN_CAT)
|| (tid == TozeTokenizer.TOKEN_DCAT)
|| (tid == TozeTokenizer.TOKEN_PREFIX)
|| (tid == TozeTokenizer.TOKEN_SUFFIX))
{
if (!typeL.isSequence() || !typeR.isSequence())
{
reportTypeError("Expressions for the " + tname + " operator must be sequences",
m_infixFunctionName.m_token,
specObject,
property
);
return new AstType();
}
return typeL;
}
if (tid == TozeTokenizer.TOKEN_UPTO)
{
if (!typeL.isANumber()
|| !typeR.isANumber())
{
reportTypeError("Expressions for " + tname + " must be numbers",
m_infixFunctionName.m_token,
specObject,
property
);
return new AstType();
}
AstType type = new AstType(AstType.TYPE_SET);
type.m_setType = typeL;
return type;
}
if ((tid == TozeTokenizer.TOKEN_FOVR)
|| (tid == TozeTokenizer.TOKEN_FCMP)
|| (tid == TozeTokenizer.TOKEN_CIRC))
{
if (!typeL.isRelation()
|| !typeR.isRelation())
{
reportTypeError("Expressions for " + tname + " must be relations",
m_infixFunctionName.m_token,
specObject,
property
);
return new AstType();
}
if (!typeL.isEqual(typeR))
{
reportTypeError("Relations used in " + tname + " must be of the same type",
m_infixFunctionName.m_token,
specObject,
property
);
return new AstType();
}
return typeL;
}
if ((tid == TozeTokenizer.TOKEN_DRES)
|| (tid == TozeTokenizer.TOKEN_DSUB))
{
if (!typeL.isSet())
{
reportTypeError("Left-hand argument to " + tname + " must be a set",
m_infixFunctionName.m_token,
specObject,
property
);
bad = true;
}
if (!typeR.isRelation())
{
reportTypeError("Right-hand argument to " + tname + " must be a relation",
m_infixFunctionName.m_token,
specObject,
property
);
bad = true;
}
if (bad)
{
return new AstType();
}
if (!((AstType) typeR.getSetType().m_tupleTypes.get(0)).isEqual(typeL.getSetType()))
{
reportTypeError("Type of set must be the same as the domain type of the range",
m_infixFunctionName.m_token,
specObject,
property
);
return new AstType();
}
return typeR;
}
if ((tid == TozeTokenizer.TOKEN_RRES)
|| (tid == TozeTokenizer.TOKEN_RSUB))
{
if (!typeR.isSet())
{
reportTypeError("Right-hand argument to " + tname + " must be a set",
m_infixFunctionName.m_token,
specObject,
property
);
bad = true;
}
if (!typeL.isRelation())
{
reportTypeError("Left-hand argument to " + tname + " must be a relation",
m_infixFunctionName.m_token,
specObject,
property
);
bad = true;
}
if (bad)
{
return new AstType();
}
if (!((AstType) typeL.getSetType().m_tupleTypes.get(1)).isEqual(typeR.getSetType()))
{
reportTypeError("Type of set must be the same as the range type of the relation",
m_infixFunctionName.m_token,
specObject,
property
);
return new AstType();
}
return typeL;
}
if ((tid == TozeTokenizer.TOKEN_PROJECT))
{
if (!typeL.isSequence())
{
reportTypeError("Left-hand expression for a projection must be a sequence",
m_infixFunctionName.m_token,
specObject,
property
);
bad = true;
}
if (!typeR.isSet())
{
reportTypeError("Right-hand expression for a projection must be a set",
m_infixFunctionName.m_token,
specObject,
property
);
bad = true;
}
if (bad)
{
return new AstType();
}
AstType tl = (AstType) typeL.getSetType().m_tupleTypes.get(1);
AstType tr = typeR.getSetType();
if (!tl.isCompatible(tr))
{
reportTypeError("Type of set must be the same as the sequence type.",
m_infixFunctionName.m_token,
specObject,
property
);
}
return typeL;
}
if ((tid == TozeTokenizer.TOKEN_EXTRACT))
{
if (!typeL.isSet())
{
reportTypeError("Left-hand expression must be a set",
m_infixFunctionName.m_token,
specObject,
property
);
bad = true;
}
else
{
}
if (!typeR.isSequence())
{
reportTypeError("Right-hand expression for a projection must be a sequence",
m_infixFunctionName.m_token,
specObject,
property
);
bad = true;
}
if (bad)
{
return new AstType();
}
AstType tl = typeL.getSetType();
/*
* Check that the set contains natural numbers.
*/
if (!tl.isANumber())
{
reportTypeError("The set must contain numbers",
m_infixFunctionName.m_token,
specObject,
property
);
}
return typeR;
}
if (tid == TozeTokenizer.TOKEN_HASH)
{
if (!typeL.isBag())
{
reportTypeError("Left-hand expression for '#' must be a bag",
m_infixFunctionName.m_token,
specObject,
property
);
return new AstType();
}
if (!((AstType) typeL.getSetType().m_tupleTypes.get(0)).isEqual(typeR))
{
reportTypeError("Right-hand expression for '#' must be the same type as contained in the bag",
m_infixFunctionName.m_token,
specObject,
property
);
return new AstType();
}
return new AstType(AstType.TYPE_NATURAL);
}
if (tid == TozeTokenizer.TOKEN_UPLUS)
{
if (!typeL.isBag()
|| !typeR.isBag())
{
reportTypeError("Expressions for bag union must be bags",
m_infixFunctionName.m_token,
specObject,
property
);
return new AstType();
}
if (!typeL.isEqual(typeR))
{
reportTypeError("Both sides of bag union must be the same type",
m_infixFunctionName.m_token,
specObject,
property
);
}
}
return new AstType();
}
}
public class AstPowerX extends AstExpression
{
AstExpression m_expression;
public AstPowerX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_expression.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_expression.populateSymbolTable();
}
public AstType getType()
{
AstType ttype = m_expression.getType();
if (ttype.isUndefined())
{
return new AstType();
}
if (ttype.getSetType() == null)
{
reportTypeError("Power set must be applied to a set",
m_token,
specObject,
property
);
return new AstType();
}
AstType type = new AstType(AstType.TYPE_SET);
type.m_setType = ttype;
return type;
}
}
public class AstUnaryOpX extends AstExpression
{
AstExpression m_expression;
public AstUnaryOpX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
print(l, m_token.m_value);
m_expression.print(l + 1);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_expression.populateTypeTable(stable);
}
public void populateSymbolTable()
{
m_expression.populateSymbolTable();
}
public AstType getType()
{
return m_expression.getType();
}
}
public class AstPrefixGenericNameX extends AstUnaryOpX
{
AstPrefixGenericName m_prefixGenericName = new AstPrefixGenericName();
public AstPrefixGenericNameX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
m_prefixGenericName.print(l);
}
public AstType getType()
{
switch (m_prefixGenericName.m_token.m_id)
{
case TozeTokenizer.TOKEN_SEQ:
case TozeTokenizer.TOKEN_SEQONE:
case TozeTokenizer.TOKEN_ISEQ:
AstType t = m_expression.getType();
if (t.isUndefined())
{
return new AstType();
}
// AstType type = new AstType(AstType.TYPE_SET);
// type.m_setType = new AstType(AstType.TYPE_SEQUENCE);
if (t.isSet())
{
t = t.getSetType();
}
AstType rtype = new AstType(AstType.TYPE_SET);
rtype.m_setType = new AstType(AstType.TYPE_SEQUENCE);
rtype.m_setType.m_setType = new AstType(AstType.TYPE_TUPLE);
rtype.m_setType.m_setType.newTuple(new AstType(AstType.TYPE_NATURAL1),
t
);
rtype.m_setType.m_setType.m_tupleIsSeq = true;
return rtype;
case TozeTokenizer.TOKEN_BAG:
t = m_expression.getType();
if (t.isUndefined())
{
return new AstType();
}
// type = new AstType(AstType.TYPE_SET);
// type.m_setType = new AstType(AstType.TYPE_BAG);
if (t.isSet())
{
t = t.getSetType();
}
rtype = new AstType(AstType.TYPE_SET);
rtype.m_setType = new AstType(AstType.TYPE_BAG);
rtype.m_setType.m_setType = new AstType(AstType.TYPE_TUPLE);
rtype.m_setType.m_setType.newTuple(t,
new AstType(AstType.TYPE_NATURAL1)
);
rtype.m_setType.m_setType.m_tupleIsSeq = true;
return rtype;
}
return new AstType();
}
}
public class AstHyphenX extends AstUnaryOpX
{
AstDecorations m_decoration;
public AstHyphenX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_expression.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_expression.populateSymbolTable();
}
public AstType getType()
{
AstType t = m_expression.getType();
if (!t.isANumber())
{
reportTypeError("The expression for - must be a number",
m_token,
specObject,
property
);
return new AstType();
}
return t;
}
}
public class AstImageX extends AstExpression // (| |)
{
AstExpression m_expression1;
AstExpression m_expression0;
AstDecorations m_decoration;
public AstImageX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_expression1.populateTypeTable(m_stable);
m_expression0.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_expression1.populateSymbolTable();
m_expression0.populateSymbolTable();
}
public AstType getType()
{
boolean bad = false;
AstType typeL = m_expression1.getType();
AstType typeM = m_expression0.getType();
if ((typeL.isUndefined())
|| (typeM.isUndefined()))
{
return new AstType();
}
if (!typeL.isRelation())
{
reportTypeError("Left-hand expression to the image operator must be a relation",
m_token,
specObject,
property
);
bad = true;
}
if (!typeM.isSet())
{
reportTypeError("Inside expression of the image operator must be a set",
m_token,
specObject,
property
);
bad = true;
}
if (bad)
{
return new AstType();
}
if (!typeM.getSetType().isEqual((AstType) typeL.getSetType().m_tupleTypes.get(0)))
{
reportTypeError(
"The type of the inside set expression must the the same type as the domain type of the relation for the image operator",
m_token,
specObject,
property
);
return new AstType();
}
AstType type = new AstType(AstType.TYPE_SET);
type.m_setType = (AstType) typeL.getSetType().m_tupleTypes.get(1);
return type;
}
}
public class AstExpressionListX extends AstExpression
{
List m_expressions = new ArrayList();
public AstExpressionListX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
int i;
for (i = 0; i < m_expressions.size(); i++)
{
((AstBase) m_expressions.get(i)).populateTypeTable(m_stable);
}
}
public void populateSymbolTable()
{
int i;
for (i = 0; i < m_expressions.size(); i++)
{
((AstBase) m_expressions.get(i)).populateSymbolTable();
}
}
public AstType getType()
{
AstType type = new AstType(AstType.TYPE_TUPLE);
int i;
for (i = 0; i < m_expressions.size(); i++)
{
AstType t = ((AstBase) m_expressions.get(i)).getType();
type.m_tupleTypes.add(t);
}
/*
* Special case where a tuple is surrounded by parenthesis
*/
if (m_expressions.size() == 1)
{
AstType t = (AstType) type.m_tupleTypes.get(0);
if (t.getType() == AstType.TYPE_TUPLE)
{
return t;
}
}
return type;
}
}
public class AstDistUnionX extends AstExpression
{
AstExpression m_expression = null;
public AstDistUnionX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_expression.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_expression.populateSymbolTable();
}
public AstType getType()
{
AstType type = m_expression.getType();
if (type.isUndefined())
{
return new AstType();
}
if (type.getType() != AstType.TYPE_SET)
{
reportTypeError("Expression used in distributed union must be a set of sets.",
m_token,
specObject,
property
);
return new AstType();
}
/*
* If the set is a tuple, then we need to make sure that each tuple
* is of the same type.
*/
if (type.getSetType().getType() == AstType.TYPE_TUPLE)
{
int i;
AstType stype = type.getSetType();
if (stype.m_tupleTypes.size() == 0)
{
return new AstType(AstType.TYPE_EMPTY);
}
AstType type1 = (AstType) stype.m_tupleTypes.get(0);
for (i = 1; i < stype.m_tupleTypes.size(); i++)
{
AstType type2 = (AstType) stype.m_tupleTypes.get(i);
if (!type1.isCompatible(type2))
{
reportTypeError("All sets used in a distributed union must be of the same type.",
m_token,
specObject,
property
);
return new AstType();
}
}
return type1;
}
else
{
if (type.getSetType().getType() != AstType.TYPE_SET)
{
reportTypeError("Expression used in distributed union must be a set of sets.",
m_token,
specObject,
property
);
return new AstType();
}
return type.getSetType();
}
}
}
public class AstDistIntersectionX extends AstExpression
{
AstExpression m_expression = null;
public AstDistIntersectionX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_expression.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_expression.populateSymbolTable();
}
public AstType getType()
{
AstType type = m_expression.getType();
if (type.isUndefined())
{
return new AstType();
}
if (type.getType() != AstType.TYPE_SET)
{
reportTypeError("Expression used in distributed intersection must be a set of sets.",
m_token,
specObject,
property
);
return new AstType();
}
/*
* If the set is a tuple, then we need to make sure that each tuple
* is of the same type.
*/
if (type.getSetType().getType() == AstType.TYPE_TUPLE)
{
int i;
AstType stype = type.getSetType();
if (stype.m_tupleTypes.size() == 0)
{
return new AstType(AstType.TYPE_EMPTY);
}
AstType type1 = (AstType) stype.m_tupleTypes.get(0);
for (i = 1; i < stype.m_tupleTypes.size(); i++)
{
AstType type2 = (AstType) stype.m_tupleTypes.get(i);
if (!type1.isCompatible(type2))
{
reportTypeError("All sets used in a distributed intersection must be of the same type.",
m_token,
specObject,
property
);
return new AstType();
}
}
return type1;
}
else
{
if (type.getSetType().getType() != AstType.TYPE_SET)
{
reportTypeError("Expression used in distributed intersection must be a set of sets.",
m_token,
specObject,
property
);
return new AstType();
}
return type.getSetType();
}
}
}
public class AstVariableX extends AstExpression
{
AstVariableName m_variable;
AstActualParameters m_actualParameters;
public AstVariableX(SpecObject specObject, String property)
{
super(specObject, property);
}
}
public class AstSelfX extends AstExpression
{
public AstSelfX(SpecObject specObject, String property)
{
super(specObject, property);
}
}
public class AstNumberX extends AstExpression
{
public AstNumberX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
print(l, m_token.m_value);
}
public AstType getType()
{
AstType type = new AstType();
if (m_token.m_value.indexOf('.') >= 0)
{
type.m_type = AstType.TYPE_REAL;
}
else
{
type.m_type = AstType.TYPE_NATURAL;
}
return type;
}
}
public class AstSchemaReferenceX extends AstExpression
{
AstSchemaReference m_schemaReference;
public AstSchemaReferenceX(SpecObject specObject, String property)
{
super(specObject, property);
}
}
public class AstClassNameX extends AstExpression
{
AstClassName m_className;
AstActualParameters m_actualParameters;
AstRenameList m_renameList;
public AstClassNameX(SpecObject specObject, String property)
{
super(specObject, property);
}
}
public class AstDownArrowX extends AstExpression
{
AstExpression m_expression;
public AstDownArrowX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_expression.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_expression.populateSymbolTable();
}
public AstType getType()
{
if (m_expression == null)
{
return new AstType();
}
return m_expression.getType();
}
}
public class AstUnionX extends AstBinaryOpX
{
public void print(int l)
{
print(l, "Union");
super.print(l + 1);
}
public AstUnionX(SpecObject specObject, String property)
{
super(specObject, property);
}
public AstType getType()
{
AstType typeL = m_expressionL.getType();
AstType typeR = m_expressionR.getType();
if ((typeL.isUndefined())
|| (typeR.isUndefined()))
{
return new AstType();
}
if (!typeL.isSet() || !typeR.isSet())
{
reportTypeError(
"Expressions for the " + Character.toString(TozeFontMap.CHAR_CUP) + " operator must be sets",
m_token,
specObject,
property
);
return new AstType();
}
if (!typeL.isEqual(typeR))
{
reportTypeError(
"Sets must be the same type for the operator " + Character.toString(TozeFontMap.CHAR_CUP),
m_token,
specObject,
property
);
return new AstType();
}
return typeL;
}
}
public class AstCopyrightX extends AstUnaryOpX
{
public AstCopyrightX(SpecObject specObject, String property)
{
super(specObject, property);
}
}
public class AstAngleX extends AstExpression
{
List m_expressions = new ArrayList();
public AstAngleX(SpecObject specObject, String property)
{
super(specObject, property);
}
}
public class AstBagX extends AstExpression
{
List m_expressions = new ArrayList();
public AstBagX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
int i;
print(l, "BagExpression");
for (i = 0; i < m_expressions.size(); i++)
{
((AstExpression) m_expressions.get(i)).print(l + 1);
}
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
int i;
for (i = 0; i < m_expressions.size(); i++)
{
((AstBase) m_expressions.get(i)).populateTypeTable(m_stable);
}
}
public void populateSymbolTable()
{
int i;
for (i = 0; i < m_expressions.size(); i++)
{
((AstBase) m_expressions.get(i)).populateSymbolTable();
}
}
public AstType getType()
{
int i;
boolean wasUndefined = false;
AstType type = new AstType(AstType.TYPE_BAG);
if (m_expressions.size() == 0)
{
return new AstType(AstType.TYPE_EMPTY);
}
AstType stype = ((AstBase) m_expressions.get(0)).getType();
if (stype.isUndefined())
{
return new AstType();
}
for (i = 1; i < m_expressions.size(); i++)
{
AstType ttype = ((AstBase) m_expressions.get(i)).getType();
if (ttype.isUndefined())
{
wasUndefined = true;
}
else
{
if (!ttype.isEqual(stype))
{
reportTypeError("All expressions of a bag must be of the same type",
m_token,
specObject,
property
);
}
}
}
if (wasUndefined)
{
return new AstType();
}
AstType rtype = new AstType(AstType.TYPE_BAG);
rtype.m_setType = new AstType(AstType.TYPE_TUPLE);
rtype.m_setType.newTuple(stype,
new AstType(AstType.TYPE_NATURAL1)
);
rtype.m_setType.m_tupleIsSeq = false;
return rtype;
}
}
public class AstThetaX extends AstExpression
{
AstSchemaName m_schemaName;
AstDecorations m_decorations;
AstRenameList m_renameList;
public AstThetaX(SpecObject specObject, String property)
{
super(specObject, property);
}
}
public class AstMemberX extends AstExpression
{
AstExpression m_expression;
AstVariableName m_variableName;
public AstMemberX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
print(l, "AstMember");
m_expression.print(l + 1);
m_variableName.print(l + 1);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_expression.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_expression.populateSymbolTable();
}
public AstType getType()
{
AstType ctype = m_expression.getType();
if (ctype.isUndefined())
{
return new AstType();
}
if (ctype == null)
{
reportTypeError("Undefined class variable",
m_expression.m_token,
specObject,
property
);
return new AstType();
}
if (ctype.getType() != AstType.TYPE_CLASS)
{
reportTypeError("Member access must be from a class type",
m_expression.m_token,
specObject,
property
);
return new AstType();
}
AstType type = null;
if (m_variableName != null)
{
type = ctype.getClassMembers().getTypeVisible(m_variableName.getName());
}
if (type == null)
{
// the variable name may be null after a class.member syntax
// where member is blank, handle as a null and use a unique
// TozeToken
String member = "<null>";
TozeToken token = null;
if (m_variableName != null)
{
member = m_variableName.getName();
token = m_variableName.m_token;
}
if (token == null)
{
token = new TozeToken(-1, member, -1, -1);
}
reportTypeError("The member " + member + " is not visible",
token,
specObject,
property
);
return new AstType();
}
if (type.isUndefined())
{
reportTypeError("The member " + m_variableName.getName() + " is undefined",
m_variableName.m_token,
specObject,
property
);
return new AstType();
}
return type;
}
}
public class AstPostfixFunctionNameX extends AstUnaryOpX
{
AstPostfixFunctionName m_postfixFunctionName;
public AstPostfixFunctionNameX(SpecObject specObject, String property)
{
super(specObject, property);
}
public AstType getType()
{
AstType type = m_expression.getType();
if (type.isUndefined())
{
return new AstType();
}
if ((m_postfixFunctionName.m_token.m_id == TozeTokenizer.TOKEN_TILDE)
|| (m_postfixFunctionName.m_token.m_id == TozeTokenizer.TOKEN_INV))
{
if (!type.isRelation())
{
reportTypeError("The argument to '~' must be a relation",
m_postfixFunctionName.m_token,
specObject,
property
);
return new AstType();
}
AstType rtype = new AstType(AstType.TYPE_SET);
rtype.m_setType = new AstType(AstType.TYPE_TUPLE);
rtype.m_setType.newTuple((AstType) type.m_setType.m_tupleTypes.get(1),
(AstType) type.m_setType.m_tupleTypes.get(0)
);
return rtype;
}
if ((m_postfixFunctionName.m_token.m_id == TozeTokenizer.TOKEN_TCL)
|| (m_postfixFunctionName.m_token.m_id == TozeTokenizer.TOKEN_RTCL))
{
if (!type.isRelation())
{
reportTypeError(
"The argument to '" + m_postfixFunctionName.m_token.m_value + "' must be a relation",
m_postfixFunctionName.m_token,
specObject,
property
);
return new AstType();
}
}
return type;
}
}
public class AstParenX extends AstExpression
{
public AstParenX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
print(l, "Parenthesis");
super.print(l + 1);
}
}
public class AstLambdaX extends AstExpression
{
AstSchemaText m_schemaText;
AstExpression m_expression;
public AstLambdaX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
print(l, "Lambda");
m_schemaText.print(l + 1);
m_expression.print(l + 1);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_schemaText.populateTypeTable(m_stable);
m_expression.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_schemaText.populateSymbolTable();
m_expression.populateSymbolTable();
}
public AstType getType()
{
m_schemaText.checkType();
List decls = m_schemaText.m_declaration.m_decls;
AstType ttype = new AstType(AstType.TYPE_TUPLE);
int i;
for (i = 0; i < decls.size(); i++)
{
if (decls.get(i) instanceof AstBasicDeclaration1)
{
AstBasicDeclaration1 dec = (AstBasicDeclaration1) decls.get(i);
List names = dec.m_declarationNameList.m_declarationNameList;
int j;
for (j = 0; j < names.size(); j++)
{
AstDeclarationName name = (AstDeclarationName) names.get(j);
AstType nt = m_stable.getType(name.getName());
ttype.m_tupleTypes.add(nt);
}
}
}
AstType et = m_expression.getType();
if (et.isUndefined())
{
return new AstType();
}
ttype.m_tupleTypes.add(et);
AstType type = new AstType(AstType.TYPE_SET);
type.m_setType = ttype;
return type;
}
}
public class AstMuX extends AstExpression
{
AstSchemaText m_schemaText;
AstExpression m_expression;
public AstMuX(SpecObject specObject, String property)
{
super(specObject, property);
}
}
public class AstLetX extends AstExpression
{
List m_letDefinitions = new ArrayList();
AstExpression m_expression;
public AstLetX(SpecObject specObject, String property)
{
super(specObject, property);
}
}
/*
* This class is a merging of a variable (V), Schema Reference (S), and
* class (C).
* This is done because sometimes it is not possible to know at the time of
* parsing whether something is either of the three.
*
* Word -> VSC
* Word, Decoration -> VS
* Word, ActualParameters -> VSC
* Word, RenameList -> SC
* Word, ActualParameters, RenameList -> SC
* Word, Decoration, ActualParameters -> VS
* Word, Decoration, RenameList -> S
* Word, Decoration, ActualParameters, RenameList -> S
*/
public class AstVSCX extends AstExpression
{
// The Word will be stored in the token in the base class.
AstDecorations m_decorations;
AstActualParameters m_actualParameters;
AstRenameList m_renameList;
public AstVSCX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
print(l, "VSC");
print(l + 1, m_token.m_value);
if (m_decorations != null)
{
m_decorations.print(l + 1);
}
if (m_actualParameters != null)
{
m_actualParameters.print(l + 1);
}
if (m_renameList != null)
{
m_renameList.print(l + 1);
}
}
public AstType getType()
{
AstType type = m_stable.getTypeDef(getName());
if (type == null)
{
type = m_stable.getType(getName());
if (type == null)
{
reportTypeError(getName() + " is undefined",
m_token,
specObject,
property
);
return new AstType();
}
if (type.isUndefined())
{
reportTypeError(getName() + " is undefined",
m_token,
specObject,
property
);
return new AstType();
}
}
return type;
}
public String getName()
{
if (m_decorations == null)
{
return m_token.m_value;
}
return m_token.m_value + m_decorations.getName();
}
}
public class AstSetExpressionX extends AstExpression
{
public AstSetExpressionX(SpecObject specObject, String property)
{
super(specObject, property);
}
}
public class AstSetExpressionX1 extends AstSetExpressionX
{
List m_expressions = new ArrayList();
public AstSetExpressionX1(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
int i;
print(l, "SetExpression");
for (i = 0; i < m_expressions.size(); i++)
{
((AstExpression) m_expressions.get(i)).print(l + 1);
}
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
int i;
for (i = 0; i < m_expressions.size(); i++)
{
((AstBase) m_expressions.get(i)).populateTypeTable(m_stable);
}
}
public void populateSymbolTable()
{
int i;
for (i = 0; i < m_expressions.size(); i++)
{
((AstBase) m_expressions.get(i)).populateSymbolTable();
}
}
public AstType getType()
{
AstType type;
int i;
boolean wasUndefined = false;
//ttp
/*
* if (m_expressions.size() > 1)
* {
* AstType ttype = new AstType();
* ttype.m_type = AstType.TYPE_TUPLE;
* for (i=0; i<m_expressions.size(); i++)
* {
* type = ((AstBase)m_expressions.get(i)).getType();
* ttype.m_tupleTypes.add(type);
* if (type.isUndefined()) wasUndefined = true;
* }
* if (wasUndefined) return new AstType();
* type = new AstType(AstType.TYPE_SET);
* type.m_setType = ttype;
* }
* else if (m_expressions.size() == 1)
*/
if (m_expressions.size() != 0)
{
type = new AstType(AstType.TYPE_SET);
type.m_setType = ((AstBase) m_expressions.get(0)).getType();
if (type.m_setType.isUndefined())
{
return new AstType();
}
}
else
{
type = new AstType(AstType.TYPE_SET);
type.m_setType = new AstType(AstType.TYPE_EMPTY);
if (type.m_setType.isUndefined())
{
return new AstType();
}
}
return type;
}
}
public class AstSetExpressionX2 extends AstSetExpressionX
{
AstSchemaText m_schemaText;
AstExpression m_expression;
public AstSetExpressionX2(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
print(l, "SetExpression");
if (m_schemaText != null)
{
m_schemaText.print(l + 1);
}
m_expression.print(l + 1);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = new AstSymbolTable(stable);
stable.addKid(m_stable);
if (m_schemaText != null)
{
m_schemaText.populateTypeTable(m_stable);
}
if (m_expression != null)
{
m_expression.populateTypeTable(m_stable);
}
}
public void populateSymbolTable()
{
if (m_schemaText != null)
{
m_schemaText.populateSymbolTable();
}
if (m_expression != null)
{
m_expression.populateSymbolTable();
}
}
public AstType getType()
{
if (m_schemaText != null)
{
m_schemaText.checkType();
}
if (m_expression == null)
{
return m_schemaText.getType();
}
AstType type = new AstType(AstType.TYPE_SET);
type.m_setType = m_expression.getType();
if (type.m_setType.isUndefined())
{
return new AstType();
}
return type;
}
}
public class AstSetExpressionX3 extends AstSetExpressionX
{
public AstSetExpressionX3(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
print(l, "SetExpression - " + m_token.m_value);
}
public AstType getType()
{
AstType type = new AstType();
if (m_token.m_id == TozeTokenizer.TOKEN_NAT)
{
return m_stable.getTypeDef(m_token.m_value);
}
else if (m_token.m_id == TozeTokenizer.TOKEN_NATONE)
{
return m_stable.getTypeDef(m_token.m_value);
}
else if (m_token.m_id == TozeTokenizer.TOKEN_INTEGER)
{
return m_stable.getTypeDef(m_token.m_value);
}
else if (m_token.m_id == TozeTokenizer.TOKEN_REAL)
{
return m_stable.getTypeDef(m_token.m_value);
}
else if (m_token.m_id == TozeTokenizer.TOKEN_BOOL)
{
return m_stable.getTypeDef(m_token.m_value);
}
return m_stable.getTypeDef(m_token.m_value);
}
}
public class AstSequenceX extends AstExpression
{
List m_expressions = new ArrayList();
public AstSequenceX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
print(l, "Sequence");
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
int i;
for (i = 0; i < m_expressions.size(); i++)
{
((AstBase) m_expressions.get(i)).populateTypeTable(m_stable);
}
}
public void populateSymbolTable()
{
int i;
for (i = 0; i < m_expressions.size(); i++)
{
((AstBase) m_expressions.get(i)).populateSymbolTable();
}
}
public AstType getType()
{
int i;
boolean wasUndefined = false;
AstType type = new AstType(AstType.TYPE_SEQUENCE);
if (m_expressions.size() == 0)
{
type.m_setType = new AstType(AstType.TYPE_EMPTY);
return type;
}
AstType stype = ((AstBase) m_expressions.get(0)).getType();
if (stype.isUndefined())
{
return new AstType();
}
for (i = 1; i < m_expressions.size(); i++)
{
AstType ttype = ((AstBase) m_expressions.get(i)).getType();
if (ttype.isUndefined())
{
wasUndefined = true;
}
else
{
if (!ttype.isEqual(stype))
{
reportTypeError("All expressions of a sequence must be of the same type",
m_token,
specObject,
property
);
}
}
}
if (wasUndefined)
{
return new AstType();
}
AstType rtype = new AstType(AstType.TYPE_SEQUENCE);
rtype.m_setType = new AstType(AstType.TYPE_TUPLE);
rtype.m_setType.newTuple(new AstType(AstType.TYPE_NATURAL1),
stype
);
rtype.m_setType.m_tupleIsSeq = true;
return rtype;
}
}
public class AstBuiltInFunctionX extends AstUnaryOpX
{
public AstBuiltInFunctionX(SpecObject specObject, String property)
{
super(specObject, property);
}
public AstType getType()
{
AstType type = m_expression.getType();
if (type.isUndefined())
{
return new AstType();
}
if (m_token.m_id == TozeTokenizer.TOKEN_DOM)
{
if (type.getType() != AstType.TYPE_SET)
{
reportTypeError("The argument to the function 'dom' must be a set of tuples",
m_token,
specObject,
property
);
return new AstType();
}
if (type.getSetType().getType() != AstType.TYPE_TUPLE)
{
reportTypeError("The argument to the function 'dom' must be a set of tuples",
m_token,
specObject, property
);
return new AstType();
}
if (type.getSetType().m_tupleTypes.size() != 2)
{
reportTypeError("The argument to the function 'dom' must be a tuple of size 2",
m_token,
specObject,
property
);
return new AstType();
}
AstType rtype = new AstType(AstType.TYPE_SET);
rtype.m_setType = (AstType) type.getSetType().m_tupleTypes.get(0);
return rtype;
}
if (m_token.m_id == TozeTokenizer.TOKEN_RAN)
{
if (type.getType() != AstType.TYPE_SET)
{
reportTypeError("The argument to the function 'ran' must be a set of tuples",
m_token,
specObject,
property
);
return new AstType();
}
if (type.getSetType().getType() != AstType.TYPE_TUPLE)
{
reportTypeError("The argument to the function 'ran' must be a set of tuples",
m_token,
specObject,
property
);
return new AstType();
}
if (type.getSetType().m_tupleTypes.size() != 2)
{
reportTypeError("The argument to the function 'ran' must be a tuple of size 2",
m_token,
specObject,
property
);
return new AstType();
}
AstType rtype = new AstType(AstType.TYPE_SET);
rtype.m_setType = (AstType) type.getSetType().m_tupleTypes.get(1);
return rtype;
}
if (m_token.m_id == TozeTokenizer.TOKEN_REV)
{
if (type.getType() != AstType.TYPE_SEQUENCE)
{
reportTypeError("The argument to the function 'rev' must be a sequence",
m_token,
specObject,
property
);
return new AstType();
}
return type;
}
if (m_token.m_id == TozeTokenizer.TOKEN_HEAD)
{
if (type.getType() != AstType.TYPE_SEQUENCE)
{
reportTypeError("The argument to the function 'head' must be a sequence",
m_token,
specObject,
property
);
return new AstType();
}
return (AstType) type.getSetType().m_tupleTypes.get(1);
// return type.m_setType;
}
if (m_token.m_id == TozeTokenizer.TOKEN_LAST)
{
if (type.getType() != AstType.TYPE_SEQUENCE)
{
reportTypeError("The argument to the function 'last' must be a sequence",
m_token,
specObject,
property
);
return new AstType();
}
return (AstType) type.getSetType().m_tupleTypes.get(1);
// return type.m_setType;
}
if (m_token.m_id == TozeTokenizer.TOKEN_TAIL)
{
if (type.getType() != AstType.TYPE_SEQUENCE)
{
reportTypeError("The argument to the function 'tail' must be a sequence",
m_token,
specObject,
property
);
return new AstType();
}
return type;
}
if (m_token.m_id == TozeTokenizer.TOKEN_FRONT)
{
if (type.getType() != AstType.TYPE_SEQUENCE)
{
reportTypeError("The argument to the function 'front' must be a sequence",
m_token,
specObject,
property
);
return new AstType();
}
return type;
}
if ((m_token.m_id == TozeTokenizer.TOKEN_FIRST)
|| (m_token.m_id == TozeTokenizer.TOKEN_SECOND))
{
if ((type.getType() != AstType.TYPE_TUPLE)
|| (type.m_tupleTypes.size() != 2))
{
reportTypeError("The argument to " + m_token.m_value + " must be a tuple of size 2",
m_token,
specObject,
property
);
return new AstType();
}
if (m_token.m_id == TozeTokenizer.TOKEN_FIRST)
{
return (AstType) type.m_tupleTypes.get(0);
}
return (AstType) type.m_tupleTypes.get(1);
}
if (m_token.m_id == TozeTokenizer.TOKEN_HASH)
{
if (!type.isSet() && !type.isSequence())
{
reportTypeError("Argument to '#' must be either a set or a sequence",
m_token,
specObject,
property
);
}
return new AstType(AstType.TYPE_NATURAL);
}
return new AstType();
}
}
public class AstFunctionX extends AstExpression
{
AstExpression m_fexpression;
AstExpression m_pexpression;
public AstFunctionX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_fexpression.populateTypeTable(m_stable);
m_pexpression.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_fexpression.populateSymbolTable();
m_pexpression.populateSymbolTable();
}
public AstType getType()
{
AstType ftype = m_fexpression.getType();
AstType ptype = m_pexpression.getType();
if ((ftype.isUndefined())
|| (ptype.isUndefined()))
{
return new AstType();
}
/*
* Check the special case where it looks like an expression function
* but it is really where a single element of a sequence is being
* referenced.
*/
if (ftype.getType() == AstType.TYPE_SEQUENCE)
{
if (!ptype.isANumber())
{
reportTypeError("Subscript to a sequence must be a number",
m_token,
specObject,
property
);
}
return (AstType) ftype.getSetType().m_tupleTypes.get(1);
}
if ((ftype.getType() != AstType.TYPE_SET)
&& (ftype.getType() != AstType.TYPE_SEQUENCE))
{
reportTypeError("Expression used as a function must evaluate to a set of a tuple",
m_token,
specObject,
property
);
return new AstType();
}
if (ftype.getSetType().getType() != AstType.TYPE_TUPLE)
{
reportTypeError("Expression used as a function must evaluate to a tuple",
m_token,
specObject,
property
);
return new AstType();
}
if (ftype.getSetType().m_tupleTypes.size() < 2)
{
reportTypeError("The tuple must be a binary relation",
m_token,
specObject,
property
);
return new AstType();
}
//if (ptype.getType() == AstType.TYPE_TUPLE)
if (ptype.isTuple())
{
if ((ptype.m_tupleTypes.size() + 1) != ftype.m_setType.m_tupleTypes.size())
{
reportTypeError("Number of parameters for the function do not match definition.",
m_token,
specObject,
property
);
}
int i;
for (i = 0; i < ptype.m_tupleTypes.size(); i++)
{
AstType t1 = (AstType) ptype.m_tupleTypes.get(i);
AstType t2 = (AstType) ftype.m_setType.m_tupleTypes.get(i);
if (!t1.isCompatible(t2))
{
reportTypeError("Parameter " + (i + 1) + " does not match definition.",
m_token,
specObject,
property
);
}
}
}
else
{
if (!ptype.isEqual((AstType) ftype.getSetType().m_tupleTypes.get(0)))
{
reportTypeError("Parameter types do not match function parameters",
m_token,
specObject,
property
);
}
}
List vtmp = ftype.getSetType().m_tupleTypes;
return (AstType) vtmp.get(vtmp.size() - 1);
}
}
public class AstPredicateX extends AstExpression
{
AstPredicate m_predicate;
public AstPredicateX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_predicate.populateTypeTable(stable);
}
public void populateSymbolTable()
{
m_predicate.populateSymbolTable();
}
public AstType getType()
{
boolean bad = false;
return new AstType(AstType.TYPE_BOOL);
}
}
/*
* Infix, Postfix, Prefix
*/
public class AstPrefixGenericName extends AstBase
{
AstDecorations m_decoration;
public void print(int l)
{
print(l, "PrefixGenericName = " + m_token.m_value);
if (m_decoration != null)
{
m_decoration.print(l + 1);
}
}
}
public class AstInfixGenericName extends AstBase
{
AstDecorations m_decoration;
public void print(int l)
{
print(l, "InfixGenericName = " + getName());
if (m_decoration != null)
{
m_decoration.print(l + 1);
}
}
public String getName()
{
return m_token.m_value;
}
}
public class AstInfixFunctionName extends AstBase
{
AstDecorations m_decoration;
public void print(int l)
{
print(l, m_token.m_value);
if (m_decoration != null)
{
m_decoration.print(l + 1);
}
}
}
public class AstInfixRelationName extends AstBase
{
AstDecorations m_decoration;
public void print(int l)
{
print(l, "InfixRelationName = " + m_token.m_value);
if (m_decoration != null)
{
m_decoration.print(l + 1);
}
}
}
public class AstPrefixRelationName extends AstBase
{
public void print(int l)
{
print(l, "PrefixRelationName = " + getName());
}
public String getName()
{
return m_token.m_value;
}
}
public class AstPostfixFunctionName extends AstBase
{
AstDecorations m_decoration;
public void print(int l)
{
print(l, "PrefixFunctionName = " + m_token.m_value);
m_decoration.print(l + 1);
}
|
747fc2b7-6c6d-4d69-b686-e9d0105e3c8f
|
public void setCustomPhone6(crmondemand.xml.customobject6.query.QueryType customPhone6) {
this.customPhone6 = customPhone6;
}
|
19791398-ceb1-4d5c-ba56-f14e9e1935b9
|
public java.lang.String getCustomText43() {
return this.customText43;
}
|
ec3f0124-8377-4daa-b79f-6bf19f620254
|
public crmondemand.xml.contact.query.QueryType getCustomText53() {
return this.customText53;
}
|
df213be2-a9b7-42b5-80fc-4fdb59859ba5
|
public java.lang.String getPrimaryGroup() {
return this.primaryGroup;
}
|
c73a8e71-5bcb-4b0c-b210-5e09ef1cfd3b
|
public java.lang.String getCustomPickList20() {
return this.customPickList20;
}
|
ce4322a7-02da-4637-96c6-291fe3a31004
|
public void handler() {
A(IMMBYTE());
CLR_NZV();
SET_NZ8(A());
/*if (konamilog != null) {
fprintf(konamilog, "konami#%d lda_im :PC:%d,PPC:%d,A:%d,B:%d,D:%d,DP:%d,U:%d,S:%d,X:%d,Y:%d,CC:%d,EA:%d\n", cpu_getactivecpu(), konami.pc, konami.ppc, A(), B(), konami.d, konami.dp, konami.u, konami.s, konami.x, konami.y, konami.cc, ea);
}*/
}
|
f9ac571c-004d-4077-b54e-11904d7a66aa
|
public java.lang.Boolean getIsDifferentNaicsCode() {
return IsDifferentNaicsCode;
}
|
f0b246d9-a9b7-4a9e-9a4a-701debc2515e
|
public void setEngine(crmondemand.xml.customobject6.query.QueryType engine) {
this.engine = engine;
}
|
f24507c2-4480-4484-99f2-e470d9223ef4
|
public void setCustomPickList2(java.lang.String customPickList2) {
this.customPickList2 = customPickList2;
}
|
c3e203f8-906f-4718-8ff5-d0199e2c8fd9
|
public void setCustomBoolean15(crmondemand.xml.contact.query.QueryType customBoolean15) {
this.customBoolean15 = customBoolean15;
}
|
f1d13ea4-1f91-4864-b7d5-d5b8fb86fd8e
|
public crmondemand.xml.contact.query.QueryType getCustomPickList6() {
return this.customPickList6;
}
|
d50e208d-985a-4265-bc5a-f9fac4a87e3e
|
public void setCustomDate23(java.util.Calendar customDate23) {
this.customDate23 = customDate23;
}
|
07a33fd7-644d-436a-8f35-108832c5af3d
|
public java.lang.String getCustomPickList74() {
return this.customPickList74;
}
|
ae0d23c8-9bcf-4b7e-a236-ca8904baa283
|
public String getName(){
return name;
}
|
ba077ac0-5fa8-4164-94e9-38e0b9ce6c8e
|
public java.lang.Integer getCustomInteger15() {
return this.customInteger15;
}
|
49de08f1-6147-444f-85e1-858dd4dba1ec
|
public void setCustomDate55(crmondemand.xml.customobject3.query.QueryType customDate55) {
this.customDate55 = customDate55;
}
|
5b97f984-e999-48f0-83d7-04b50ac37701
|
public void setCustomCurrency7(java.math.BigDecimal customCurrency7) {
this.customCurrency7 = customCurrency7;
}
|
e88ccdfe-2654-4a7a-97b7-0cfbb0991093
|
public StringBuilder journalList(Session viewerS, String partialjournal)
{
final StringBuilder buf=new StringBuilder("");
String journal=null;
for(final Enumeration<JournalsLibrary.CommandJournal> e=CMLib.journals().commandJournals();e.hasMoreElements();)
{
final JournalsLibrary.CommandJournal CMJ=e.nextElement();
if((CMJ.NAME()+"S").startsWith(partialjournal.toUpperCase().trim()))
journal=CMJ.NAME().trim();
}
if(journal==null)
return buf;
final List<JournalEntry> V=CMLib.database().DBReadJournalMsgsByUpdateDate("SYSTEM_"+journal+"S", true);
final int COL_LEN1=CMLib.lister().fixColWidth(3.0,viewerS);
final int COL_LEN2=CMLib.lister().fixColWidth(10.0,viewerS);
if(V!=null)
{
buf.append("\n\r^x"+CMStrings.padRight("#",COL_LEN1+2)+CMStrings.padRight(L("From"),COL_LEN2)+" Entry^.^N\n\r");
buf.append("---------------------------------------------\n\r");
for(int j=0;j<V.size();j++)
{
final JournalEntry entry=V.get(j);
final String from=entry.from();
final String message=entry.msg();
buf.append("^x"+CMStrings.padRight((j+1)+"",COL_LEN1)+") "+CMStrings.padRight(from,COL_LEN2)+"^?^. "+message+"\n\r");
}
}
return buf;
}
|
e7307fcc-9554-44a7-8959-f711d72ab50a
|
public crmondemand.xml.customobject6.query.QueryType getCustomDate31() {
return this.customDate31;
}
|
d2209d10-499b-4206-9994-b9d56cffb83b
|
public crmondemand.xml.customobject3.query.QueryType getCustomPickList34() {
return this.customPickList34;
}
|
e6e5f7fa-8af7-4b75-9047-c0bf7d913f9e
|
public crmondemand.xml.contact.query.QueryType getCustomDate39() {
return this.customDate39;
}
|
c92930fe-da1e-4c90-80be-f8da62ad1336
|
public final PrimitiveTypeContext primitiveType() throws RecognitionException {
PrimitiveTypeContext _localctx = new PrimitiveTypeContext(_ctx, getState());
enterRule(_localctx, 96, RULE_primitiveType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(656);
_la = _input.LA(1);
if ( !(((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (10 - 10)) | (1L << (12 - 10)) | (1L << (14 - 10)) | (1L << (15 - 10)) | (1L << (35 - 10)) | (1L << (36 - 10)) | (1L << (49 - 10)) | (1L << (69 - 10)))) != 0)) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
|
bc78dd75-0b93-4a67-8510-7d021131f9ec
|
public void setCustomPhone2(crmondemand.xml.customobject6.query.QueryType customPhone2) {
this.customPhone2 = customPhone2;
}
|
8be954b3-750c-4a25-8d11-b261e2c022bd
|
public void requestCompleted(IRequest events) {
m_completedRequests.add(events);
}
|
6f5dd26c-606a-4d7a-87e9-64ff6c72aad0
|
public void setCustomPickList32(crmondemand.xml.contact.query.QueryType customPickList32) {
this.customPickList32 = customPickList32;
}
|
f88f3515-85e3-4766-a1e2-38177699301e
|
public java.math.BigDecimal getCustomNumber51() {
return this.customNumber51;
}
|
9b7ab353-984b-4237-b900-d61ec44e8e09
|
public String findQuery(String table, String name, String id, String att) {
if (att == "") {
att = "*";
}
String query = "SELECT " + att + " FROM " + table + " WHERE ";
if (notNorE(name) && notNorE(id)) {
if (table.toLowerCase().equals("security")) {
query += "s";
} else if (table.toLowerCase().equals("prisoner")) {
query += "p";
}
query += "name LIKE '%" + name + "%' AND ";
if (table.toLowerCase().equals("security")) {
query += "s";
} else if (table.toLowerCase().equals("prisoner")) {
query += "p";
}
query += "id = " + id;
} else if (notNorE(name)) {
if (table.toLowerCase().equals("security")) {
query += "s";
} else if (table.toLowerCase().equals("prisoner")) {
query += "p";
}
query += "name LIKE '%" + name + "%'";
} else if (notNorE(id)) {
if (table.toLowerCase().equals("security")) {
query += "s";
} else if (table.toLowerCase().equals("prisoner")) {
query += "p";
}
query += "id = " + id;
} else {
return error;
}
return sendQuery(query);
}
|
2a0bf638-2b61-4b14-8a2a-4d8d985a99e9
|
public ClientOperation() {
}
|
e188b76d-caf9-4aa0-ad8c-557ff0275899
|
public crmondemand.xml.customobject3.query.QueryType getAccreditationExternalSystemId() {
return this.accreditationExternalSystemId;
}
|
2636dac5-56cb-4f5d-91e7-94e7566c4905
|
public java.lang.String getCustomPickList63() {
return this.customPickList63;
}
|
e287edad-28ee-414e-b090-1ad243c29cd5
|
public void setCustomNumber51(java.math.BigDecimal customNumber51) {
this.customNumber51 = customNumber51;
}
|
a19e6324-7625-447d-a760-3b50c4368ac4
|
public crmondemand.xml.contact.query.QueryType getCustomInteger0() {
return this.customInteger0;
}
|
810623c4-8eba-4160-a33e-59b676f940de
|
public void setLeadId(crmondemand.xml.customobject6.query.QueryType leadId) {
this.leadId = leadId;
}
|
ddbd2121-f19e-40af-83b6-a6302b0aa347
|
public java.lang.String getObjectiveId() {
return this.objectiveId;
}
|
d1fab26a-371c-450d-960c-9959ad540fcd
|
public void setCourseIdentifier(crmondemand.xml.contact.query.QueryType courseIdentifier) {
this.courseIdentifier = courseIdentifier;
}
|
5ffd1963-8325-41ea-aa02-80cbaf4bd46c
|
public void comb()
{
m6809.b = (m6809.b ^ 0xFFFFFFFF) & 0xFF;
CLR_NZV();
SET_NZ8(m6809.b);
SEC();
if(m6809log!=null) fprintf(m6809log,"M6809#%d comb :PC:%d,PPC:%d,A:%d,B:%d,D:%d,DP:%d,U:%d,S:%d,X:%d,Y:%d,CC:%d,EA:%d\n", cpu_getactivecpu(),m6809.pc,m6809.ppc,m6809.a,m6809.b,getDreg(),m6809.dp,m6809.u,m6809.s,m6809.x,m6809.y,m6809.cc,ea);
}
|
3e611604-be56-4c99-bd9f-b1c101c26e45
|
public String getUserName() {
return userName;
}
|
32e3daac-c10a-41f0-9377-4e25da9156e8
|
public crmondemand.xml.opportunity.query.QueryType getCustomDate59() {
return this.customDate59;
}
|
5811f0e5-5009-46d4-af03-c6afe85900a4
|
public void setCustomObject6Type(java.lang.String customObject6Type) {
this.customObject6Type = customObject6Type;
}
|
184571e0-1a6e-4973-bce4-52f825324e38
|
public boolean existeMayorista(String nombre) throws Exception;
|
689f9753-c406-4c6c-89f6-bd65664d4bfa
|
public crmondemand.xml.customobject6.query.QueryType getCustomText87() {
return this.customText87;
}
|
def70608-f03c-427d-99ff-ee05c76cc103
|
public void setCustomBoolean7(java.lang.Boolean customBoolean7) {
this.customBoolean7 = customBoolean7;
}
|
f0d19fe9-88ba-4eb3-9faa-b64ce0bc1644
|
public void setCustomObject13Id(java.lang.String customObject13Id) {
this.customObject13Id = customObject13Id;
}
|
10084125-2c47-48d5-acda-6aaa23b6f232
|
public crmondemand.xml.contact.query.QueryType getCustomText19() {
return this.customText19;
}
|
0d04edba-a9b2-44b9-b621-f71f2879a3d4
|
public void setCustomNumber18(java.math.BigDecimal customNumber18) {
this.customNumber18 = customNumber18;
}
|
4c70a575-a287-44e4-9f9c-1603b559692e
|
public String getTipusActivitat() {
return tipusActivitat;
}
|
4bda4abc-ba69-4c87-88c0-37858de403ca
|
public void actionPerformed(java.awt.event.ActionEvent evt) {
StartActionPerformed(evt);
}
|
b1309af3-af80-4055-9239-bfc56dd8ca35
|
public void setFinancialAccountExternalSystemId(crmondemand.xml.opportunity.query.QueryType financialAccountExternalSystemId) {
this.financialAccountExternalSystemId = financialAccountExternalSystemId;
}
|
047428bc-a2f0-4546-b4ea-f7edf4178d45
|
public java.util.Calendar getCustomDate15() {
return this.customDate15;
}
|
439dd767-9798-44f3-b9da-ca71a6a70b3e
|
public void setAccreditationNum(java.lang.String accreditationNum) {
this.accreditationNum = accreditationNum;
}
|
2609dcec-feef-40f1-9a86-2ab69bb42e33
|
public java.lang.String getCustomPickList97() {
return this.customPickList97;
}
|
bd3f9467-5443-426e-ac05-4f26f0fe5870
|
public static int getCount() {
return MAP.size();
}
|
bc666265-dd45-4c91-ab76-a8bf680592d6
|
public crmondemand.xml.opportunity.query.QueryType getCustomCurrency23() {
return this.customCurrency23;
}
|
2efbd476-574b-4556-9f95-437f60e60dbc
|
public java.lang.String getCustomText22() {
return this.customText22;
}
|
9207277b-2f18-4f5a-a7f1-68bcf7643919
|
public void setCustomPickList7(crmondemand.xml.contact.query.QueryType customPickList7) {
this.customPickList7 = customPickList7;
}
|
9669a039-c4f0-4fba-ae2a-1ae9883eb087
|
public java.lang.String getCustomPickList68() {
return this.customPickList68;
}
|
77fefa0b-22f9-4b44-b90f-ee3eeda0a9a9
|
public void setCustomPickList45(java.lang.String customPickList45) {
this.customPickList45 = customPickList45;
}
|
c1e3b718-736f-480a-835e-67219955fa9c
|
public java.lang.String getCustomText10() {
return this.customText10;
}
|
512a26f3-de0c-4e28-af83-6290d2c90391
|
public void setCustomPickList51(java.lang.String customPickList51) {
this.customPickList51 = customPickList51;
}
|
487c59cc-5ee5-4ee5-9331-f4051e494407
|
public void handler() {
if (m68klog != null) {
fclose(m68klog);
}
throw new UnsupportedOperationException("Unimplemented");
}
|
da84f0bc-1a7b-4feb-9b61-6d39472910fa
|
public void setCustomText34(crmondemand.xml.contact.query.QueryType customText34) {
this.customText34 = customText34;
}
|
a438ccae-43a1-428b-8915-5a090d0ca6b5
|
public java.lang.String getBusinessPlanId() {
return this.businessPlanId;
}
|
73be0e12-da73-4d05-9dc3-d12203d7d387
|
private void drawTickMarks(final GraphicsContext CTX) {
double sinValue;
double cosValue;
double startAngle = getSkinnable().getStartAngle();
Point2D center = new Point2D(size * 0.5, size * 0.5);
for (double angle = 0, counter = getSkinnable().getMinValue() ; Double.compare(counter, getSkinnable().getMaxValue()) <= 0 ; angle -= angleStep, counter++) {
sinValue = Math.sin(Math.toRadians(angle + startAngle));
cosValue = Math.cos(Math.toRadians(angle + startAngle));
Point2D innerPoint = new Point2D(center.getX() + size * 0.388 * sinValue, center.getY() + size * 0.388 * cosValue);
Point2D outerPoint = new Point2D(center.getX() + size * 0.485 * sinValue, center.getY() + size * 0.485 * cosValue);
CTX.setStroke(getSkinnable().getTickMarkFill());
if (counter % getSkinnable().getMinorTickSpace() == 0) {
CTX.setLineWidth(size * 0.0035);
CTX.strokeLine(innerPoint.getX(), innerPoint.getY(), outerPoint.getX(), outerPoint.getY());
}
}
}
|
ab74306b-8b8b-4c16-b060-c3fbd9241a37
|
private boolean sanitizeUserCredentials(String username, String password, String passwordVerify) {
// Make sure something was entered in all fields + password matches verify
return (username.length() > 0 && password.length() > 0 && passwordVerify.length() > 0) && password.equals(passwordVerify);
}
|
1e415923-33e6-4227-b228-70aabe5cea45
|
public void setCustomObject14ExternalSystemId(crmondemand.xml.opportunity.query.QueryType customObject14ExternalSystemId) {
this.customObject14ExternalSystemId = customObject14ExternalSystemId;
}
|
e9ed0c9e-8a02-4760-a96b-aa2a5b90e528
|
public boolean isNetOutputEnabled()
{
return m_settingsData.netOutEnabled;
}
|
34b7eca8-bb60-44be-957c-a546184d6c53
|
public crmondemand.xml.customobject6.query.QueryType getCustomObject12Id() {
return this.customObject12Id;
}
|
545a4454-ff9a-4d47-8eb9-1b55804b32ba
|
public java.util.Calendar getCustomDate48() {
return this.customDate48;
}
|
165c8c03-2e30-4ba0-9d15-fea96a1079f4
|
public void setCustomBoolean24(java.lang.Boolean customBoolean24) {
this.customBoolean24 = customBoolean24;
}
|
6b25efad-6c3e-4b4f-8c67-c43e36256058
|
public java.lang.String getRole() {
return this.role;
}
|
1e0a6aa2-81a2-4c86-989c-f55091f84780
|
public String removeIfChild(String childID) {
return removeChild(childID);
}
|
80e268af-0535-4fce-bbf0-e82e0db5fed7
|
public static void setOnlineUserMap(HashMap<String, OnlineUserDetail> onlineUserMap_)
{
CommonData.onlineUserMap = onlineUserMap_;
}
|
5b988c91-7068-4dfd-a834-f992d57ab049
|
public void setAccountLocation(crmondemand.xml.customobject3.query.QueryType accountLocation) {
this.accountLocation = accountLocation;
}
|
db96b526-67ec-4c5a-a619-72acbb93e146
|
public java.lang.String getCustomObject14Type() {
return this.customObject14Type;
}
|
521f945e-ac18-46a4-a165-461a54d88f3a
|
public void setUpdatedByFirstName(crmondemand.xml.contact.query.QueryType updatedByFirstName) {
this.updatedByFirstName = updatedByFirstName;
}
|
9973beea-83a9-424a-8635-a69275b65b6a
|
public crmondemand.xml.opportunity.query.QueryType getPlanItemExternalSystemId() {
return this.planItemExternalSystemId;
}
|
f4090263-1f46-44ac-8886-08f4ad0a9908
|
public crmondemand.xml.contact.query.QueryType getCustomText18() {
return this.customText18;
}
|
3ee0e0c2-1bde-4cd0-b7fe-83d6db7ac8be
|
@Override
public byte getSecondGender() {
if (GameConstants.isZero(getJob())) {
return 1;
}
return gender; //todo zero
}
|
3f07232e-1b3e-4f85-9e24-cfe1c354c2b8
|
public void setCustomDate40(crmondemand.xml.contact.query.QueryType customDate40) {
this.customDate40 = customDate40;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.