| /* |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| */ |
| |
| package macromedia.abc; |
| import static macromedia.asc.parser.Tokens.EMPTY_TOKEN; |
| import static macromedia.asc.semantics.Slot.*; |
| |
| import macromedia.asc.embedding.avmplus.*; |
| import macromedia.asc.util.*; |
| import macromedia.asc.parser.*; |
| import macromedia.asc.semantics.*; |
| import macromedia.asc.semantics.QName; |
| |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.IOException; |
| import java.util.Map; |
| import java.util.HashMap; |
| import java.util.Set; |
| |
| /** |
| * @author Erik Tierney |
| */ |
| @SuppressWarnings("nls") // TODO: Remove |
| public final class AbcParser |
| { |
| private Context ctx; |
| private AbcData abcData; |
| private static final boolean debug = false; |
| |
| public AbcParser(Context cx, String name) throws IOException |
| { |
| this.ctx = cx; |
| this.abcData = new AbcData(""); |
| this.abcData.readAbc(new BytecodeBuffer(name)); |
| } |
| |
| public AbcParser(Context cx, byte[] bytes) |
| { |
| this.ctx = cx; |
| this.abcData = new AbcData(""); |
| this.abcData.readAbc(new BytecodeBuffer(bytes)); |
| } |
| |
| private final Map<String, Integer> fun_names = new HashMap<String, Integer>(); |
| |
| private final ObjectList<ObjectList<ClassDefinitionNode>> clsdefs_sets = new ObjectList<ObjectList<ClassDefinitionNode>>(); |
| private final ObjectList<String> region_name_stack = new ObjectList<String>(); |
| |
| // TODO: better dependency analysis - this is used to populate FA's ce_unresolved_sets which |
| // TODO: mxml uses to find dependencies - could be done earlier for abcs |
| private ObjectList<Set<ReferenceValue>> ce_unresolved_sets = new ObjectList<Set<ReferenceValue>>(); |
| |
| public ProgramNode parseAbc() |
| { |
| return parseAbc(false, false); |
| } |
| |
| // first parameter causes BinaryProgramNode's toplevelDefinitions instance variable to be populated |
| // second parameter turns on/off building full ast's - if you suspect an mxmlc problem caused by a lack of |
| // ast from ABCs, turn this on to see if it fixes it. |
| // if this is false, only BinaryProgramNode, and toplevel definition nodes are created (mostly BinaryClassDefNode). |
| // hopefully we can get rid of those someday too. |
| // both these parameters are set to true by Flash Authoring and left false by by mxmlc |
| public ProgramNode parseAbc(boolean collectTopLevel, boolean buildASTForClasses) |
| { |
| try |
| { |
| // Create a program node that will represent the data in the abc file. |
| // It won't actually be a parse tree, but it will contain the correct builder |
| // objects which are usually built up by the FlowAnalyzer |
| |
| BinaryProgramNode program = ctx.getNodeFactory().binaryProgram(ctx, ctx.getNodeFactory().statementList(null, (StatementListNode)null)); |
| GlobalBuilder b = new GlobalBuilder(); |
| b.is_in_package = true; // cn: necessary for proper slot creation for top level functions |
| program.frame = new ObjectValue(ctx, b, ctx.noType()); |
| ctx.pushScope(program.frame); |
| clsdefs_sets.add(new ObjectList<ClassDefinitionNode>()); |
| ce_unresolved_sets.push_back(program.ce_unresolved); |
| region_name_stack.push_back(""); |
| |
| for( int i = 0; i < this.abcData.getScriptInfoSize(); ++i ) |
| { |
| parseScript(i, program, collectTopLevel, buildASTForClasses); |
| } |
| |
| program.clsdefs = clsdefs_sets.last(); |
| clsdefs_sets.removeLast(); |
| ce_unresolved_sets.removeLast(); |
| region_name_stack.pop_back(); |
| ctx.popScope(); // global |
| |
| // For proper const and type enforcement of top level functions and vars, we need to |
| // process those def nodes during CE. These definitions need to be evaluated in the |
| // scope of the BinaryProgramNode's frame. |
| // Conversely, class definition nodes are maintained in the clsdefs list rather than ever |
| // being added to the binary program node's statement list. This is so that they get processed outside the |
| // BinaryProgramNode's frame... |
| |
| // {pmd} following builds <ProgramNode <StatementList <BinaryProgramNode ...>>> |
| // {pmd} I wondered why? --probably to match some undefined visitor pattern behavior... |
| |
| ProgramNode prog = ctx.getNodeFactory().program(ctx, ctx.getNodeFactory().statementList(null, program)); |
| |
| // Uncomment next line to get some debugging info to print to stdout. |
| // {pmd} ??? for this to be useful it really should iterate the clsdefs list...(and print the objectvalue hierarchy too.) |
| // dumpProgram(program); |
| |
| return prog; |
| } |
| catch(Exception t) |
| { |
| if(debug) t.printStackTrace(); |
| // Clean up any scope we may have pushed and didn't pop when the exception was thrown |
| ObjectValue scope = ctx.scope(); |
| ObjectValue global = ctx.globalScope(); |
| while( scope != global ) |
| { |
| ctx.popScope(); |
| scope = ctx.scope(); |
| } |
| return null; |
| } |
| } |
| |
| static private class DefAndSlot |
| { |
| public DefinitionNode def; |
| public Slot slot; |
| } |
| |
| /** |
| * Returns a TypeValue for the qname specified by typeID. If that type does not exist yet |
| * a new placeholder TypeValue is created and returned. The placeholder will be filled in later when |
| * we actually see that type. This allows us to avoid any forward reference problems when parsing an ABC |
| * @param typeID the index of the QName we want the TypeValue for |
| * @return the TypeValue representing the type specifed by typeID. |
| */ |
| private TypeValue getTypeFromQName(int typeID) |
| { |
| if( typeID == 0 ) |
| return ctx.noType(); |
| |
| QName typename = getFullName(getBinaryMNFromCPool(typeID)); |
| |
| if( ctx.isBuiltin(typename.toString()) ) |
| return ctx.builtin( typename.toString() ); |
| |
| TypeValue type = TypeValue.getTypeValue(ctx, typename); |
| if( !type.resolved ) |
| ce_unresolved_sets.last().add(new ReferenceValue(ctx, null, typename.name, typename.ns)); |
| |
| return TypeValue.getTypeValue(ctx, typename); |
| |
| } |
| |
| private DefAndSlot slotTrait(String name, ObjectValue ns, int slotID, int typeID, int valueID, int value_kind, boolean is_const, boolean build_ast) |
| { |
| ObjectValue obj = ctx.scope(); |
| DefAndSlot ret = new DefAndSlot(); |
| Namespaces nss = new Namespaces(); |
| nss.push_back(ns); |
| |
| TypeValue type = getTypeFromQName(typeID); |
| |
| int var_id = obj.builder.Variable(ctx, obj); |
| int slot_id = obj.builder.ExplicitVar(ctx,obj,name,nss,type,-1,-1,var_id); |
| |
| Slot slot = obj.getSlot(ctx,slot_id); |
| slot.setConst(is_const); |
| slot.setImported(true); |
| |
| ret.slot = slot; |
| |
| IdentifierNode id=null; |
| AttributeListNode attr=null; |
| |
| if( build_ast ) |
| { |
| id = identifierNode(name, ns); |
| attr = attributeList(false, false, false, ns, obj.builder); |
| } |
| if( value_kind == ActionBlockConstants.CONSTANT_Namespace ) |
| { |
| ObjectValue nsValue = getNamespace(valueID); |
| slot.setObjectValue(nsValue); |
| slot.setConst(true); |
| |
| if( build_ast ) |
| ret.def = ctx.getNodeFactory().namespaceDefinition(attr, id, ctx.getNodeFactory().literalString(nsValue.name)); |
| |
| return ret; |
| } |
| if( valueID != 0) |
| slot.setObjectValue(getInitValue(valueID, value_kind)); |
| |
| if( build_ast ) |
| { |
| MemberExpressionNode typeExpr = null; |
| if( typeID != 0 ) |
| { |
| AbcData.BinaryMN t = getBinaryMNFromCPool(typeID); |
| typeExpr = memberExprFromMN(t); |
| } |
| |
| Node init = getInitValueNode(valueID,value_kind); // (0,0) means undefined |
| TypedIdentifierNode ty = ctx.getNodeFactory().typedIdentifier(id, typeExpr); |
| int tok = is_const ? Tokens.CONST_TOKEN : Tokens.VAR_TOKEN; |
| VariableBindingNode bind = ctx.getNodeFactory().variableBinding(attr, tok, ty, init); |
| |
| bind.ref = id.ref; |
| if( typeExpr != null ) |
| { |
| bind.typeref = typeExpr.ref; |
| } |
| |
| ret.def = (DefinitionNode) ctx.getNodeFactory().variableDefinition(attr, tok, ctx.getNodeFactory().list(null, bind)); |
| } |
| return ret; |
| } |
| |
| private MemberExpressionNode memberExprFromMN(AbcData.BinaryMN mn) |
| { |
| MemberExpressionNode typeExpr = null; |
| QName typeName = getFullName(mn); |
| NodeFactory nf = ctx.getNodeFactory(); |
| |
| if( typeName instanceof ParameterizedName ) |
| { |
| ParameterizedName pn = (ParameterizedName)typeName; |
| IdentifierNode baseIdNode = identifierNode(pn.name, pn.ns); |
| MemberExpressionNode param_node = memberExprFromMN(getBinaryMNFromCPool(mn.params[0])); |
| ListNode list = nf.list(null, param_node); |
| Node apply = nf.applyTypeExpr(baseIdNode, list, -1); |
| typeExpr = nf.memberExpression(null, (SelectorNode)apply); |
| typeExpr.ref = baseIdNode.ref; |
| typeExpr.ref.addTypeParam(param_node.ref); |
| } |
| else |
| { |
| IdentifierNode typeIdNode = identifierNode(typeName.name, typeName.ns); |
| GetExpressionNode getNode = nf.getExpression(typeIdNode); |
| typeExpr = nf.memberExpression(null, getNode); |
| typeExpr.ref = typeIdNode.ref; |
| } |
| return typeExpr; |
| } |
| |
| /** |
| * Creates an identifier node, and fills in the ref with the correct reference value |
| * @param simpleName |
| * @param ns |
| * @return IdentifierNode |
| */ |
| private IdentifierNode identifierNode(String simpleName, ObjectValue ns) |
| { |
| IdentifierNode id = ctx.getNodeFactory().identifier(simpleName); |
| //IdentifierNode will clean this up |
| id.ref = new ReferenceValue(ctx, null, id.name, ns); |
| return id; |
| } |
| |
| private DefAndSlot methodTrait(String methodName, ObjectValue ns, int dispID, int methInfo, int attrs, int kind, boolean build_ast) |
| { |
| ObjectValue obj = ctx.scope(); |
| DefAndSlot ret = new DefAndSlot(); |
| boolean isFinal = (attrs & ActionBlockConstants.TRAIT_FLAG_final) != 0; |
| boolean isOverride = (attrs & ActionBlockConstants.TRAIT_FLAG_override) != 0; |
| Namespaces names = new Namespaces(ns); |
| int method_id = obj.builder.Method(ctx,obj,methodName,names,false); |
| int method_slot; |
| NodeFactory nf = ctx.getNodeFactory(); |
| |
| // Create the right type of method based on what kind it is. Either a setter, getter, or regular method |
| switch(kind) |
| { |
| case ActionBlockConstants.TRAIT_Setter: //Set property |
| method_slot = obj.builder.ExplicitSet(ctx,obj,methodName,names,ctx.noType(),isFinal,isOverride,-1,method_id,-1); |
| break; |
| |
| case ActionBlockConstants.TRAIT_Getter: //get property |
| method_slot = obj.builder.ExplicitGet(ctx,obj,methodName,names,ctx.noType(),isFinal,isOverride,-1,method_id,-1); |
| break; |
| |
| default: // regular method |
| method_slot = obj.builder.ExplicitCall(ctx,obj,methodName,names,ctx.noType(),isFinal,isOverride,-1,method_id,-1); |
| break; |
| } |
| |
| ObjectValue funcObj = getFunctionObject(); |
| Slot slot = obj.getSlot(ctx, method_slot); |
| slot.setValue(funcObj); |
| slot.setImported(true); |
| |
| // Calculate the internal name - this matter because with get/set properties you can end up with |
| // multiple methods with the same name, but they must each have different internal names. |
| StringBuilder internal_name = new StringBuilder(methodName.length() + 5); |
| if( !fun_names.containsKey(methodName) ) |
| { |
| fun_names.put(methodName,0); |
| } |
| internal_name.append(methodName).append('$'); |
| int num = fun_names.get(methodName); |
| internal_name.append(num); |
| num++; |
| fun_names.put(methodName, num); |
| |
| int slot_id = obj.getImplicitIndex(ctx,method_slot,Tokens.EMPTY_TOKEN); |
| Slot implied_slot = obj.getSlot(ctx, slot_id); |
| implied_slot.setImported(true); |
| |
| String n = internal_name.toString(); |
| implied_slot.setMethodName(n);//node->fexpr->internal_name; |
| ret.slot = implied_slot; |
| |
| // Make sure the FunctionBuilder gets cleaned up |
| int functionKind; |
| switch( kind ) |
| { |
| case ActionBlockConstants.TRAIT_Getter: |
| functionKind = Tokens.GET_TOKEN; |
| break; |
| case ActionBlockConstants.TRAIT_Setter: |
| functionKind = Tokens.SET_TOKEN; |
| break; |
| default: |
| functionKind = Tokens.EMPTY_TOKEN; |
| break; |
| } |
| |
| // Come up with the function signature |
| AbcData.Method m_info = this.abcData.getMethod(methInfo); |
| |
| int returnTypeID = m_info.getReturnType(); |
| int paramTypeIDs[] = m_info.getParamTypes(); |
| int paramCount = paramTypeIDs.length; |
| ObjectList<Node> optional_nodes = null; |
| int optional_count = 0; |
| if( m_info.getHasOptional() ) |
| { |
| if( build_ast ) |
| { |
| optional_nodes = parseOptionalParams(m_info); |
| } |
| optional_count = m_info.getOptionalParamTypes().length; |
| } |
| String[] param_names = m_info.getParamNames(); |
| |
| // Set return type |
| implied_slot.setType(getTypeFromQName(returnTypeID).getDefaultTypeInfo()); |
| |
| ParameterListNode paramList = null; |
| |
| ObjectList<TypeInfo> param_types = new ObjectList<TypeInfo>(paramCount); |
| ByteList decl_styles = new ByteList(1); |
| |
| for( int i = 0, cur_optional = 0; i < paramCount; ++i ) |
| { |
| ParameterNode param = null; |
| if( build_ast ) |
| { |
| AbcData.BinaryMN typeMN = null; |
| if( paramTypeIDs[i] != 0 ) |
| { |
| typeMN = getBinaryMNFromCPool(paramTypeIDs[i]); |
| // getFullName(typeMN); // for effect |
| } |
| |
| String simple_param_name = i < param_names.length && param_names[i] != null ? param_names[i] : ("param" + (i+1)).intern(); |
| param = parameterNode(simple_param_name, typeMN); |
| |
| paramList = nf.parameterList(paramList, param); |
| } |
| |
| param_types.push_back(getTypeFromQName(paramTypeIDs[i]).getDefaultTypeInfo()); |
| |
| if( i >= paramCount - optional_count ) |
| { |
| if( build_ast ) |
| param.init = optional_nodes.get(cur_optional++); |
| decl_styles.push_back((byte) Slot.PARAM_Optional); |
| } |
| else |
| { |
| decl_styles.push_back((byte) Slot.PARAM_Required); |
| } |
| } |
| |
| if( m_info.getNeedsRest() ) |
| { |
| if( build_ast ) |
| { |
| ParameterNode param = parameterNode("rest", ctx.arrayType().name); |
| RestParameterNode restNode = ctx.getNodeFactory().restParameter(param , -1); |
| restNode.ref = param.ref; |
| restNode.typeref = param.typeref; |
| paramList = nf.parameterList(paramList, restNode); |
| |
| // rsun 11.22.05 porting over a fix made to the 8ball_AS3 branch a long time |
| // ago, but only to the C++ compiler. has_rest needs to be reset here since |
| // MovieClipMaker is a special entry point that creates function nodes itself. |
| // otherwise, has_rest is unnecessarily true for all functions processed after |
| // this. |
| ctx.getNodeFactory().has_rest = false; |
| } |
| |
| param_types.push_back(ctx.arrayType().getDefaultTypeInfo()); |
| decl_styles.push_back((byte) Slot.PARAM_Rest); |
| } |
| |
| if( param_types.size() > 0 ) |
| { |
| implied_slot.setTypes(param_types); |
| implied_slot.setDeclStyles(decl_styles); |
| } |
| else |
| { |
| param_types.push_back(ctx.voidType().getDefaultTypeInfo()); |
| implied_slot.setTypes(param_types); |
| implied_slot.addDeclStyle(Slot.PARAM_Void); |
| } |
| |
| if( build_ast ) |
| { |
| MemberExpressionNode retTypeNode = null; |
| if( returnTypeID != 0 ) |
| { |
| AbcData.BinaryMN retMN = getBinaryMNFromCPool(returnTypeID); |
| retTypeNode = memberExprFromMN(retMN); |
| } |
| FunctionSignatureNode fsn = nf.functionSignature(paramList,retTypeNode); |
| if( retTypeNode != null ) |
| { |
| fsn.typeref = retTypeNode.ref; |
| } |
| |
| IdentifierNode id = identifierNode(methodName,ns); |
| FunctionCommonNode fcn = nf.functionCommon(ctx, id, fsn, null); |
| fcn.kind = functionKind; |
| fcn.ref = id.ref; |
| |
| FunctionNameNode fn = nf.functionName(functionKind, id); |
| AttributeListNode attr = attributeList(isFinal, isOverride, false, ns, obj.builder); |
| FunctionDefinitionNode fdn = nf.binaryFunctionDefinition(ctx, attr, fn, fcn, -1); |
| |
| ret.def = fdn; |
| } |
| return ret; |
| } |
| |
| private static ObjectValue dummyFunc = null; |
| |
| /** |
| * Helper so we only allocate 1 ObjectValue to represent a method, instead |
| * of 1 for each method. This is safe because the OV is only used as the value |
| * of a MethodSlot, and we only ever check for the existance of the value, never anything else |
| * @return an ObjectValue that can be used for a function object |
| */ |
| private ObjectValue getFunctionObject() |
| { |
| if( dummyFunc == null ) |
| dummyFunc = new ObjectValue(ctx,new FunctionBuilder(),ctx.functionType()); |
| |
| return dummyFunc; |
| } |
| |
| private Node getInitValueNode(int valueID,int kind) |
| { |
| Node t; |
| NodeFactory nf = ctx.getNodeFactory(); |
| |
| switch (kind) |
| { |
| case ActionBlockConstants.CONSTANT_Void: |
| t = nf.unaryExpression(Tokens.VOID_TOKEN,nf.literalNumber("0",-1),-1); |
| break; |
| |
| case ActionBlockConstants.CONSTANT_Integer: |
| case ActionBlockConstants.CONSTANT_UInteger: |
| case ActionBlockConstants.CONSTANT_Double: |
| double val = getNumberFromCPool(valueID, kind); |
| t = nf.literalNumber(String.valueOf(val)); |
| break; |
| |
| case ActionBlockConstants.CONSTANT_Decimal: |
| Decimal128 dval = getDecimalFromCPool(valueID); |
| String sval = dval.toString(); |
| if (ctx.statics.es4_numerics) |
| sval += "m"; |
| t = nf.literalNumber(sval); |
| break; |
| |
| case ActionBlockConstants.CONSTANT_True: |
| t = nf.literalBoolean(true); |
| break; |
| |
| case ActionBlockConstants.CONSTANT_False: |
| t = nf.literalBoolean(false); |
| break; |
| |
| case ActionBlockConstants.CONSTANT_Utf8: |
| t = nf.literalString(getStringFromCPool(valueID)); |
| break; |
| |
| case ActionBlockConstants.CONSTANT_Null: |
| t = nf.literalNull(); |
| break; |
| |
| case ActionBlockConstants.CONSTANT_Namespace: |
| ObjectValue ns = getNamespace(valueID); |
| t = nf.literalString(ns.name); |
| break; |
| |
| default: |
| t = nf.literalString(""); |
| break; |
| } |
| return t; |
| } |
| |
| private ObjectValue getInitValue(int valueID,int kind) |
| { |
| ObjectValue ov; |
| switch (kind) |
| { |
| case ActionBlockConstants.CONSTANT_Void: |
| ov = ctx.voidType().prototype; |
| break; |
| |
| case ActionBlockConstants.CONSTANT_Integer: |
| double intval = getNumberFromCPool(valueID, kind); |
| ov = new ObjectValue(String.valueOf(intval), ctx.intType()); |
| break; |
| case ActionBlockConstants.CONSTANT_UInteger: |
| double uintval = getNumberFromCPool(valueID, kind); |
| ov = new ObjectValue(String.valueOf(uintval), ctx.uintType()); |
| break; |
| case ActionBlockConstants.CONSTANT_Double: |
| double val = getNumberFromCPool(valueID, kind); |
| ov = new ObjectValue(String.valueOf(val), ctx.doubleType()); |
| break; |
| |
| case ActionBlockConstants.CONSTANT_Decimal: |
| Decimal128 dval = getDecimalFromCPool(valueID); |
| String sval = dval.toString(); |
| if (ctx.statics.es4_numerics) |
| sval += "m"; |
| ov = new ObjectValue(sval, ctx.decimalType()); |
| break; |
| |
| case ActionBlockConstants.CONSTANT_True: |
| ov = ctx.booleanTrue(); |
| break; |
| |
| case ActionBlockConstants.CONSTANT_False: |
| ov = ctx.booleanFalse(); |
| break; |
| |
| case ActionBlockConstants.CONSTANT_Utf8: |
| ov = new ObjectValue(getStringFromCPool(valueID), ctx.stringType()); |
| break; |
| |
| case ActionBlockConstants.CONSTANT_Null: |
| ov = ctx.nullType().prototype; |
| break; |
| |
| case ActionBlockConstants.CONSTANT_Namespace: |
| ObjectValue ns = getNamespace(valueID); |
| ov = ns; |
| break; |
| |
| default: |
| ov = null; |
| break; |
| } |
| return ov; |
| } |
| |
| private ObjectList<Node> parseOptionalParams(AbcData.Method method_info) |
| { |
| int[] optional_values = method_info.getOptionalParamTypes(); |
| int[] optional_kinds = method_info.getOptionalParamKinds(); |
| |
| ObjectList<Node> optionals = new ObjectList<Node>(optional_values.length); |
| for( int i = 0; i < optional_values.length; ++i) |
| { |
| int value_index = optional_values[i]; |
| int value_kind = optional_kinds[i]; |
| Node current_node = getInitValueNode(value_index,value_kind); |
| optionals.push_back(current_node); |
| } |
| return optionals; |
| } |
| |
| |
| private ParameterNode parameterNode(String simpleParamName, QName typeName) |
| { |
| IdentifierNode id = identifierNode(simpleParamName, ctx.publicNamespace()); |
| IdentifierNode ty = null; |
| MemberExpressionNode paramType = null; |
| |
| if( typeName != null ) |
| { |
| ty = identifierNode(typeName.name, typeName.ns); |
| GetExpressionNode getNode = ctx.getNodeFactory().getExpression(ty); |
| paramType = ctx.getNodeFactory().memberExpression(null, getNode); |
| } |
| ParameterNode param = ctx.getNodeFactory().parameter(Tokens.VAR_TOKEN, id, paramType); |
| if( ty != null ) |
| { |
| param.typeref = ty.ref; |
| } |
| param.ref = id.ref; |
| |
| return param; |
| } |
| |
| private ParameterNode parameterNode(String simpleParamName, AbcData.BinaryMN typeMN) |
| { |
| IdentifierNode id = identifierNode(simpleParamName, ctx.publicNamespace()); |
| |
| MemberExpressionNode paramType = null; |
| if( typeMN != null ) |
| { |
| paramType = memberExprFromMN(typeMN); |
| } |
| ParameterNode param = ctx.getNodeFactory().parameter(Tokens.VAR_TOKEN, id, paramType); |
| if( paramType != null ) |
| { |
| param.typeref = paramType.ref; |
| } |
| param.ref = id.ref; |
| |
| return param; |
| } |
| |
| private AttributeListNode attributeList(boolean isFinal, boolean isOverride, boolean isDynamic, ObjectValue ns, Builder builder) |
| { |
| AttributeListNode attr = ctx.getNodeFactory().attributeList(ctx.getNodeFactory().literalString(""), null); |
| |
| attr.hasFinal = isFinal; |
| attr.hasOverride = isOverride; |
| attr.hasDynamic = isDynamic; |
| |
| if( builder instanceof ClassBuilder ) //Statics are built by classbuilder, non statics by instancebuilder |
| { |
| attr.hasStatic = true; |
| } |
| if ( ns == null ) |
| return attr; |
| |
| if( ns == ctx.publicNamespace() || (ns.getNamespaceKind() == Context.NS_PUBLIC && ns.isPackage()) ) |
| { |
| // Only package public namespaces will have been qualified with the 'public' access specifier |
| // user defined namespaces may also be public namespaces in the cpool, but they will not be package namespaces |
| attr.hasPublic = true; |
| } |
| else if( ns.isInternal() ) |
| attr.hasInternal = true; |
| else if( ns.isProtected() ) |
| attr.hasProtected = true; |
| else if( ns.isPrivate() ) |
| attr.hasPrivate = true; |
| else |
| { |
| if( builder.classname != null && ns == builder.classname.ns) |
| attr.hasPublic = true; |
| else |
| attr.namespaces.add(ns); |
| } |
| return attr; |
| } |
| |
| // Utility to get the full name based on a qname (ns + "/" + name) |
| private QName getFullName(AbcData.BinaryMN mn) |
| { |
| if( mn.kind == ActionBlockConstants.CONSTANT_TypeName ) |
| { |
| AbcData.BinaryMN base = getBinaryMNFromCPool(mn.baseMN); |
| QName base_qn = getFullName(base); |
| ObjectList<QName> params = new ObjectList<QName>(mn.params.length); |
| |
| for( int i = 0; i < mn.params.length; ++i) { |
| params.add(getFullName(getBinaryMNFromCPool(mn.params[i]))); |
| } |
| ParameterizedName pn = new ParameterizedName(params, base_qn.ns, base_qn.name); |
| return pn; |
| } |
| else |
| { |
| assert (mn.nsIsSet != true):"expected a single namespace"; |
| |
| String fullName = getStringFromCPool(mn.nameID); |
| ObjectValue ns = getNamespace(mn.nsID); |
| return ctx.computeQualifiedName("", fullName, ns, EMPTY_TOKEN); |
| } |
| } |
| |
| private DefAndSlot classTrait(String className, ObjectValue ns, int slotID, int classID, boolean build_ast) |
| { |
| if( classID >= this.abcData.getClassInfoSize() || classID < 0 ) |
| return null; |
| |
| DefAndSlot ret = new DefAndSlot(); |
| ObjectValue current_scope = ctx.scope(); |
| |
| String region_name = region_name_stack.back(); |
| if( region_name.length() > 0 ) |
| { |
| region_name += "/"; |
| ns = ctx.getNamespace(region_name + ns.name); |
| } |
| |
| NodeFactory nf = ctx.getNodeFactory(); |
| |
| // Instance info |
| AbcData.InstanceInfo iinfo = this.abcData.getInstanceInfo(classID); |
| |
| AbcData.BinaryMN instanceMN = getBinaryMNFromCPool(iinfo.getInstanceNameID()); |
| QName fullName = getFullName(instanceMN); |
| String fullNameString = fullName.toString(); |
| |
| int superID = iinfo.getSuperID(); |
| boolean hasSuper = superID != 0; |
| QName superName = null; |
| String simpleSuperName =""; |
| ObjectValue superNamespace = null; |
| if( hasSuper ) |
| { |
| AbcData.BinaryMN superMN = getBinaryMNFromCPool(superID); |
| |
| assert (superMN.nsIsSet != true):"expected a single namespace"; |
| |
| superNamespace = getNamespace(superMN.nsID); |
| superName = getFullName(superMN); |
| simpleSuperName = getStringFromCPool(superMN.nameID); |
| } |
| |
| int flags = iinfo.getFlags(); |
| |
| int[] interfaces = iinfo.getInterfaces(); |
| ListNode interface_nodes = null; |
| if(debug&&interfaces.length>0) System.out.println("parsing " + interfaces); |
| for( int i = 0; i < interfaces.length; ++i ) |
| { |
| int int_index = interfaces[i]; |
| AbcData.BinaryMN intMN = getBinaryMNFromCPool(int_index); |
| String simpleIntName = getStringFromCPool(intMN.nameID); |
| Namespaces intNamespaces; |
| if(intMN.nsIsSet) |
| intNamespaces = getNamespaces(intMN.nsID); |
| else { |
| intNamespaces = new Namespaces(1); |
| intNamespaces.add(getNamespace(intMN.nsID)); |
| } |
| |
| IdentifierNode ident = nf.identifier(simpleIntName); |
| |
| ident.ref = new ReferenceValue(ctx, null, simpleIntName, intNamespaces); |
| GetExpressionNode getNode = nf.getExpression(ident); |
| MemberExpressionNode interface_node = nf.memberExpression(null, getNode); |
| interface_node.ref = ident.ref; |
| interface_nodes = nf.list(interface_nodes, interface_node); |
| interface_nodes.values.push_back(ident.ref); |
| } |
| |
| boolean isFinal = (flags & ActionBlockConstants.CLASS_FLAG_final) != 0; |
| boolean isDynamic = ( flags & ActionBlockConstants.CLASS_FLAG_sealed ) == 0; |
| boolean isInterface = (flags & ActionBlockConstants.CLASS_FLAG_interface) != 0; |
| |
| ClassDefinitionNode cdn = null; |
| IdentifierNode idNode = nf.identifier(className); |
| idNode.ref = new ReferenceValue(ctx, null, idNode.name, ns); |
| |
| AttributeListNode attr = attributeList(isFinal, false, isDynamic, ns, current_scope.builder); |
| StatementListNode stmtList = nf.statementList(null, (StatementListNode)null); |
| |
| if (isInterface) |
| { |
| cdn = nf.binaryInterfaceDefinition(ctx, attr, idNode, null, stmtList); |
| } |
| else |
| { |
| cdn = nf.binaryClassDefinition(ctx, attr, idNode, null, stmtList); |
| } |
| cdn.ref = idNode.ref; |
| cdn.interfaces = interface_nodes; |
| cdn.public_namespace = ctx.publicNamespace(); |
| cdn.protected_namespace = ctx.getNamespace(fullNameString, Context.NS_PROTECTED); |
| cdn.static_protected_namespace = ctx.getNamespace(fullNameString, Context.NS_STATIC_PROTECTED); |
| cdn.private_namespace = ctx.getNamespace(fullNameString, Context.NS_PRIVATE); |
| cdn.default_namespace = ctx.getNamespace(fullName.ns.name, Context.NS_INTERNAL); |
| |
| boolean is_builtin = ctx.isBuiltin(fullNameString); |
| TypeValue cframe; |
| ObjectValue iframe; |
| if( is_builtin ) |
| { |
| cframe = ctx.builtin(fullNameString); |
| iframe = cframe.prototype; |
| } |
| else |
| { |
| ClassBuilder cb = new ClassBuilder(fullName,cdn.protected_namespace,cdn.static_protected_namespace); |
| cframe = TypeValue.defineTypeValue(ctx,cb,fullName,RuntimeConstants.TYPE_object); |
| |
| InstanceBuilder ib = new InstanceBuilder(fullName); |
| ib.canEarlyBind = false; |
| iframe = new ObjectValue(ctx,ib,cframe); |
| cframe.prototype = iframe; |
| |
| cdn.debug_name = fullNameString; |
| // Make sure the ClassBuilder and InstanceBuilders get cleaned up |
| cdn.owns_cframe = true; |
| } |
| cdn.cframe = cframe; |
| cdn.iframe = iframe; |
| |
| if( isInterface ) |
| { |
| ((ClassBuilder)cframe.builder).is_interface = true; |
| } |
| cframe.builder.is_dynamic = iframe.builder.is_dynamic = isDynamic; |
| cframe.builder.is_final = iframe.builder.is_final = isFinal; |
| |
| clsdefs_sets.last().add(cdn); |
| |
| if( hasSuper ) |
| { |
| TypeValue superType; |
| cdn.baseclass = nf.literalString(superName.toString(), -1); |
| if( ctx.isBuiltin(superName.toString()) ) |
| { |
| // Set the super type, this important for int/uint which derive from Number |
| superType = ctx.builtin(superName.toString()); |
| cframe.baseclass = superType; |
| cdn.baseref = new ReferenceValue(ctx, null, superName.toString(), ctx.publicNamespace()); |
| } |
| else |
| { |
| //cdn.baseclass = nf.literalString(superName.toString(), -1); |
| cdn.baseref = new ReferenceValue(ctx, null, simpleSuperName, superNamespace); |
| cdn.baseref.getSlot(ctx); |
| |
| cframe.baseclass = getTypeFromQName((int)superID) ; |
| } |
| } |
| else if (cdn.cframe != ctx.objectType()) |
| { |
| cdn.baseclass = nf.memberExpression(null, nf.getExpression(nf.identifier("Object"))); |
| cframe.baseclass = ctx.objectType(); |
| } |
| else |
| { |
| cdn.baseclass = null; |
| cframe.baseclass = null; |
| } |
| |
| int var_id = current_scope.builder.Variable(ctx,current_scope); |
| int slot_id = current_scope.builder.ExplicitVar(ctx,current_scope,className,ns,ctx.typeType(),-1,-1,var_id); |
| Slot slot = current_scope.getSlot(ctx,slot_id); |
| slot.setObjectValue(cframe); |
| slot.setImported(true); |
| slot.setConst(true); // all class definitions are const. |
| |
| ret.slot = slot; |
| |
| current_scope.builder.ImplicitCall(ctx,current_scope,slot_id,cframe,CALL_Method,-1,-1); |
| current_scope.builder.ImplicitConstruct(ctx,current_scope,slot_id,cframe,CALL_Method,-1,-1); |
| |
| if( isInterface ) |
| { |
| ((ClassBuilder)cframe.builder).is_interface = true; |
| slot.setImplNode(cdn); |
| } |
| |
| clsdefs_sets.add(new ObjectList<ClassDefinitionNode>()); |
| |
| region_name_stack.push_back(fullNameString); |
| |
| ctx.pushStaticClassScopes(cdn); // class |
| { |
| ctx.pushScope(iframe); // instance |
| { |
| StatementListNode instance_stmts = nf.statementList(null, (StatementListNode)null); |
| parseTraits(iinfo.getITraits(), instance_stmts, build_ast, null, build_ast); // Traits for the instance |
| cdn.instanceinits = new ObjectList<Node>(instance_stmts.items.size()); |
| if( instance_stmts.items.size() > 0) |
| { |
| cdn.instanceinits.addAll(instance_stmts.items); |
| } |
| // Add nodes for the constructor, which doesn't have a traits entry. |
| DefAndSlot d = methodTrait("$construct", ctx.publicNamespace(),0,iinfo.getInitIndex(),0,0, build_ast); |
| DefinitionNode iinit_node = d.def; |
| if( build_ast ) |
| cdn.instanceinits.add(iinit_node); |
| |
| int implied_idx = current_scope.getImplicitIndex(ctx, slot_id, Tokens.NEW_TOKEN); |
| Slot class_slot = current_scope.getSlot(ctx, implied_idx); |
| if( class_slot != null) |
| { |
| //class_slot.setType(d.slot.getType()); |
| class_slot.setTypes(d.slot.getTypes()); |
| class_slot.setDeclStyles(d.slot.getDeclStyles()); |
| } |
| } |
| ctx.popScope(); // instance |
| |
| AbcData.ClassInfo cinfo = this.abcData.getClassInfo(classID); |
| parseTraits(cinfo.getCTraits(), cdn.statements, build_ast, null, build_ast); // Traits for the class (statics) |
| } |
| ctx.popStaticClassScopes(cdn); //class |
| |
| clsdefs_sets.removeLast(); |
| region_name_stack.pop_back(); |
| |
| ret.def = cdn; |
| return ret; |
| } |
| |
| // parsetraits - if prog is non-null we will populate prog.toplevelDefinitions |
| private void parseTraits(AbcData.Trait[] traits, StatementListNode statements, boolean build_ast, BinaryProgramNode prog, boolean buildASTForClasses) |
| { |
| for (AbcData.Trait t: traits) |
| { |
| AbcData.BinaryMN mn = getBinaryMNFromCPool(t.getNameIndex()); |
| String name = getStringFromCPool(mn.nameID); |
| ObjectValue ns; |
| ns = getNamespaceFromMultiname(mn); |
| |
| DefAndSlot d = null; |
| switch (t.getTag()) |
| { |
| case ActionBlockConstants.TRAIT_Var: |
| case ActionBlockConstants.TRAIT_Const: |
| d = slotTrait(name, ns, t.getSlotId(), t.getTypeName(), t.getValueIndex(), t.getValueKind(), t.isConstTrait(), build_ast); |
| if( build_ast ) |
| statements.items.add(d.def); |
| |
| if( prog != null ) |
| prog.toplevelDefinitions.add(new QName(ns, name)); |
| |
| break; |
| |
| case ActionBlockConstants.TRAIT_Method: |
| case ActionBlockConstants.TRAIT_Getter: |
| case ActionBlockConstants.TRAIT_Setter: |
| d = methodTrait(name, ns, t.getDispId(), t.getMethodId(), t.getAttrs(), t.getTag(), build_ast); |
| if( build_ast ) |
| statements.items.add(d.def); |
| |
| if( prog != null ) |
| prog.toplevelDefinitions.add(new QName(ns, name)); |
| |
| break; |
| |
| case ActionBlockConstants.TRAIT_Class: |
| d = classTrait(name, ns, t.getSlotId(), t.getClassId(), buildASTForClasses); |
| |
| if( prog != null ) |
| prog.toplevelDefinitions.add(new QName(ns, name)); |
| |
| break; |
| |
| case ActionBlockConstants.TRAIT_Function: // currently unused |
| break; |
| |
| default: |
| break; |
| //throw new DecoderException("Invalid trait kind: " + kind); |
| } |
| |
| if( t.hasMetadata() && d!= null ) |
| { |
| int[] metadata = t.getMetadata(); |
| for( int metaIndex: metadata ) |
| { |
| MetaDataNode metaNode = parseMetadataInfo(metaIndex); |
| |
| if ( d.def != null ){ |
| metaNode.def = d.def; |
| d.def.addMetaDataNode(metaNode); |
| if( build_ast ) |
| statements.items.add(metaNode); //{pmd} now hasn't this just been hung off the def node? yup, but fails if not here too. |
| } |
| |
| if( d.slot != null ) |
| { |
| String md_id = metaNode.getId(); |
| if( (MetaDataEvaluator.GO_TO_CTOR_DEFINITION_HELP != md_id) && |
| (MetaDataEvaluator.GO_TO_DEFINITION_HELP != md_id) ) // Should be ok since the cpool entries are interned |
| { |
| // Don't add the go_to_def metadata - its never needed by the compiler (its just a hint for tools) |
| // and it takes up a ton of memory if we add it. |
| //??? Used to only add 'deprecated' metadata...???ask Erik whats up here? |
| d.slot.addMetadata(metaNode); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * Extract a namespace from a multiname. |
| * @param mn - the multiname. It should only have one namespace if it's a set. |
| * @return the multiname's namespace. |
| */ |
| private ObjectValue getNamespaceFromMultiname(AbcData.BinaryMN mn) |
| { |
| ObjectValue ns; |
| if( mn.nsIsSet ) |
| { |
| Namespaces ns_set = getNamespaces(mn.nsID); |
| if (ns_set.size() > 1) { // they should all have the same URI modulo version maker |
| ns = null; |
| for (ObjectValue t : ns_set) { |
| if (ns == null || t.name.length() < ns.name.length()) { |
| ns = t; // the unmarked uri is always the shortest, so return it |
| } |
| } |
| } |
| else { |
| ns = ns_set.at(0); |
| } |
| } |
| else |
| { |
| ns = getNamespace(mn.nsID); |
| } |
| return ns; |
| } |
| |
| private void parseScript(int scriptIndex, BinaryProgramNode program, boolean collectTopLevel, boolean buildASTForClasses) |
| { |
| if( scriptIndex < 0 || scriptIndex >= this.abcData.getScriptInfoSize() ) |
| { |
| return; |
| } |
| |
| AbcData.ScriptInfo s = this.abcData.getScriptInfo(scriptIndex); |
| // at top level always want to set build_ast param to true |
| parseTraits(s.getScriptTraits(), program.statements, true, collectTopLevel ? program : null, buildASTForClasses); |
| } |
| |
| |
| private MetaDataNode parseMetadataInfo( int index ) |
| { |
| // TODO: Cache this data more aggressively. |
| MetaDataNode metaNode = ctx.getNodeFactory().metaData(null, -1); |
| metaNode.setMetadata(this.abcData.getMetadata(index, metaNode)); |
| return metaNode; |
| } |
| |
| |
| |
| private String getStringFromCPool(int id) |
| { |
| return this.abcData.getString(id); |
| } |
| |
| private Decimal128 getDecimalFromCPool(int id) |
| { |
| return this.abcData.getDecimal(id); |
| } |
| |
| private double getNumberFromCPool(int id, int kind) |
| { |
| double ret = 0.0; |
| switch(kind) |
| { |
| case ActionBlockConstants.CONSTANT_Integer: |
| ret = this.abcData.getInt(id); |
| return ret; |
| |
| case ActionBlockConstants.CONSTANT_UInteger: |
| ret = this.abcData.getUint(id) & 0xFFFFFFFFL; |
| return ret; |
| |
| case ActionBlockConstants.CONSTANT_Double: |
| ret = this.abcData.getDouble(id); |
| return ret; |
| } |
| // {pmd} silent fail here...is this really a good idea? |
| return ret; |
| } |
| |
| |
| private AbcData.BinaryMN getBinaryMNFromCPool(int index) |
| { |
| return this.abcData.getName(index); |
| } |
| |
| Namespaces getNamespaces(int namespaceSetID) |
| { |
| int[] ns_ids = this.abcData.getNamespaceSet(namespaceSetID).getNamespaceIds(); |
| Namespaces val = new Namespaces(ns_ids.length); |
| for(int i = 0; i < ns_ids.length; ++i) |
| { |
| val.add(getNamespace(ns_ids[i])); |
| } |
| return val; |
| } |
| |
| ObjectValue getNamespace(int namespaceID) |
| { |
| ObjectValue ns = null; |
| if( namespaceID == 0 ) |
| { |
| ns = ctx.anyNamespace(); |
| } |
| else |
| { |
| int kind = this.abcData.getNamespace(namespaceID).nsKind; |
| String uri = this.abcData.getNamespace(namespaceID).getName(); |
| int ver = -1; |
| byte ns_kind; |
| |
| switch(kind) |
| { |
| case ActionBlockConstants.CONSTANT_Namespace: |
| //vers.add(getVersion(uri)); |
| ns_kind = Context.NS_PUBLIC; |
| ns = ctx.getNamespace(uri); |
| break; |
| case ActionBlockConstants.CONSTANT_PackageNamespace: |
| //vers.add(getVersion(uri)); |
| ns_kind = Context.NS_PUBLIC; |
| ns = ctx.getNamespace(uri); |
| ns.setPackage(true); |
| break; |
| case ActionBlockConstants.CONSTANT_ProtectedNamespace: |
| ns_kind = Context.NS_PROTECTED; |
| ns = ctx.getNamespace(uri, ns_kind); |
| break; |
| case ActionBlockConstants.CONSTANT_PackageInternalNs: |
| ns_kind = Context.NS_INTERNAL; |
| ns = ctx.getNamespace(uri, ns_kind); |
| break; |
| case ActionBlockConstants.CONSTANT_PrivateNamespace: |
| ns_kind = Context.NS_PRIVATE; |
| ns = ctx.getNamespace(uri, ns_kind); |
| break; |
| case ActionBlockConstants.CONSTANT_ExplicitNamespace: |
| ns_kind = Context.NS_EXPLICIT; |
| ns = ctx.getNamespace(uri, ns_kind); |
| break; |
| case ActionBlockConstants.CONSTANT_StaticProtectedNs: |
| ns_kind = Context.NS_STATIC_PROTECTED; |
| ns = ctx.getNamespace(uri, ns_kind); |
| break; |
| default: |
| throw new IllegalStateException("Invalid kind:" + Integer.toString(kind)); |
| } |
| } |
| return ns; |
| } |
| |
| |
| /* |
| // These dump functions below are just some debugging aids. |
| private void dumpProgram(BinaryProgramNode program) |
| { |
| |
| if( program.statements != null) |
| { |
| dumpStatementList(program.statements); |
| } |
| } |
| |
| private void dumpClass(BinaryClassDefNode bincls) |
| { |
| if( bincls.attrs != null) |
| System.out.print(attrsToString(bincls.attrs)); |
| System.out.print("class " + bincls.cframe.name); |
| if( bincls.baseref != null) |
| { |
| System.out.print(" extends " + typeRefToString(bincls.baseref)); |
| } |
| if( bincls.interfaces != null ) |
| { |
| System.out.print(" implements " ); |
| for( int i = 0; i < bincls.interfaces.size(); ++ i) |
| { |
| Node n = bincls.interfaces.items.get(i); |
| if( n instanceof MemberExpressionNode ) |
| { |
| System.out.print( typeRefToString(((MemberExpressionNode)n).ref)); |
| } |
| } |
| } |
| System.out.println(""); |
| System.out.println("{"); |
| if( bincls.statements != null) |
| { |
| dumpStatementList(bincls.statements); |
| } |
| |
| if( bincls.instanceinits != null) |
| { |
| dumpNodeList(bincls.instanceinits); |
| } |
| |
| System.out.println("} //"+bincls.cframe.name); |
| } |
| |
| private void dumpStatementList(StatementListNode stmts) |
| { |
| dumpNodeList(stmts.items); |
| } |
| private void dumpNodeList(ObjectList<Node> stmts) |
| { |
| for( Node n : stmts) |
| { |
| if( n instanceof FunctionDefinitionNode ) |
| dumpFunction((FunctionDefinitionNode)n); |
| else if( n instanceof VariableDefinitionNode ) |
| dumpVar((VariableDefinitionNode)n); |
| else if( n instanceof BinaryClassDefNode) |
| dumpClass((BinaryClassDefNode)n); |
| else if( n instanceof NamespaceDefinitionNode) |
| dumpNamespace((NamespaceDefinitionNode)n); |
| } |
| } |
| private void dumpFunction(FunctionDefinitionNode funcDef) |
| { |
| |
| if( funcDef.attrs != null) |
| System.out.print(attrsToString(funcDef.attrs)); |
| System.out.print("function "); |
| if( funcDef.fexpr.kind == Tokens.GET_TOKEN) |
| System.out.print("get "); |
| else if (funcDef.fexpr.kind == Tokens.SET_TOKEN) |
| System.out.print("set "); |
| System.out.print( typeRefToString(funcDef.fexpr.identifier.ref) ); |
| System.out.print("("); |
| if(funcDef.fexpr.signature.parameter != null) |
| { |
| ParameterListNode params = funcDef.fexpr.signature.parameter; |
| for(int i = 0; i < params.size(); ++ i) |
| { |
| ParameterNode param = params.items.get(i); |
| if(param != null && param.typeref != null) |
| { |
| System.out.print(typeRefToString(param.typeref) ); |
| } |
| System.out.print(", "); |
| } |
| } |
| System.out.print(")"); |
| if( funcDef.fexpr.signature.result != null) |
| { |
| System.out.println( " : " + typeRefToString( ((MemberExpressionNode)funcDef.fexpr.signature.result).ref) ); |
| } |
| } |
| |
| private void dumpVar(VariableDefinitionNode varDef) |
| { |
| if(varDef.attrs != null) |
| System.out.print(attrsToString(varDef.attrs)); |
| Node first = varDef.list.items.at(0); |
| System.out.print(" " + typeRefToString( ((VariableBindingNode)first).ref)); |
| System.out.println(" : " + typeRefToString( ((VariableBindingNode)first).typeref) ); |
| // /System.out.println(" Name: " + varDef.); |
| } |
| |
| private void dumpNamespace(NamespaceDefinitionNode nsDef) |
| { |
| System.out.print( attrsToString(nsDef.attrs) ); |
| System.out.println( " namespace " + nsDef.name.name + " = \"" + ((LiteralStringNode)nsDef.value).value + "\""); |
| |
| } |
| private String attrsToString(AttributeListNode attr) |
| { |
| String ret = ""; |
| if( attr.hasStatic ) |
| ret += "static "; |
| if( attr.hasPublic) |
| ret += "public "; |
| else if( attr.hasPrivate) |
| ret += "private "; |
| if(attr.hasOverride) |
| ret += " override "; |
| if(attr.hasFinal) |
| ret += " final "; |
| if(attr.namespaces.size() > 0) |
| ret += attr.namespaces.at(0).name + " "; |
| |
| return ret; |
| } |
| private String typeRefToString(ReferenceValue typeref) |
| { |
| String value = ""; |
| if( typeref.getImmutableNamespaces().size() == 1) |
| { |
| ObjectValue ns = typeref.getImmutableNamespaces().first(); |
| if( ns != null && !ns.name.equals("") ) |
| { |
| value = ns.name + ":"; |
| } |
| value += typeref.name; |
| } |
| else |
| { |
| value += "{"; |
| for( int i = 0; i < typeref.getImmutableNamespaces().size(); ++i ) |
| { |
| ObjectValue ns = typeref.getImmutableNamespaces().get(i); |
| value += ns.name + ", "; |
| } |
| value += "}:" + typeref.name; |
| } |
| return value; |
| } |
| */ |
| |
| public static void main(String[] args) throws Throwable |
| { |
| File abcFile = new File(args[0]); |
| byte[] bytes = getBytesFromFile(abcFile); |
| |
| TypeValue.init(); |
| ObjectValue.init(); |
| Context ctx = new Context(new ContextStatics()); |
| AbcParser abcParser = new AbcParser(ctx, bytes); |
| @SuppressWarnings("unused") |
| ProgramNode programNode = abcParser.parseAbc(); |
| |
| //System.out.println(programNode.toString()); |
| } |
| |
| private static byte[] getBytesFromFile(File file) throws IOException |
| { |
| FileInputStream is = new FileInputStream(file); |
| |
| // Get the size of the file |
| long length = file.length(); |
| |
| // Create the byte array to hold the data |
| byte[] bytes = new byte[(int)length]; |
| |
| // Read in the bytes |
| int offset = 0; |
| int numRead = 0; |
| while (offset < bytes.length |
| && (numRead=is.read(bytes, offset, bytes.length-offset)) >= 0) |
| { |
| offset += numRead; |
| } |
| |
| // Ensure all the bytes have been read in |
| if (offset < bytes.length) |
| { |
| throw new IOException("Could not completely read file "+file.getName()); |
| } |
| |
| // Close the input stream and return bytes |
| is.close(); |
| return bytes; |
| } |
| |
| } |
| |
