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.